def run_iter(args): solvers, solver_options, general_options, seed = args for op in solver_options: op['seed'] = seed times = [] for s, s_ops in zip(solvers, solver_options): tstart = time.time() print "{} START TIME: {}".format(s, tstart) madhype.simulate_run([s], [s_ops], seed=seed, **general_options) tstop = time.time() times.append(tstop - tstart) return times
def collect_data(): # Set up run parameters solvers = ['madhype', 'alphabetr'] solver_options = [{'fdr': 0.05}, {'estimate_frequencies': False}] # Set up parameters that apply to all solvers/simulations general_options = { 'num_cells': 3000, 'cell_freq_constant': 2, 'cell_freq_max': 0.05, 'alpha_sharing_probs': None, 'beta_sharing_probs': None, 'num_wells': (96, ), 'cpw': (300, ), 'visual': False, 'fdr': 0.05, } repeats = 20 madhype_results = [] alphabetr_results = [] for rep in xrange(repeats): seed = random.randint(0, 1e6) print "Iteration {}: SEED {}".format(rep, seed) solver_options[1]['seed'] = seed _, results = madhype.simulate_run(solvers, solver_options, seed=seed, **ops) madhype_results.append(results[0]) alphabetr_results.append(results[1])
def collect_data(): # Set up run parameters solvers = ['madhype', 'alphabetr'] solver_options = [{ 'silent': True }, { 'silent': True, 'estimate_frequencies': False }] # Set up parameters that apply to all solvers/simulations general_options = { 'num_cells': 1000, 'cell_freq_constant': 2, 'cell_freq_max': 0.01, 'alpha_sharing_probs': None, 'beta_sharing_probs': None, 'visual': False, 'silent': True, } total_cells = 9600 total_wells = 96 w_range = np.arange(12, 96, 12) c_range = np.ceil(np.logspace(0, np.log10(total_cells / total_wells), 11)).astype(np.int) repeats = 10 madhype_results = {(c, w): [] for c, w in it.product(c_range, w_range)} alphabetr_results = {(c, w): [] for c, w in it.product(c_range, w_range)} print "Running simulations with the following settings:" print " Well partitions:", w_range print " CPW:", c_range print " # reps/condition", repeats for i, c in enumerate(c_range): for j, w in enumerate(w_range): num_wells = (w, total_wells - w) cpw = (c, int((total_cells - c * w) / (total_wells - w))) print "Number of wells: {}, cells per well: {}".format( num_wells, cpw) for rep in xrange(repeats): seed = random.randint(0, 1e6) print "Iteration {}: SEED {}".format(rep, seed) _, results = madhype.simulate_run(solvers, solver_options, num_wells=num_wells, cpw=cpw, seed=seed, **general_options) madhype_results[(c, w)].append(results[0]['frac_repertoire']) alphabetr_results[(c, w)].append(results[1]['frac_repertoire']) return madhype_results, alphabetr_results
def main(*args, **kwargs): """ Loads data, does some pretty basic simulations """ labels = ['Peripheral Blood (9-25 y)', 'Peripheral Blood (61-66 y)'] specific_settings = { # ranges 0.1% to 3% 'Peripheral Blood (9-25 y)': { 'cell_freq_max': 0.0025, 'cell_freq_constant': 1. + 1.21, 'num_cells': 10000, 'threshold': 2.0, 'block': False, 'num_wells': (48, 48), 'cpw': (500, 10000) }, 'Peripheral Blood (61-66 y)': { 'cell_freq_max': 0.086, 'cell_freq_constant': 1. + 1.15, 'num_cells': 10000, 'threshold': 2.0, 'block': True, 'num_wells': (48, 48), 'cpw': (500, 10000) }, } # figure specific properties fig, axes = plt.subplots(nrows=1, ncols=len(labels), figsize=(15, 4)) #plt.subplots_adjust(left=0.15,right=0.9,top=0.85,bottom=0.3,hspace=0.5,wspace=0.5) # some default settings solvers = ['madhype'] solver_options = [{}] for ind, label in enumerate(labels): settings = { 'plot_repertoire': { 'ax': axes[ind], 'fig': fig, }, 'visual': True, 'silent': False, 'legend': bool(ind), 'save': True, 'savename': 'figS1ab_{}.png', # where plots are saved 'alpha_dual_prob': 0.33, 'beta_dual_prob': 0.33, } specific_settings[label].update(settings) data, results = madhype.simulate_run(solvers, solver_options, **specific_settings[label]) plt.show(block=False) raw_input('Press enter to close...') plt.close()
def main(*args, **kwargs): modifications = { 'dual_prob': [.0, .1, .2, .3, .4, .5], #'dual_prob':[.0,.1], } labels = ['0%', '10%', '20%', '30%', '40%', '50%'] #labels = ['0%','10%'] repeats = 10 settings = default_settings() settings['cell_freq_max'] = 0.05 settings['num_cells'] = 1000 settings['cpw'] = (50, 1000) settings['num_wells'] = (48, 48) settings['chain_deletion_prob'] = 0.1 settings['chain_misplacement_prob'] = 0.0 all_coverage = {} all_matches = {} solvers = ['madhype'] solver_options = [{}] for first_mod, values in modifications.items(): for chain_sharing in [False, True]: if chain_sharing: mod = 'Chain sharing' else: mod = 'No chain sharing' all_coverage[mod] = [] all_matches[mod] = [] for i, v in enumerate(values): all_results = [] # iterate across system for r in xrange(repeats): specific_settings = copy.copy(settings) if first_mod == 'dual_prob': specific_settings['alpha_dual_prob'] = v specific_settings['beta_dual_prob'] = v else: specific_settings[first_mod] = v if chain_sharing == True: specific_settings['alpha_sharing_probs'] = None specific_settings['beta_sharing_probs'] = None else: specific_settings['alpha_sharing_probs'] = 0.0 specific_settings['beta_sharing_probs'] = 0.0 specific_settings['seed'] = r _, results = simulate_run(solvers, solver_options, **specific_settings) all_results += results all_coverage[mod].append( [results['frac_repertoire'] for results in all_results]) all_matches[mod].append([ float(results['positives']) / (settings['num_cells'] * (1 + 2 * v + v**2)) for results in all_results ]) # plot/display settings fs = 18 boxprops = dict(linewidth=3.0, zorder=1) meanlineprops = dict(linestyle='-', linewidth=2, color='black', zorder=0) plt.rcParams['xtick.labelsize'] = fs - 4 # figure specific properties fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10, 12), sharey=False) plt.subplots_adjust(left=0.15, right=0.9, hspace=0.3, wspace=0.4) # set border for figure for axe in axes: for ax in axe: [i.set_linewidth(3) for i in ax.spines.itervalues()] bp = axes[0][0].boxplot(all_matches['No chain sharing'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[0][0].set_title('No chain sharing', fontweight='bold', fontsize=fs) label_figure(axes[0][0], 'Dual Clone Probability (%)', 'Clonal Matches (%)', fs=fs) bp = axes[1][0].boxplot(all_coverage['No chain sharing'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) label_figure(axes[1][0], 'Dual Clone Probability (%)', 'Repertoire Coverage', fs=fs) bp = axes[0][1].boxplot(all_matches['Chain sharing'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[0][1].set_title('Chain sharing', fontweight='bold', fontsize=fs) label_figure(axes[0][1], 'Dual Clone Probability (%)', 'Clonal Matches (%)', fs=fs) bp = axes[1][1].boxplot(all_coverage['Chain sharing'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) label_figure(axes[1][1], 'Dual Clone Probability (%)', 'Repertoire Coverage', fs=fs) plt.show(block=False) raw_input('Press enter to close...') plt.savefig('fig_S5.png', format='png', dpi=300) plt.close()
def main(*args, **kwargs): mod_range = [.1, .15, .2, .25, .3, .35, .4] #mod_range = [.1,.4] #mod_range = [.0,.05,.1,.15,.2,.25] labels = ['{}%'.format(int(100 * m)) for m in mod_range] modifications = { 'chain_deletion_prob': mod_range, } repeats = 10 match_limit_low = 750 match_limit = 250 settings = default_settings() settings['cell_freq_max'] = 0.01 settings['num_cells'] = 1000 settings['cpw'] = (300, ) settings['chain_deletion_prob'] = 0.1 settings['chain_misplacement_prob'] = 0.0 settings['alpha_sharing_probs'] = None settings['beta_sharing_probs'] = None all_cm_fdr = {} all_rep_fdr = {} for sn in ['madhype', 'alphabetr']: if sn == 'madhype': solver_options = [{ 'threshold': 10., # minimum ratio accepted by match_probability }] elif sn == 'alphabetr': solver_options = [{}] solvers = [sn] all_cm_fdr[sn] = {} all_rep_fdr[sn] = {} for mod, values in modifications.items(): all_cm_fdr[sn][mod] = [] all_rep_fdr[sn][mod] = [] for i, v in enumerate(values): all_results = [] # iterate across system for r in xrange(repeats): specific_settings = copy.copy(settings) specific_settings[mod] = v specific_settings['seed'] = r data, results = simulate_run(solvers, solver_options, **specific_settings) results[0]['fdr_for_cm'] = _get_fdr_for_match_limit( data, results, match_limit) results[0]['fdr_for_rep'] = _get_fdr_for_match_limit( data, results, match_limit_low) print 'FDR (cm):', results[0]['fdr_for_cm'] print 'FDR (low cm):', results[0]['fdr_for_rep'] all_results += results all_cm_fdr[sn][mod].append( [results['fdr_for_cm'] for results in all_results]) all_rep_fdr[sn][mod].append( [results['fdr_for_rep'] for results in all_results]) # plot/display settings fs = 18 boxprops = dict(linewidth=3.0, zorder=1) meanlineprops = dict(linestyle='-', linewidth=2, color='black', zorder=0) plt.rcParams['xtick.labelsize'] = fs - 4 # figure specific properties fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(14, 12), sharey=False) plt.subplots_adjust(left=0.15, right=0.9, hspace=0.3, wspace=0.5) # set border for figure for axe in axes: for ax in axe: [i.set_linewidth(3) for i in ax.spines.itervalues()] bp = axes[0][0].boxplot(all_cm_fdr['madhype']['chain_deletion_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[0][0].set_title('MAD-HYPE', fontweight='bold', fontsize=fs) label_figure(axes[0][0], 'Chain Deletion Probability', 'FDR (%)', fs=fs) bp = axes[0][1].boxplot(all_cm_fdr['alphabetr']['chain_deletion_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[0][1].set_title('ALPHABETR', fontweight='bold', fontsize=fs) label_figure(axes[0][1], 'Chain Deletion Probability', 'FDR (%)', fs=fs) bp = axes[1][0].boxplot(all_rep_fdr['madhype']['chain_deletion_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[1][0].set_title('MAD-HYPE', fontweight='bold', fontsize=fs) label_figure(axes[1][0], 'Chain Deletion Probability', 'FDR (%)', fs=fs) bp = axes[1][1].boxplot(all_rep_fdr['alphabetr']['chain_deletion_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[1][1].set_title('ALPHABETR', fontweight='bold', fontsize=fs) label_figure(axes[1][1], 'Chain Deletion Probability', 'FDR (%)', fs=fs) plt.show(block=False) raw_input('Press enter to close...') plt.savefig('fig_S7.png', format='png', dpi=300) plt.close()
'seed': 1, } id_map = np.zeros((len(cpw_range), options['num_cells'])) for ii, num_wells in enumerate(num_wells_range): for i, cpw in enumerate(cpw_range): for seed in xrange(repeats): specific_options = copy.copy(options) specific_options['cpw'] = (cpw, ) specific_options['num_wells'] = (num_wells, ) specific_options['seed'] = seed _, results = simulate_run(solvers, solver_options, **specific_options) id_map[i, :] += results[0]['pattern'] print 'Finished cpw = {}!'.format(cpw) # display graph c_labels = [ v for v in [1, 10, 100, 1000, 10000] if v <= max(cpw_range) ] c_inds = [ min(range(len(cpw_range)), key=lambda i: abs(cpw_range[i] - v)) for v in c_labels ] fig, ax = plt.subplots()
def main(): """ Match probability as a function of w_a,w_b """ fig = plt.figure(figsize=(12, 10)) grid = plt.GridSpec(2, 2) ax1 = plt.subplot(grid[0, 0]) ax2 = plt.subplot(grid[0, 1]) ax3 = plt.subplot(grid[1, :]) fig = plt.gcf() plt.subplots_adjust(wspace=0.45, hspace=0.3) # Spanning parameters w_i_range = (0, 24) w_j_range = (0, 24) prior = 1e-5 # Create match built from parameters X, Y = np.mgrid[w_i_range[0]:w_i_range[1] + 1, w_j_range[0]:w_j_range[1] + 1] # Preallocate data matrix space Z = np.zeros((X.shape[0], Y.shape[1])) # Define default well distribution parameters well_data = { 'w_ij': (24, ), 'w_o': (48, ), 'w_tot': (96, ), 'cpw': (10, ), 'alpha': 2 } plt.sca(ax1) for i in xrange(X.shape[0]): for j in xrange(Y.shape[1]): well_data['w_i'] = (X[i, j], ) well_data['w_j'] = (Y[i, j], ) val = 10**(-match_probability(well_data, prior)[0]) Z[i, j] = 1. / (1. + val) matplotlib.rcParams['xtick.labelsize'] = 16 matplotlib.rcParams['ytick.labelsize'] = 16 #cax = ax.imshow(data,interpolation='nearest') #ax.set_aspect(aspect='auto') pcm = ax1.pcolor(X, Y, Z, norm=colors.Normalize(vmin=0, vmax=1), cmap='PuBu_r') cbar = fig.colorbar(pcm, ax=ax1) cbar.ax.tick_params(labelsize=16) cbar.set_ticks([0, .5, 1]) cbar.set_ticklabels(['0%', '50%', '100%']) #ax.set_yticks(c_inds) #ax.set_yticklabels(c_labels) ax1.tick_params(width=3, length=8, labelsize=18) plt.xticks([0, 10, 20]) plt.yticks([0, 10, 20]) plt.xlabel('$w_{i}$', fontsize=20) plt.ylabel('$w_{j}$', fontsize=20) #cbar.ax.set_yticklabels(['0%','100%']) # vertically oriented colorbar # some default settings solvers = ['madhype'] solver_options = [{}] settings = { 'plot_auroc': True, 'plot_auroc_options': { 'ax': ax2, 'fig': fig, }, 'plot_repertoire': True, 'plot_repertoire_options': { 'ax': ax3, 'fig': fig, }, 'visual': True, 'silent': False, } data, results = madhype.simulate_run(solvers, solver_options, **settings) plt.savefig('Figure3.png')
def main(*args,**kwargs): modifications = { 'chain_deletion_prob':[.0,.1,.2,.3,.4,.5,.75], 'chain_misplacement_prob':[.0,.1,.2,.3,.4,.5,.75] } repeats = 10 settings = default_settings() settings['cell_freq_max'] = 0.01 settings['num_cells'] = 1000 settings['cpw'] = (100,) settings['chain_deletion_prob'] = 0.0 settings['chain_misplacement_prob'] = 0.0 all_coverage = {} all_matches = {} solvers = ['madhype'] solver_options = [{}] # for mod,values in modifications.items(): #all_results = [] all_coverage[mod] = [] all_matches[mod] = [] for i,v in enumerate(values): all_results = [] # iterate across system for r in xrange(repeats): specific_settings = copy.copy(settings) specific_settings[mod] = v specific_settings['seed'] = r _,results = simulate_run(solvers,solver_options,**specific_settings) all_results += results all_coverage[mod].append([results['frac_repertoire'] for results in all_results]) all_matches[mod].append([results['positives'] for results in all_results]) # plot/display settings fs = 18 boxprops = dict(linewidth=3.0,zorder=1) meanlineprops = dict(linestyle='-',linewidth=2, color='black', zorder=0) plt.rcParams['xtick.labelsize'] = fs-4 # figure specific properties fig,axes = plt.subplots(nrows=2, ncols=2, figsize=(10, 12), sharey=False) plt.subplots_adjust(left=0.15,right=0.9,hspace=0.3,wspace=0.4) # set border for figure for axe in axes: for ax in axe: [i.set_linewidth(3) for i in ax.spines.itervalues()] labels = ['0%','10%','20%','30%','40%','50%','75%'] bp = axes[0][0].boxplot( all_matches['chain_deletion_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True ) label_figure(axes[0][0],'Chain Deletion Probability','Clonal Matches (#)',fs=fs) bp = axes[0][1].boxplot( all_coverage['chain_deletion_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True ) label_figure(axes[0][1],'Chain Deletion Probability','Repertoire Coverage',fs=fs) bp = axes[1][0].boxplot( all_matches['chain_misplacement_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True ) label_figure(axes[1][0],'Chain Misplacement Probability','Clonal Matches (#)',fs=fs) bp = axes[1][1].boxplot( all_coverage['chain_misplacement_prob'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True ) label_figure(axes[1][1],'Chain Misplacement Probability','Repertoire Coverage',fs=fs) plt.show(block=False) raw_input('Press enter to close...') plt.savefig('figS2.png', format='png', dpi=300) plt.close()
def main(*args, **kwargs): modifications = {'prior_alpha': [.1, 0.5, 1.0, 2.0, 10]} repeats = 2 settings = default_settings() settings['cell_freq_max'] = 0.01 settings['num_cells'] = 100 settings['cpw'] = (100, ) settings['chain_deletion_prob'] = 0.1 settings['chain_misplacement_prob'] = 0.0 if os.path.isfile('figS3A_data.p'): (all_coverage, all_matches) = pickle.load(open('figS3A_data.p', 'rb')) else: all_coverage = {} all_matches = {} solvers = ['madhype'] solver_options = [{}] for mod, values in modifications.items(): all_results = [] try: all_coverage[mod] all_matches[mod] print 'Skipping {}!'.format(mod) continue except KeyError: all_coverage[mod] = [] all_matches[mod] = [] for i, v in enumerate(values): # iterate across system for r in xrange(repeats): specific_settings = copy.copy(settings) specific_settings[mod] = v specific_settings['seed'] = r _, results = simulate_run(solvers, solver_options, **specific_settings) all_results += results all_coverage[mod].append( [results['frac_repertoire'] for results in all_results]) all_matches[mod].append( [results['positives'] for results in all_results]) pickle.dump((all_coverage, all_matches), open('figS3A_data.p', 'wb')) # plot/display settings fs = 18 boxprops = dict(linewidth=3.0, zorder=1) meanlineprops = dict(linestyle='-', linewidth=2, color='black', zorder=0) plt.rcParams['xtick.labelsize'] = fs - 4 # figure specific properties fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10, 12), sharey=False) plt.subplots_adjust(left=0.15, right=0.9, hspace=0.3, wspace=0.5) # set border for figure for axe in axes: for ax in axe: [i.set_linewidth(3) for i in ax.spines.itervalues()] labels = ['0.1', '0.5', '1', '2', '10'] bp = axes[0][0].boxplot(all_matches['prior_alpha'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) label_figure(axes[0][0], r'Prior $\alpha$', 'Clonal Matches (#)', fs=fs) bp = axes[0][1].boxplot(all_coverage['prior_alpha'], labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) label_figure(axes[0][1], r'Prior $\alpha$', 'Repertoire Coverage', fs=fs) ##### HEATMAPS ##### print 'Start heatmaps...' settings = default_settings() settings['chain_deletion_prob'] = 0.1 settings['chain_misplacement_prob'] = 0.0 num_wells_range = [(48, ), (96, )] cpw_range = np.logspace(0, 4, 5, dtype=int) freq_range = np.logspace(-4, -1, 13) #cpw_range = np.logspace(0,3,4,dtype=int) #freq_range = np.logspace(-2,-1,3) repeats = 3 fs = 18 pickle_files = ['figS3C_data.p', 'figS3D_data.p'] for plot_ind, num_wells in enumerate(num_wells_range): if os.path.isfile(pickle_files[plot_ind]): id_map = pickle.load(open(pickle_files[plot_ind], 'rb')) else: id_map = np.zeros((len(freq_range), len(cpw_range))) for i, freq in enumerate(freq_range): for j, cpw in enumerate(cpw_range): print 'Starting f = {} / cpw = {}...'.format(freq, cpw) val = [] print 'Val:', id_map[i][j] if id_map[i][j] != 0.: print 'Skipping! {} found...'.format(id_map[i][j]) continue for r in xrange(repeats): if int(1. / freq) >= 5000 and cpw >= 1000: threshold = 2.0 else: threshold = 0.1 specific_settings = copy.copy(settings) specific_settings['num_wells'] = num_wells specific_settings['cpw'] = (cpw, ) specific_settings[ 'cell_freq_distro'] = 'uniform' # forces uniform #specific_settings['cell_freq_max'] = 0.0 # forces uniform specific_settings['num_cells'] = int( 1. / freq) # forces uniform specific_settings['threshold'] = threshold specific_settings['seed'] = r _, results = simulate_run(solvers, solver_options, **specific_settings) val.append(results[0]['frac_repertoire']) id_map[i][j] = np.mean(val) pickle.dump(id_map, open(pickle_files[plot_ind], 'wb')) axes[1][plot_ind].imshow(id_map, interpolation='nearest') axes[1][plot_ind].set_aspect(aspect='auto') # X axis c_labels = [ v for v in [1, 10, 100, 1000, 10000] if v <= max(cpw_range) and v >= min(cpw_range) ] c_inds = [ min(range(len(cpw_range)), key=lambda i: abs(cpw_range[i] - v)) for v in c_labels ] axes[1][plot_ind].set_xticks(c_inds) axes[1][plot_ind].set_xticklabels(c_labels) # Y axis c_labels = [ v for v in [1e-4, 1e-3, 1e-2, 1e-1] if v <= max(freq_range) and v >= min(freq_range) ] c_inds = [ min(range(len(freq_range)), key=lambda i: abs(freq_range[i] - v)) for v in c_labels ] axes[1][plot_ind].set_yticks(c_inds) axes[1][plot_ind].set_yticklabels(c_labels) plt.title('Identification of clones with {} wells'.format( num_wells[0])) axes[1][plot_ind].set_xlabel('Cells/Well', fontsize=fs) axes[1][plot_ind].set_ylabel('Clonal Frequency', fontsize=fs) # plot figure plt.show(block=False) raw_input('Press enter to close...') plt.savefig('Figure S3.png', format='png', dpi=300) plt.close()
cpws = [(100, ), (30, )] # Set up parameters that apply to all solvers/simulations general_options = { 'num_wells': (96, ), } fig, ax = plt.subplots(2, 1, figsize=(10, 10)) general_options['fig'] = fig for i, cpw in enumerate(cpws): # set the number of cells per well general_options['cpw'] = cpw general_options['ax'] = ax[i] # Run MAD-HYPE with default parameters data, results = madhype.simulate_run(solvers, solver_options, **general_options) plot_comparison(results, **general_options) # Print out results for solver, result in zip(solvers, results): print "{} Results:".format(solver) print " Total # Cells:", result['total'] print " Chain pairs identified:", result['positives'] print " Chain pairs not identified:", result['negatives']
def main(): settings = { } # update settings #for arg in args: settings.update(arg) #settings.update(kwargs) """ Match probability as a function of w_a,w_b """ fig1,ax1 = plt.subplots(3,1,figsize=(8,12)) fig2,ax2 = plt.subplots(1,3,figsize=(15,4)) fig = plt.gcf() plt.subplots_adjust(wspace=0.45,bottom=0.2) #plt.subplots_adjust(left=0.1,right=0.9,wspace=0.25, hspace=0.2) # some default settings solvers = ['madhype'] solver_options = [{}] base_settings = { 'plot_repertoire': { 'ax':ax1, 'fig':fig1, }, 'plot_frequency_estimation': { 'ax':ax2, 'fig':fig2, 'figsize': (12,9), 'xlim':((2.)*(10.**-4),(6./5)*(10.**-2)), 'ylim':((2.)*(10.**-4),(6./5)*(10.**-2)), }, 'num_cells':1000, 'cell_freq_max': 0.01, # 0.01 'cell_freq_constant': 2, 'visual': True, 'silent': False, } settings_list = [ { 'num_wells':(42,54), 'cpw':(25,1758), }, { 'num_wells':(60,36), 'cpw':(159,2402), }, { 'num_wells':(96,), 'cpw':(1000,), }, ] for i,sub_settings in enumerate(settings_list): specific_options = copy.copy(base_settings) specific_options.update(sub_settings) specific_options['plot_repertoire']['ax'] = ax1[i] specific_options['plot_frequency_estimation']['ax'] = ax2[i] _,results = madhype.simulate_run(solvers, solver_options, **specific_options) fig1.savefig('Figure 5B.png', format='png', dpi=300) fig2.savefig('Figure 5C.png', format='png', dpi=300) plt.show(block=False) raw_input('Press enter to close...') plt.close()
def main(*args,**kwargs): """ Loads data, does some pretty basic simulations """ fnames = { 'Adjacent Tissue':'PTC.txt', 'Tumor Tissue':'TTC.txt' } specific_settings = { 'Adjacent Tissue':{ 'num_cells':1000, 'num_wells':(48,48), 'cpw':(50,1000) }, 'Tumor Tissue':{ 'num_cells':1000, 'num_wells':(48,48), 'cpw':(50,1000) } } # figure specific properties #fig,axes = plt.subplots(nrows=2, ncols=len(fnames), figsize=(12,12), sharey=False) #plt.tight_layout() #plt.subplots_adjust(left=0.15,right=0.9,top=0.85,bottom=0.3,hspace=0.5,wspace=0.5) fs = 18 # iterate across sample/data sets for ind,(sample,fname) in enumerate(fnames.items()): #ax = axes[ind][0] #plt.sca(ax) with open('./figures/'+fname) as f: data = f.readlines() data = [float(x.strip()) for x in data] data = [x/sum(data) for x in data] options = {'maxiters':10000} alpha = minimize(_error,1.0,data,method = 'Nelder-Mead',tol=1e-12,options=options) alpha = 1. + 1./alpha.x print 'Sample: {} / Alpha: {}'.format(sample,alpha) #[i.set_linewidth(3) for i in axes[ind][0].spines.itervalues()] ''' ax.set_xscale('log') ax.set_yscale('log') ax.set_xlabel('Clonal Index',fontsize=fs,fontweight='bold') ax.set_ylabel('Clonal Frequency',fontsize=fs,fontweight='bold') ax.tick_params(width = 3,length=8,labelsize=18) #ax.tick_params(axis='y',pad=22) ax.scatter(xrange(1,len(data)+1), data,c='blue',s=55,marker='s') ax.scatter(xrange(1,len(data)+1), _power_law_distribution(len(data),max(data),alpha),c='red',s=30,marker='D') ''' #plt.yticks(rotation='vertical') # default settings settings = { 'cell_freq_constant': alpha, 'cell_freq_max': max(data), ''' 'plot_repertoire': { 'save': True, }, 'plot_frequency_estimation': { #'ax':axes[ind][1], #'fig':fig, 'save': True, }, ''' 'visual': False, 'display': False, 'silent': False, } # update settings with sample specific hyperparameters settings.update(specific_settings[sample]) solvers = ['alphabetr'] solver_options = [{}] data,results = madhype.simulate_run(solvers, solver_options, **settings) plt.subplots_adjust(left=0.125,right=0.9,top=0.9,bottom=0.1,hspace=0.4,wspace=0.4) plt.savefig('figure_S1cd.png',dpi=300)
def main(): # Set up run parameters solvers = ['madhype', 'alphabetr'] solver_options = [{}, {}] # don't change default parameters # variants cpws = [(10, ), (30, )] num_simulations = 5 # Set up parameters that apply to all solvers/simulations general_options = { 'num_wells': (96, ), } fig, ax = plt.subplots(2, 1, figsize=(10, 10)) general_options['fig'] = fig matches_by_cpw = {} coverage_by_cpw = {} for _, cpw in enumerate(cpws): print 'Running simulations with {} cpw...'.format(cpw) # set the number of cells per well general_options['cpw'] = cpw matches_by_cpw[cpw] = dict([(s, []) for s in solvers]) coverage_by_cpw[cpw] = dict([(s, []) for s in solvers]) for index in xrange(num_simulations): print 'Starting simulation {}/{}...'.format( index + 1, num_simulations) # Run MAD-HYPE with default parameters data, results = madhype.simulate_run(solvers, solver_options, **general_options) # iterate across data for method_name, result in zip(solvers, results): matches_by_cpw[cpw][method_name].append(result['positives']) coverage_by_cpw[cpw][method_name].append( result['frac_repertoire']) ### START FIGURE ### # settings boxprops = dict(linewidth=3.0, zorder=1) meanlineprops = dict(linestyle='-', linewidth=2, color='black', zorder=0) fs = 18 # figure specific properties fig, axes = plt.subplots(nrows=len(cpws), ncols=1, figsize=(2 * len(cpws) + 1, 12), sharey=False) plt.subplots_adjust(left=0.3, right=0.9, hspace=1.0, wspace=1.0) # set border for figure for ax in axes: [i.set_linewidth(3) for i in ax.spines.itervalues()] matches = [matches_by_cpw[c][s] for s in solvers for c in cpws] coverage = [coverage_by_cpw[c][s] for s in solvers for c in cpws] labels = ['$N$ = {}'.format(c) for _ in xrange(2) for c in cpws] # boxplot matches bp = axes[0].boxplot(matches, labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[0].plot((2.5, 2.5), (0, 1000), linestyle='--', color='k') setBoxColors(bp) axes[0].set_xticks((1.5, 3.5)) axes[0].set_xticklabels(('100', '1000'), fontsize=fs) axes[0].set_xlabel('Cells/well (#)', fontsize=fs) axes[0].set_ylim((0, 1000)) axes[0].set_yticks((0, 250, 500, 750, 1000)) axes[0].set_yticklabels((0, 250, 500, 750, 1000), fontsize=fs) axes[0].set_ylabel('Clonal Matches (#)', fontsize=fs) # boxplot coverage bp = axes[1].boxplot(coverage, labels=labels, boxprops=boxprops, meanprops=meanlineprops, widths=0.6, meanline=True, showmeans=True) axes[1].plot((2.5, 2.5), (0, 1), linestyle='--', color='k') setBoxColors(bp) axes[1].set_xticks((1.5, 3.5)) axes[1].set_xticklabels(('N = 100', 'N = 1000'), fontsize=fs) axes[1].set_xlabel('Cells/well', fontsize=fs) axes[1].set_ylim((0., 1.)) axes[1].set_yticks((0., .5, 1.)) axes[1].set_yticklabels(('0%', '50%', '100%'), fontsize=fs) axes[1].set_ylabel('Repertoire Coverage', fontsize=fs) plt.show(block=False) raw_input('Press enter to close...') plt.savefig('fig4C.png', format='png', dpi=200) plt.close()