def issue_21_basic_scatter_plots(dataset): """ Makes scatter plots of fitness """ from plotting import make_color_grouped_scatter_plot folder = make_issue_specific_figure_folder('21_scatter_plots', dataset) fit_data, par_data, gen, ids = IO.load_pickled_generation_dataframe(dataset_name=dataset) #colormap = brewer2mpl.get_map('YlOrRd', 'Sequential', 9, reverse=True) colormap = brewer2mpl.get_map('Spectral', 'Diverging', 9, reverse=True) print "Making scatter plots of fitness data for dataset %s"%dataset filename = folder + 'a.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='overshoot', y_name='time_to_reach_new_fundamental', color_by='stdev', filename=filename, colormap = colormap, y_function='log') filename = folder + 'b.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='overshoot', y_name='stdev', color_by='time_to_reach_new_fundamental', filename=filename, colormap = colormap) filename = folder + 'c.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='time_to_reach_new_fundamental', y_name='round_stable', color_by='stdev', filename=filename, colormap = colormap) filename = folder + 'd.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='stdev', y_name='round_stable', color_by='time_to_reach_new_fundamental', filename=filename, colormap = colormap, x_function='log', y_function='log') filename = folder + 'e.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='stdev', y_name='time_to_reach_new_fundamental', color_by='round_stable', filename=filename, colormap = colormap, x_function='log', y_function='log') filename = folder + 'f.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='time_to_reach_new_fundamental', y_name='stdev', color_by='round_stable', filename=filename, colormap = colormap) filename = folder + 'g.png' make_color_grouped_scatter_plot(data_frame=fit_data, x_name='time_to_reach_new_fundamental', y_name='stdev', color_by='round_stable', filename=filename, colormap = colormap, x_function='log', y_function='log', color_function='log')
def test(dataset, overshoot_threshold): from numpy import where, zeros from sklearn.neighbors.kde import KernelDensity folder = make_issue_specific_figure_folder('108 cluster after removing outliers', dataset) fit, par, gen, ids = IO.load_pickled_generation_dataframe(dataset) o = where(fit.overshoot > overshoot_threshold)[0] #not_o = where(fit.overshoot <= overshoot_threshold)[0] par = par.drop(o) fit = fit.drop(o) g1 = par.groupby('ssmm_nAgents').groups.keys() g2 = par.groupby('ssmm_latency_mu').groups.keys() #stdev_mean = zeros((len(g1), len(g2))) data = DataFrame(columns=['ssmm_nAgents', 'ssmm_latency_mu', 'stdev_mean']) for a, ssmm_nAgents in enumerate(g1): print ssmm_nAgents for l, ssmm_latency_mu in enumerate(g2): row = dict() try: row['stdev_mean'] = fit[(par['ssmm_latency_mu'] == ssmm_latency_mu) & (par['ssmm_nAgents'] == ssmm_nAgents)]['stdev'].mean() row['ssmm_nAgents'] = ssmm_nAgents row['ssmm_latency_mu'] = ssmm_latency_mu #print row data = data.append(row, ignore_index = True) except TypeError: print "ARGHS" X, Y = np.meshgrid(g1.groups.keys(), g2.groups.keys()) xy = np.vstack([Y.ravel(), X.ravel()]).T return data
def filter_and_print_tables(dataset): from plotting import plot_group_overlap from utils import make_issue_specific_figure_folder def make_dataframe(l): ldf = concat(l, axis=1) ldf.columns = columns tdf = ldf.transpose() tdf.columns = utils.get_latex_par_names([tdf], as_row = True).split(',') tdf = tdf.transpose() return tdf fnums = [1,2,3,4,5,6,7,8,9] #fit, par, gen, ids = IO.load_pickled_generation_dataframe(dataset) fit, par = utils.load_d10d11() masks, filters = apply_filters(fit, fnums = fnums) jaccard = calculate_jaccard(masks) columns = map(lambda x: 'F%s'%x, fnums) parmeans = make_dataframe(map(lambda f: par[f()].mean(), filters)) fitmeans = make_dataframe(map(lambda f: fit[f()].mean(), filters)) counts = make_dataframe(map(lambda f: par[f()].count(), filters)) full_table = concat([parmeans, fitmeans]) counts = counts.iloc[0] counts.name = 'Count' full_table = full_table.append(counts) tex = full_table.to_latex(float_format=lambda x: str(round(x,1))) full_tex = utils.prettify_table(tex, 'table:manual_filtering_%s'%dataset, 'XXX').replace('nan','N/A') print full_tex folder = make_issue_specific_figure_folder('manual_filtering', dataset) plot_group_overlap(folder + 'group_overlap', jaccard) return jaccard
def latency_vs_fitness_with_lines_for_agent_ratio(dataset): from plotting import multiline_xy_plot from utils import make_issue_specific_figure_folder def get_ssmmlat_mask(l, u): return (p.ssmm_latency_mu > l) & (p.ssmm_latency_mu < u) def get_sclat_mask(l, u): return (p.sc_latency_mu > l) & (p.sc_latency_mu < u) def zip_to_tuples(r): return zip(r[:-1], r[1::]) def calc_and_plot(ratio_direction): for fitness in f.columns: ssmm_ys = list() sc_ys = list() legend_labels = list() for ratio_lower, ratio_upper in zip_to_tuples(ratio_range): ratio_mask = (ratio_lower < p.ratio) & (p.ratio < ratio_upper) ssmm_lat_range = concat(map(lambda l: f[get_ssmmlat_mask(l,l+20) & ratio_mask].mean(), ssmmlatencyrange), axis=1).transpose() ssmm_ys.append(ssmm_lat_range[fitness]) sc_lat_range = concat(map(lambda l: f[get_sclat_mask(l,l+20) & ratio_mask].mean(), sclatencyrange), axis=1).transpose() sc_ys.append(sc_lat_range[fitness]) legend_labels.append(r'$\displaystyle %s < %s < %s$'%(round(ratio_lower,1), fl(ratio_direction, mathmode = False), round(ratio_upper,1))) filename = '%s_%s_%s_mmlatency.png'%(folder, ratio_direction, fitness) multiline_xy_plot(ssmm_lat_range.index, ssmm_ys, xlabel = 'ssmm_latency_mu', ylabel = fitness, legend_labels = legend_labels, filename = filename) filename = '%s_%s_%s_sclatency.png'%(folder, ratio_direction, fitness) multiline_xy_plot(sc_lat_range.index, sc_ys, xlabel = 'sc_latency_mu', ylabel = fitness, legend_labels = legend_labels, filename = filename) ssmmlatencyrange = range(100) sclatencyrange = range(100) folder = make_issue_specific_figure_folder('latency_vs_fitness_with_lines_for_agent_ratio', dataset) if dataset == 'd10d11': f, p = utils.load_d10d11() else: f,p,g, i=IO.load_pickled_generation_dataframe(dataset_name=dataset) if dataset == 'd10': p['sc_nAgents'] = 150 elif dataset == 'd11': p['ssmm_nAgents'] = 52 #nssmm_mask = p.ssmm_nAgents > 50 #f = f[nssmm_mask] #p = p[nssmm_mask] p['ratio'] = p['sc_nAgents'].astype(float) / p['ssmm_nAgents'] ratio_range = np.linspace(0,3,6) calc_and_plot('ratioagent') p['ratio'] = p['ssmm_nAgents'].astype(float) / p['sc_nAgents'] ratio_range = [0,0.01, 0.2,0.35,0.6,1] calc_and_plot('ratioagentinv')
def issue_118_fitness_corelation_matrix(dataset): import IO from plotting import plot_correlation_matrix from utils import format_as_latex_parameter as fl folder = make_issue_specific_figure_folder('fitness_correlation', dataset) f,p,g, i=IO.load_pickled_generation_dataframe(dataset) mask = f.overshoot < 5 c = np.corrcoef(f[mask].transpose()) labels = map(fl, f.columns) plot_correlation_matrix(folder + 'correlation_matrix.png', c, labels)
def issue_101_plot_pars_vs_fitness(dataset, overshoot_threshold, preloaded_data = None): from plotting import get_pretty_xy_plot, make_pretty_scatter_plot from numpy import where def get_plots_to_make(fitness_types): plots_to_make = list() for fitness_type in fitness_types: for stat in stats: plots_to_make.append((fitness_type, stat)) return plots_to_make def mkplot(all_data, groupby, plots_to_make): g = all_data.groupby(groupby) #x = g.groups.keys() s = all_data.sort(groupby) sorted_x, index_order = zip(*sorted(zip(g.groups.keys(), range(len(g.groups.keys()))))) for attr, stat in plots_to_make: print groupby, attr, stat y = getattr(g[attr],stat)() filename = '%s%s__vs__%s(%s)'%(folder, groupby, attr, stat) ax, fig = get_pretty_xy_plot(sorted_x, y, groupby, '%s (%s)'%(attr, stat), filename, g[attr].std()/2, save_figure = False) filename = '%s%s__vs__%s(%s)_scatter'%(folder, groupby, attr, stat) make_pretty_scatter_plot(s[groupby], s[attr], groupby, '%s (%s)'%(attr, stat), filename, ax=ax, fig=fig) def run_analysis(groups, data, plots_to_make): for groupby in groups: mkplot(data, groupby, plots_to_make) folder = make_issue_specific_figure_folder('101_pars_vs_fits', dataset) stats = ['mean'] if dataset == 'd10d11': f, p = utils.load_d10d11() else: f,p,g, i=IO.load_pickled_generation_dataframe(dataset_name=dataset) if 'dataset' == 'd10': p['sc_nAgents'] = 150 elif 'dataset' == 'd11': p['ssmm_nAgents'] = 52 if preloaded_data is None: fit, par, gen, ids = IO.load_pickled_generation_dataframe(dataset) else: try: fit = preloaded_data['fit'] par = preloaded_data['par'] except KeyError, e: print "Provide dict with keys 'fit' and 'par' containing dataframes for fit and par data" print e sys.exit(1)
def agent_ratio_to_latency_ratio(n_ar_bins = 10, n_lr_bins = 10, dataset = 'd10d11'): from plotting import plot_image_matrix from utils import make_issue_specific_figure_folder folder = make_issue_specific_figure_folder('latency_vs_agent_ratios', dataset) fit, par = utils.load_d10d11() #fit, par, gen, ids = IO.load_pickled_generation_dataframe('d10') agent_ratio = par.sc_nAgents.astype(float) / par.ssmm_nAgents latency_ratio = par['ssmm_latency_mu'].astype(float) / par['sc_latency_mu'] inf_mask = agent_ratio != np.inf agent_ratio_mask = (agent_ratio < 5) latency_ratio_mask = (latency_ratio > 0) & (latency_ratio < 5) #nsc_mask = par.sc_nAgents > 0 #nssmm_mask = (20 < par.ssmm_nAgents) & (par.ssmm_nAgents < 50) #total_mask = inf_mask & agent_ratio_mask & latency_ratio_mask & nsc_mask & nssmm_mask total_mask = inf_mask & agent_ratio_mask & latency_ratio_mask par = par[total_mask] fit = fit[total_mask] agent_ratio = agent_ratio[total_mask] latency_ratio = latency_ratio[total_mask] ar_hn, ar_histbins = np.histogram(agent_ratio, bins = n_ar_bins) lr_hn, lr_histbins = np.histogram(latency_ratio, bins = n_lr_bins) print ar_histbins overshoot_mean = np.zeros((n_ar_bins, n_lr_bins)) roundstable_mean = np.zeros((n_ar_bins, n_lr_bins)) stdev_mean = np.zeros((n_ar_bins, n_lr_bins)) timeto_mean = np.zeros((n_ar_bins, n_lr_bins)) test = np.zeros((n_ar_bins, n_lr_bins)) for i, (ar_lower, ar_upper) in enumerate(zip(ar_histbins[:-1], ar_histbins[1::])): for j, (lr_lower, lr_upper) in enumerate(zip(lr_histbins[:-1], lr_histbins[1::])): index_mask = (ar_lower < agent_ratio) & (agent_ratio < ar_upper) & (lr_lower < latency_ratio) & (latency_ratio < lr_upper) means = fit[index_mask].mean() overshoot_mean[i][j] = means['overshoot'] roundstable_mean[i][j] = means['round_stable'] stdev_mean[i][j] = means['stdev'] timeto_mean[i][j] = means['time_to_reach_new_fundamental'] test[i][j] = j x_ticklabels = map(lambda x: round(x,1), lr_histbins) y_ticklabels = map(lambda x: round(x,1), ar_histbins) plot_image_matrix(folder + 'overshoot.png', overshoot_mean, x_ticklabels, y_ticklabels) plot_image_matrix(folder + 'stdev.png', stdev_mean, x_ticklabels, y_ticklabels) plot_image_matrix(folder + 'time_to_reach_new_fundamental.png', timeto_mean, x_ticklabels, y_ticklabels) plot_image_matrix(folder + 'round_stable.png', roundstable_mean, x_ticklabels, y_ticklabels) x_ticklabels = range(10) y_ticklabels = range(10) plot_image_matrix(folder + 'test.png', test, x_ticklabels, y_ticklabels) return overshoot_mean, stdev_mean, roundstable_mean, timeto_mean
def issue_130_overvaluation_scatter(): from plotting import make_scatter_plot_for_labelled_data folder = make_issue_specific_figure_folder('issue_130_overvaluation_scatter', 'd10') colormap = brewer2mpl.get_map('RdBu', 'Diverging', 11, reverse=True) ind = IO.load_pickled_generation_dataframe('d10', True) mask = ind.ssmm_latency_mu > 0 #plot(ind.ssmm_nAgents[mask], ind.ssmm_latency_mu[mask], 'r.'); xlab = r'$N_m$' ylab = r'$\lambda_{m,\mu}$' l = np.repeat(10, len(ind[mask])) filename = folder + 'scatter.png' make_scatter_plot_for_labelled_data(ind[mask], 'ssmm_nAgents', 'ssmm_latency_mu', l, filename, colormap, point_size = 20)
def issue_113_make_all_tradeprice_plots(): from plotting import make_pretty_tradeprice_plot data_folder = '/Users/halfdan/Dropbox/Waseda/Research/MarketSimulation/Thesis/data_for_tradeprice_plots/' mapping = { 'gen12_1386710381616696.npz' : 'low_stdev_but_not_stable', 'gen56_1388690478773536.npz' : 'low_stdev_and_stable', 'gen13_1387568360402236.npz' : 'high_stdev_but_stable' } figure_folder = make_issue_specific_figure_folder('issue_113_tradeprice_plots', 'all') for dataname, plotname in mapping.items(): rounds, prices = IO.load_tradeprice_data(data_folder + dataname) #make_pretty_tradeprice_plot(rounds, prices, figure_folder + plotname, dpi = 200, figsize=tuple(map(lambda x: x*1, [8,4])), format = 'pdf') make_pretty_tradeprice_plot(rounds, prices, figure_folder + plotname, dpi = 200, format = 'pdf')
def average_par_vs_fitnesses(dataset): from plotting import multiline_xy_plot folder = make_issue_specific_figure_folder('average_par_vs_fitness_lineplot', dataset) """ TRIED AND FAILED TO MAKE THE WHOLE THING WITHOUT A LOOP USING MAPS INSTEAD def mkplot(fitness): fitness = 'overshoot' mask = f < f.quantile(0.9) masked_f = f[mask] hists = map(lambda x: np.histogram(x, bins = 50), map(lambda x: list(masked_f[x]), masked_f.columns)) bins = list(zip(*bins)[1]) bins = DataFrame(np.transpose(bins), columns = masked_f.columns) ws = bins.iloc[1,:] - bins.iloc[0,:] counts, bins = np.histogram(f[fitness][mask], bins=50) return mask, bins ws = bins[1] - bins[0] means = concat(map(lambda x: p[(f[fitness][mask] > x - ws) & (f[fitness][mask] < x + ws)].mean(), bins), axis=1).transpose() means_as_list = map(lambda x: list(means[x]), means.columns) xlabel = fl(fitness) ylabel = '' legend_labels = map(fl, means.columns) filename = folder + '%s.png'%fitness multiline_xy_plot(bins, means_as_list, xlabel, ylabel, legend_labels, filename) """ def mkplot(fitness): mask = f[fitness] < f[fitness].quantile(0.95) mask &= f.overshoot < 5 masked_fit = f[mask][fitness] masked_par = p[mask] counts, bins = np.histogram(masked_fit, bins = 50) ws = (bins[1] - bins[0]) means = concat(map(lambda bin: masked_par[(masked_fit > bin - ws) & (masked_fit < bin + ws)].mean(), bins), axis=1).transpose() means_as_list = map(lambda x: list(means[x]), means.columns) xlabel = fl(fitness) ylabel = '' legend_labels = map(fl, means.columns) filename = folder + '%s.png'%fitness multiline_xy_plot(bins, means_as_list, xlabel, ylabel, legend_labels, filename) f,p,g, i=IO.load_pickled_generation_dataframe(dataset) for fitness in f.columns: mkplot(fitness)
def faster_mm_many_chartists(): from plotting import multiline_xy_plot folder = make_issue_specific_figure_folder('par_tendencies', 'all') def mkplot(filename, line_parameter, intervals_for_lines, range_parameter, fitness_type, legend_caption, xlabel, ylabel): ylines = list() labels = list() x = list(set(p[range_parameter])) for lb, ub in zip(intervals_for_lines[:-1], intervals_for_lines[1::]): line = map(lambda l: f[(p[range_parameter] == l) & (lb <= p[line_parameter]) & (p[line_parameter] < lb + ub)][fitness_type].mean(), set(p[range_parameter])) ylines.append(line) labels.append('%s < %s < %s'%(lb,legend_caption, ub)) line = map(lambda l: f[(p[range_parameter] == l) & (intervals_for_lines[-1] <= p[line_parameter])][fitness_type].mean(), set(p[range_parameter])) ylines.append(line) labels.append('%s < %s '%(intervals_for_lines[-1], legend_caption)) print xlabel print ylabel print labels multiline_xy_plot(x, ylines, ylabel = ylabel, xlabel=xlabel, filename = filename, y_errorbars = None, save_figure = True, legend_labels = labels) f,p,g,i = IO.load_pickled_generation_dataframe('d11') filename = folder + 'd11_overshoot_mm_latency.png' mkplot(filename = filename, line_parameter='sc_nAgents', intervals_for_lines = [0, 50, 100], range_parameter='ssmm_latency_mu', fitness_type='overshoot', legend_caption = '# chartists', xlabel = 'Average market maker latency', ylabel = 'Average model overshoot') filename = folder + 'd11_overshoot_chartist_latency.png' mkplot(filename = filename, line_parameter='sc_nAgents', intervals_for_lines = [0, 50, 100], range_parameter='sc_latency_mu', fitness_type='overshoot', legend_caption = '# chartists', xlabel = 'Average chartist latency', ylabel = 'Average model overshoot') f,p,g,i = IO.load_pickled_generation_dataframe('d10') filename = folder + 'd10_overshoot_mm_latency.png' mkplot(filename = filename, line_parameter='ssmm_nAgents', intervals_for_lines = [0, 50, 100], range_parameter='ssmm_latency_mu', fitness_type='overshoot', legend_caption = '# market makers', xlabel = 'Average market maker latency', ylabel = 'Average model overshoot') filename = folder + 'd10_overshoot_chartist_latency.png' mkplot(filename = filename, line_parameter='ssmm_nAgents', intervals_for_lines = [0, 50, 100], range_parameter='sc_latency_mu', fitness_type='overshoot', legend_caption = '# market makers', xlabel = 'Average chartist latency', ylabel = 'Average model overshoot') filename = folder + 'd10_overshoot_ssmm_nAgents.png' mkplot(filename = filename, line_parameter='ssmm_latency_mu', intervals_for_lines = [0, 20, 40, 60], range_parameter='ssmm_nAgents', fitness_type='overshoot', legend_caption = 'ssmm latency', xlabel = 'Average # market makers', ylabel = 'Average model overshoot')
def d9_diagional_points(n_centers = 100): from plotting import get_pretty_xy_plot def getidx(center, max_dist_to_diagonal = 400, averaging_window_size = 5000): cond1 = (np.abs(fit.time_to_reach_new_fundamental - fit.round_stable) < max_dist_to_diagonal) cond2 = (fit.time_to_reach_new_fundamental > center - averaging_window_size) cond3 = (fit.time_to_reach_new_fundamental < center + averaging_window_size) return cond1 & cond2 & cond3 folder = make_issue_specific_figure_folder('diagional_points', 'd9') fit, par, gen, ids = IO.load_pickled_generation_dataframe('d9') centers_to_calculate = np.linspace(10000, 90000, n_centers) list_of_dataframes = map(lambda i: par[getidx(i, 1000, 5000)], centers_to_calculate) mean_frame = concat(map(lambda x: getattr(x, 'mean')(), list_of_dataframes), axis=1).transpose() std_frame = concat(map(lambda x: getattr(x, 'std')(), list_of_dataframes), axis=1).transpose() for parameter in mean_frame.columns: filename = folder + parameter + '.png' #print mean_frame[parameter] y1 = mean_frame[parameter] - std_frame[parameter] y2 = mean_frame[parameter] + std_frame[parameter] ax, fig = get_pretty_xy_plot(x=centers_to_calculate, y=mean_frame[parameter], xlabel='Time to reach new fundamental', ylabel=parameter, filename = filename, save_figure = False) ax.fill_between(centers_to_calculate, y2.values, y1.values, color = 'gray', alpha = 0.5) fig.savefig(filename) return centers_to_calculate, mean_frame, std_frame
def issue_126_chartist_strategy(): from settings import default_parameters as dp import ppl as Ppp import pandas import matplotlib.pyplot as pp import brewer2mpl folder = make_issue_specific_figure_folder('agent_strategies', 'chartist') datapath = '/Users/halfdan/Dropbox/Waseda/Research/MarketSimulation/Thesis/data_for_figures/chartist_strategy/gen0_1387502533563458.npz' rounds, prices = IO.load_tradeprice_data(datapath) colors = brewer2mpl.get_map('Set1', 'qualitative', 9).mpl_colors pp.rc('text', usetex= True) pp.rc('font', family = 'serif') pp.rc('font', size = 14) def mkplot(filename, ma_width = 5000, tbr = 1): pp.figure() pp.plot(rounds, prices, alpha=0.5, color=colors[0]) rolling_mean = pandas.rolling_mean(prices, ma_width) pp.plot(rounds,rolling_mean, linewidth=2, color='black') pp.fill_between(rounds, rolling_mean-tbr, rolling_mean+tbr, color='gray', alpha=0.5, linewidth=0) pp.xlabel('Time (rounds)') pp.ylabel('Price (ticks)') pp.legend(['Price of trades', 'Chartist moving average']) pp.text(50000, 9995, '$H_c = %s$ (rounds)\n $\gamma_c = %s$ (ticks)'%(ma_width, tbr), fontsize = 16) print folder + filename pp.savefig(folder + filename) mkplot('a.png', 5000, 1) mkplot('b.png', 5000, 2) mkplot('c.png', 10000, 1) mkplot('d.png', 10000, 2) mkplot('e.png', 1000, 1) mkplot('f.png', 1000, 2) mkplot('g.png', 15000, 1) mkplot('h.png', 15000, 2) return rounds, prices
#from multiprocessing import Process, Queue from fitness import evaluate_simulation_results from multiprocessing import Pool from utils import make_issue_specific_figure_folder from other_issues import apply_filters import numpy as np if __name__ == "__main__": n_times_to_sample = 100 pool = Pool(sys.argv[1]) for dataset in ['d9','d10', 'd11']: fit, par, gen, ids = load_pickled_generation_dataframe(dataset) folder = make_issue_specific_figure_folder('tpgraphs_for_filter_simulations', dataset) sys.path.append(dataset_paths[dataset]) masks = apply_filters(dataset, return_masks=True) for i, mask in enumerate(masks): graph_folder = '%sfilter_%s/'%(folder,i) if not os.path.exists(graph_folder): os.makedirs(graph_folder) if len(np.where(mask)[0]) > 0: sampled_parameters = map(lambda x: par[mask].iloc[x,:], np.random.randint(0,len(par[mask]), n_times_to_sample)) merged_parameters = map(lambda x: merge_parameters('d9', sampled_parameters[x]), range(n_times_to_sample)) kwargs = map(lambda x: {'graph_folder':graph_folder, 'generation_number':0, 'reps':range(1), 'autorun':True, 'parameters':x}, merged_parameters) pool.map(helper, kwargs)
def issue_127_marketmaker_plots(): from settings import default_parameters as dp import ppl as Ppp import pandas import matplotlib.pyplot as pp import brewer2mpl folder = make_issue_specific_figure_folder('agent_strategies', 'marketmaker') colors = brewer2mpl.get_map('Set1', 'qualitative', 9).mpl_colors pp.rc('text', usetex= True) pp.rc('font', family = 'serif') pp.rc('font', size = 14) def plot_step(val_before_step, stepsize, time_of_step, xmin = 0, xmax = 14, **kwargs): pp.hlines(y=val_before_step, xmin=xmin, xmax=time_of_step, **kwargs) pp.vlines(x=time_of_step, ymin=val_before_step, ymax=val_before_step + stepsize, **kwargs) return pp.hlines(y=val_before_step + stepsize, xmin=time_of_step, xmax=xmax, **kwargs) pp.figure() pp.xlabel('Time (rounds)') pp.ylabel('Price (ticks)') mm_delay=6 pp.ylim(3,22) c1=plot_step(8, -3, 5, color='green', linewidth=3, alpha=0.5) c2=plot_step(12, 3, 2, color='blue', linewidth=3, alpha=0.5) c3=plot_step(8, -3, 5+mm_delay, color='green', linewidth=3, linestyle='dashed') c4=plot_step(12, 3, 2+mm_delay, color='blue', linewidth=3, linestyle='dashed') pp.text(2, 16, '$\delta = %s$'%mm_delay, fontsize = 20) pp.legend([c1,c2,c3,c4],['Best buy price', 'Best sell price', 'Agent buy price', 'Agent sell price']) pp.savefig(folder + 'a.png') pp.figure() pp.xlabel('Time (rounds)') pp.ylabel('Price (ticks)') mm_delay=6 pp.ylim(8,25) c3=plot_step(18, -2, 5, color='blue', linewidth=3, alpha=0.5) c4=plot_step(10, 3, 5, color='green', linewidth=3, alpha=0.5) c1=plot_step(18, -2, 5+mm_delay, color='blue', linewidth=3, linestyle='dashed') c2=plot_step(10, 2, 5+mm_delay, color='green', linewidth=3, linestyle='dashed') pp.fill_between([11,14],[12,12],[16,16], color='red', alpha=0.3, linewidth=0) pp.text(2, 21, '$\delta = %s$\n $\\theta = 4$'%mm_delay, fontsize = 20) pp.legend([c1,c2,c3,c4],['Best sell price', 'Best buy price', 'Agent sell price', 'Agent buy price']) pp.savefig(folder + 'b.png') pp.figure() pp.xlabel('Time (rounds)') pp.ylabel('Price (ticks)') mm_delay=6 pp.ylim(8,25) c1=plot_step(18, -3, 10, color='blue', linewidth=3, alpha=0.5, xmax=20) c2=plot_step(10, 3, 2, color='green', linewidth=3, alpha=0.5, xmax=20) c3=plot_step(18, -1, 10+mm_delay, color='blue', linewidth=3, linestyle='dashed', xmax=20) c4=plot_step(10, 3, 2+mm_delay, color='green', linewidth=3, linestyle='dashed', xmax=20) #pp.fill_between([0,8],[10,10],[14,14], color='red', alpha=0.3, linewidth=0) pp.fill_between([8,20],[13,13],[17,17], color='red', alpha=0.3, linewidth=0) pp.text(2, 22, '$\delta = %s$\n $\\theta = 4$'%mm_delay, fontsize = 20) pp.legend([c1,c2,c3,c4],['Best sell price', 'Best buy price', 'Agent sell price', 'Agent buy price']) pp.savefig(folder + 'c.png') pp.figure() pp.xlabel('Time (rounds)') pp.ylabel('Price (ticks)') mm_delay=6 pp.ylim(8,27) c1=plot_step(20, -3, 10, color='blue', linewidth=3, alpha=0.5, xmax=20) c2=plot_step(10, 3, 2, color='green', linewidth=3, alpha=0.5, xmax=20) c3=plot_step(20, -3, 10+mm_delay, color='blue', linewidth=3, linestyle='dashed', xmax=20) c4=plot_step(10, 3, 2+mm_delay, color='green', linewidth=3, linestyle='dashed', xmax=20) #pp.fill_between([0,8],[10,10],[14,14], color='red', alpha=0.3, linewidth=0) pp.fill_between([8,20],[13,13],[17,17], color='red', alpha=0.3, linewidth=0) pp.text(2, 22, '$\delta = %s$\n $\\theta = 4$'%mm_delay, fontsize = 20) pp.legend([c1,c2,c3,c4],['Best sell price', 'Best buy price', 'Agent sell price', 'Agent buy price']) pp.savefig(folder + 'd.png') pp.figure() pp.xlabel('Time (rounds)') pp.ylabel('Price (ticks)') mm_delay=6 pp.ylim(8,27) pp.xlim(0, 30) c1=plot_step(20, -3, 5, color='blue', linewidth=3, alpha=0.5, xmin = 0, xmax=12) plot_step(17, 2, 18, color='blue', linewidth=3, alpha=0.5, xmin = 12, xmax=30) c2=plot_step(10, 0, 5, color='green', linewidth=3, alpha=0.5, xmin = 0, xmax=30) #pp.fill_between([0,8],[10,10],[14,14], color='red', alpha=0.3, linewidth=0) #pp.fill_between([8,20],[13,13],[17,17], color='red', alpha=0.3, linewidth=0) #pp.text(2, 22, '$\lambda = %s$\n $\\theta = 4$'%mm_delay, fontsize = 20) #pp.legend([c1,c2,c3,c4],['Best sell price', 'Best buy price', 'Agent sell price', 'Agent buy price']) pp.savefig(folder + 'e.png')
def faster_mm_makes_worse_markets(dataset): from plotting import multiline_xy_plot from utils import make_issue_specific_figure_folder def get_mmlat_mask(l, u): return (p.ssmm_latency_mu > l) & (p.ssmm_latency_mu < u) def get_ssmmlatencyrange_mean(agent_mask, ssmmlatencyrange = range(1,100), nsc_lower = 0): return concat(map(lambda l: f[get_mmlat_mask(l,l+20) & agent_mask].mean(), ssmmlatencyrange), axis=1).transpose() def get_sclat_mask(l, u): return (p.sc_latency_mu > l) & (p.sc_latency_mu < u) def get_sclatencyrange_mean(agent_mask, sclatencyrange = range(1,100), nsc_lower = 0): return concat(map(lambda l: f[get_sclat_mask(l,l+20) & agent_mask].mean(), sclatencyrange), axis=1).transpose() def get_nchartist_mask(lower, upper): return (p.sc_nAgents >= lower) & (p.sc_nAgents < upper) def get_nmm_mask(lower, upper): return (p.ssmm_nAgents >= lower) & (p.ssmm_nAgents < upper) def zip_to_tuples(r): return zip(r[:-1], r[1::]) ssmmlatencyrange = range(80) sclatencyrange = range(100) if dataset == 'd10d11': f, p = utils.load_d10d11() else: f,p,g, i=IO.load_pickled_generation_dataframe(dataset_name=dataset) folder = make_issue_specific_figure_folder('faster_mm_makes_worse_markets', dataset) try: for fitness in f.columns: filename = folder + fitness + '_SC_mmlatency.png' xlabel = 'Market maker latency' ylabel = fitness legend_labels = list() ys = list() for nsc_lower, nsc_upper in zip_to_tuples(np.linspace(0,500,6)): nchartist_mask = get_nchartist_mask(nsc_lower, nsc_upper) means = get_ssmmlatencyrange_mean(nchartist_mask, ssmmlatencyrange, nsc_lower = nsc_lower) ys.append(means[fitness]) legend_labels.append('%s <= # SC < %s'%(nsc_lower, nsc_upper)) multiline_xy_plot(means.index, ys, xlabel, ylabel, legend_labels, filename, y_errorbars=None, save_figure = True) filename = folder + fitness + '_SC_sclatency.png' xlabel = 'Chartist latency' legend_labels = list() ys = list() for nsc_lower, nsc_upper in zip_to_tuples(np.linspace(0,500,6)): nchartist_mask = get_nchartist_mask(nsc_lower, nsc_upper) means = get_sclatencyrange_mean(nchartist_mask, sclatencyrange, nsc_lower = nsc_lower) ys.append(means[fitness]) legend_labels.append('%s <= # SC < %s'%(nsc_lower, nsc_upper)) multiline_xy_plot(means.index, ys, xlabel, ylabel, legend_labels, filename, y_errorbars=None, save_figure = True) except AttributeError: pass try: for fitness in f.columns: filename = folder + fitness + '_MM_mmlatency.png' xlabel = 'Market maker latency' ylabel = fitness legend_labels = list() ys = list() for nmm_lower, nmm_upper in zip_to_tuples(range(0,150,25)): n_mm_mask = get_nmm_mask(nmm_lower, nmm_upper) means = get_ssmmlatencyrange_mean(n_mm_mask, ssmmlatencyrange, nsc_lower = nsc_lower) ys.append(means[fitness]) legend_labels.append('%s <= # MM < %s'%(nmm_lower, nmm_upper)) multiline_xy_plot(means.index, ys, xlabel, ylabel, legend_labels, filename, y_errorbars=None, save_figure = True) filename = folder + fitness + '_MM_sclatency.png' xlabel = 'Chartist latency' ylabel = fitness legend_labels = list() ys = list() for nmm_lower, nmm_upper in zip_to_tuples(range(0,150,25)): n_mm_mask = get_nmm_mask(nmm_lower, nmm_upper) means = get_sclatencyrange_mean(n_mm_mask, sclatencyrange, nsc_lower = nsc_lower) ys.append(means[fitness]) legend_labels.append('%s <= # MM < %s'%(nmm_lower, nmm_upper)) multiline_xy_plot(means.index, ys, xlabel, ylabel, legend_labels, filename, y_errorbars=None, save_figure = True) except AttributeError: pass
def issue_108(dataset, n_clusters, overshoot_threshold, load_pickled_labels = False, labels_to_include = []): from numpy import where, repeat, log, random from sklearn.cluster import KMeans from plotting import make_scatter_plot_for_labelled_data from data_analysis import calculate_stats_for_dataframe from sklearn.mixture import GMM from sklearn.decomposition import PCA from sklearn.preprocessing import scale import cPickle if labels_to_include: labels_to_plot = labels_to_include else: labels_to_plot = range(n_clusters) plots_to_make = [ {'x_name':'stdev', 'x_function':'log', 'y_name':'round_stable', 'y_function':'log'}, {'x_name':'time_to_reach_new_fundamental', 'y_name':'round_stable'}, {'x_name':'stdev', 'x_function':'log', 'y_name':'time_to_reach_new_fundamental'} ] folder = make_issue_specific_figure_folder('108 cluster after removing outliers', dataset) fit, par, gen, ids = IO.load_pickled_generation_dataframe(dataset) o = where(fit.overshoot > overshoot_threshold)[0] not_o = where(fit.overshoot <= overshoot_threshold)[0] data_to_plot = fit.iloc[not_o] pca = PCA(n_components = 3) par_transformed = pca.fit_transform(scale(par.iloc[not_o].astype(float))) par_transformed += random.random(par_transformed.shape)*0.2 par_inliers_PCA = DataFrame(par_transformed, columns = ['PC1', 'PC2', 'PC3']) """ print 'Component 0:' print map(lambda c, n: '%s=%.3g'%(n, c), pca.components_[0], utils.get_latex_par_names_from_list(par.columns)) print 'Component 1:' print map(lambda c, n: '%s=%.3g'%(n, c), pca.components_[1], utils.get_latex_par_names_from_list(par.columns)) print 'Component 1:' print map(lambda c, n: '%s=%.3g'%(n, c), pca.components_[2], utils.get_latex_par_names_from_list(par.columns)) """ def print_pca_components(pca, name): from plotting import plot_pca_components components = DataFrame(pca.components_, columns=utils.get_latex_par_names_from_list(par.columns)) filename = folder + 'clustering_%s_%s'%(dataset, name) plot_pca_components(filename=filename, components=components[::-1]) components['$\\gamma$'] = pca.explained_variance_ratio_ filename = folder + 'clustering_%s_%s.tex'%(dataset, name) tex = utils.prettify_table(components.to_latex(float_format=lambda x: str(round(x,2))), label='table:clustering_%s_%s'%(dataset, name), caption='XXX') with open(filename, 'w') as f: f.write(tex) print_pca_components(pca, 'allclusters') def make_tables(clustering_method, name, cluster_labels): def make_table(stat): fit_inlier_stats = calculate_stats_for_dataframe(fit.iloc[not_o,:], cluster_labels) fit_outlier_stats = calculate_stats_for_dataframe(fit.iloc[o,:], repeat(0, len(o))) fit_mean_table = concat([fit_inlier_stats[stat], fit_outlier_stats[stat]], axis=1) fit_mean_table = fit_mean_table.drop('Count', axis=0) fit_mean_table.index = utils.get_latex_par_names_from_list(fit_mean_table.index) fit_mean_table = fit_mean_table.transpose() par_inlier_stats = calculate_stats_for_dataframe(par.iloc[not_o,:], cluster_labels) par_outlier_stats = calculate_stats_for_dataframe(par.iloc[o,:], repeat(0, len(o))) par_mean_table = concat([par_inlier_stats[stat], par_outlier_stats[stat]], axis=1) par_mean_table.index = utils.get_latex_par_names_from_list(par_mean_table.index) par_mean_table = par_mean_table.transpose() full_table = concat([fit_mean_table, par_mean_table], axis=1) print full_table.columns full_table = full_table.sort('\\overshoot') tex = full_table.to_latex(float_format=lambda x: str(round(x,1))) tex = utils.prettify_table(full_table.to_latex(float_format=lambda x: str(round(x,1))), 'table:fit_gmm_'+name, 'gmm_'+name) filename = folder + '%s_%s_%s_%s.tex'%(n_clusters,clustering_method, name, stat) with open(filename, 'w') as f: f.write(tex) make_table('Mean') make_table('Std') #def make_pca_plots(): def make_plots(clustering_method, data_name, labels): colormap = brewer2mpl.get_map('Paired', 'Qualitative', n_clusters, reverse=True) if not labels_to_include: for i, plotargs in enumerate(plots_to_make): filename = folder + '%s_%s_%s_fit_%s.png'%(n_clusters, clustering_method, data_name, i) make_scatter_plot_for_labelled_data(data_to_plot, labels=labels, filename=filename, colormap=colormap, legend = True, **plotargs) filename = folder + '%s_%s_%s_par.png'%(n_clusters, clustering_method, data_name) make_scatter_plot_for_labelled_data(par_inliers_PCA, x_name='PC1', y_name='PC2', labels=labels, filename=filename, colormap=colormap, legend = True) filename = folder + '%s_%s_%s_par_omit.png'%(n_clusters, clustering_method, data_name) make_scatter_plot_for_labelled_data(par_inliers_PCA, x_name='PC1', y_name='PC2', labels=labels, filename=filename, colormap=colormap, legend = True, omit_largest=n_clusters-4) else: ltp = '_'.join(map(str, labels_to_plot)) filename = folder + '%s_%s_%s_par_%s_pca_1v2.png'%(n_clusters, clustering_method, data_name, ltp) data = par_inliers_PCA[['PC1', 'PC2']] make_scatter_plot_for_labelled_data(data, x_name='PC1', y_name='PC2', labels=labels, filename=filename, colormap=colormap, legend = True, labels_to_plot = labels_to_plot) filename = folder + '%s_%s_%s_par_%s_pca_1v3.png'%(n_clusters, clustering_method, data_name, ltp) data = par_inliers_PCA[['PC1', 'PC3']] make_scatter_plot_for_labelled_data(data, x_name='PC1', y_name='PC3', labels=labels, filename=filename, colormap=colormap, legend = True, labels_to_plot = labels_to_plot) filename = folder + '%s_%s_%s_par_%s_pca_2v3.png'%(n_clusters, clustering_method, data_name, ltp) data = par_inliers_PCA[['PC2', 'PC3']] make_scatter_plot_for_labelled_data(data, x_name='PC2', y_name='PC3', labels=labels, filename=filename, colormap=colormap, legend = True, labels_to_plot = labels_to_plot) selective_par = par.iloc[not_o][get_indluded_labels_mask(labels, *labels_to_plot)] selective_labels = labels[get_indluded_labels_mask(labels, *labels_to_include)] pca_selective = PCA(3) selective_par = DataFrame(pca_selective.fit_transform(selective_par), columns = ['PC1', 'PC2', 'PC3']) print_pca_components(pca_selective, ltp) filename = folder + '%s_%s_%s_par_%s_pca_1v2_selective.png'%(n_clusters, clustering_method, data_name, ltp) data = selective_par[['PC1', 'PC2']] make_scatter_plot_for_labelled_data(data, x_name='PC1', y_name='PC2', labels=selective_labels, filename=filename, colormap=colormap, legend = True, labels_to_plot = labels_to_plot) filename = folder + '%s_%s_%s_par_%s_pca_1v3_selective.png'%(n_clusters, clustering_method, data_name, ltp) data = selective_par[['PC1', 'PC3']] make_scatter_plot_for_labelled_data(data, x_name='PC1', y_name='PC3', labels=selective_labels, filename=filename, colormap=colormap, legend = True, labels_to_plot = labels_to_plot) filename = folder + '%s_%s_%s_par_%s_pca_2v3_selective.png'%(n_clusters, clustering_method, data_name, ltp) data = selective_par[['PC2', 'PC3']] make_scatter_plot_for_labelled_data(data, x_name='PC2', y_name='PC3', labels=selective_labels, filename=filename, colormap=colormap, legend = True, labels_to_plot = labels_to_plot) #par_data_for_plotting = par.iloc[not_o].copy() + random.random(par.iloc[not_o].shape) * 0.2 #filename = folder + '%s_%s_%s_par_latencies.png'%(n_clusters, clustering_method, data_name) #columns = ['ssmm_latency_mu', 'sc_latency_mu'] #make_scatter_plot_for_labelled_data(par_data_for_plotting[columns], 'ssmm_latency_mu', 'sc_latency_mu', labels, filename, colormap, legend = True, labels_to_plot = labels_to_plot) def get_indluded_labels_mask(labels, *labels_to_include): from numpy import repeat mask = repeat(False, labels.shape) for l in labels_to_include: mask = mask | (labels == l) print mask return mask def cluster_and_label(name, data_to_cluster): data_to_cluster = scale(data_to_cluster) """ km_labels_store_file = folder + '%s_%s_%s_classifier.pickle'%(n_clusters, 'km', name) if load_pickled_labels: with open(km_labels_store_file, 'rb') as fid: km_labels = cPickle.load(fid) else: km = KMeans(n_clusters=n_clusters) km.fit(data_to_cluster) km_labels = km.predict(data_to_cluster) with open(km_labels_store_file, 'wb') as fid: cPickle.dump(km_labels, fid) make_plots('km', name, km_labels) make_tables('km', name, km_labels) """ gmm_labels_store_file = folder + '%s_%s_%s_classifier.pickle'%(n_clusters, 'gmm', name) if load_pickled_labels: with open(gmm_labels_store_file, 'rb') as fid: gmm_labels = cPickle.load(fid) else: gmm = GMM(n_components = n_clusters, covariance_type = 'full') gmm.fit(data_to_cluster) gmm_labels = gmm.predict(data_to_cluster) with open(gmm_labels_store_file, 'wb') as fid: cPickle.dump(gmm_labels, fid) #make_plots('gmm', name, gmm_labels) make_tables('gmm', name, gmm_labels) #data_to_cluster = concat([log(fit['stdev']), log(fit['round_stable']), fit['time_to_reach_new_fundamental']], axis=1).iloc[not_o,:] #cluster_and_label('logs_logr_t', data_to_cluster) """ data_to_cluster = concat([log(fit['stdev']), log(fit['round_stable'])], axis=1).iloc[not_o,:] cluster_and_label('logs_logr', data_to_cluster, 'stdev', 'round_stable', 'log', 'log') data_to_cluster = concat([fit['round_stable'], log(fit['stdev'])], axis=1).iloc[not_o,:] cluster_and_label('r_logs', data_to_cluster, 'time_to_reach_new_fundamental', 'round_stable') data_to_cluster = concat([fit['round_stable'], fit['time_to_reach_new_fundamental'], log(fit['stdev'])], axis=1).iloc[not_o,:] cluster_and_label('t_r_logs', data_to_cluster, 'time_to_reach_new_fundamental', 'round_stable') data_to_cluster = concat([fit['round_stable'], fit['time_to_reach_new_fundamental']], axis=1).iloc[not_o,:] cluster_and_label('t_r', data_to_cluster, 'time_to_reach_new_fundamental', 'round_stable') """ data_to_cluster = fit.iloc[not_o,:] cluster_and_label('all', data_to_cluster) data_to_cluster = concat([log(fit['stdev']), log(fit['round_stable']), fit['time_to_reach_new_fundamental']], axis=1).iloc[not_o,:] cluster_and_label('logs_logr_t', data_to_cluster)
def issue_103_manually_removing_large_fitness_points(dataset, overshoot_threshold): from plotting import make_color_grouped_scatter_plot from numpy import where folder = make_issue_specific_figure_folder('103_scatter_manual_outlier', dataset) fit, par, gen, ids = IO.load_pickled_generation_dataframe(dataset) #fit['overshoot'] -= 2 o = where(fit.overshoot > overshoot_threshold)[0] not_o = where(fit.overshoot <= overshoot_threshold)[0] #colormap = brewer2mpl.get_map('RdBu', 'diverging', 4, reverse=True) colormap = brewer2mpl.get_map('Spectral', 'Diverging', 9, reverse=True) filename = folder + 'a.png' make_color_grouped_scatter_plot(fit.iloc[not_o], 'stdev', 'time_to_reach_new_fundamental', 'round_stable', filename, colormap) filename = folder + 'b.png' make_color_grouped_scatter_plot(fit.iloc[not_o], 'stdev', 'time_to_reach_new_fundamental', 'round_stable', filename, colormap, x_function='log', y_function='log', color_function='log') filename = folder + 'c.png' make_color_grouped_scatter_plot(data_frame=fit.iloc[not_o], x_name='time_to_reach_new_fundamental', y_name='round_stable', color_by='stdev', filename=filename, colormap = colormap) filename = folder + 'd.png' make_color_grouped_scatter_plot(data_frame=fit.iloc[not_o], x_name='stdev', y_name='round_stable', color_by='time_to_reach_new_fundamental', filename=filename, colormap = colormap, x_function='log', y_function='log') filename = folder + 'e.png' make_color_grouped_scatter_plot(data_frame=fit.iloc[not_o], x_name='stdev', y_name='overshoot', color_by='time_to_reach_new_fundamental', filename=filename, colormap = colormap) filename = folder + 'h.png' make_color_grouped_scatter_plot(fit.iloc[not_o], 'stdev', 'time_to_reach_new_fundamental', 'round_stable', filename, colormap, x_function='log') filename = folder + 'i.png' make_color_grouped_scatter_plot(fit.iloc[not_o], 'stdev', 'time_to_reach_new_fundamental', 'round_stable', filename, colormap) filename = folder + 'l.png' make_color_grouped_scatter_plot(data_frame=fit.iloc[not_o], x_name='stdev', y_name='round_stable', color_by='overshoot', filename=filename, colormap = colormap, x_function='log', y_function='log') filename = folder + 'k.png' make_color_grouped_scatter_plot(fit.iloc[not_o], 'stdev', 'time_to_reach_new_fundamental', 'overshoot', filename, colormap, x_function='log') filename = folder + 'g.png' make_color_grouped_scatter_plot(fit.iloc[not_o], 'overshoot', 'time_to_reach_new_fundamental', 'round_stable', filename, colormap) filename = folder + 'j.png' ax, fig = make_color_grouped_scatter_plot(data_frame=fit.iloc[not_o], x_name='time_to_reach_new_fundamental', y_name='round_stable', color_by='overshoot', filename=filename, colormap = colormap) ax.plot(range(0,10**5), range(0,10**5), linestyle='dashed', color='black', alpha = 0.5) ax.text(40000, 80000, "A", fontsize = 18, alpha = 0.6) ax.text(80000, 40000, "B", fontsize = 18, alpha = 0.6) fig.savefig(filename) #Plot with A B regions filename = folder + 'f.png' ax, fig = make_color_grouped_scatter_plot(data_frame=fit.iloc[not_o], x_name='time_to_reach_new_fundamental', y_name='round_stable', color_by='stdev', filename=filename, colormap = colormap, color_function='log') ax.plot(range(0,10**5), range(0,10**5), linestyle='dashed', color='black', alpha = 0.5) ax.text(40000, 80000, "A", fontsize = 18, alpha = 0.6) ax.text(80000, 40000, "B", fontsize = 18, alpha = 0.6) fig.savefig(filename) stats = concat([par.iloc[not_o,:].mean(), par.iloc[o,:].mean(), par.iloc[not_o,:].std(), par.iloc[o,:].std()], axis=1) lt = '$\overshoot > %s$'%overshoot_threshold st = '$\overshoot < %s$'%overshoot_threshold stats.columns = ['%s (mean)'%st, '%s (mean)'%lt, '%s (std)'%st, '%s (std)'%lt] tex_index = utils.get_latex_par_names_from_list(stats.index.tolist()) stats.index = tex_index print utils.prettify_table(stats.to_latex(float_format=lambda x: str(round(x,1))), 'LABEL', 'CAPTION') return stats
def issue_82_parameter_evolution(dataset, vline_x = []): def get_stats(name, stats): return [getattr(group[name], s)() for s in stats] def d3(): #make_pretty_generation_plot(folder + 'd3_latpars_s.png', generations, [group['ssmm_latency_s'].mean(), group['sc_latency_s'].mean()], 'Average latency std', ['Market makers', 'Chartists']) make_pretty_generation_plot(folder + 'nAgents.png', generations, [group['ssmm_nAgents'].mean(), group['sc_nAgents'].mean()], 'Average number of agents', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_nAgents'].std(), group['sc_nAgents'].std()]) make_pretty_generation_plot(folder + 'thinkpars_s.png', generations, [group['ssmm_think_s'].mean(), group['sc_think_s'].mean()], 'Average if the thinking time standard deviation', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_think_s'].std(), group['sc_think_s'].std()]) make_pretty_generation_plot(folder + 'thinkpars_mu.png', generations, [group['ssmm_think_mu'].mean(), group['sc_think_mu'].mean()], 'Average of the thinking time distribution mean', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_think_mu'].std(), group['sc_think_mu'].std()]) make_pretty_generation_plot(folder + 'latpars_mu.png', generations, [group['ssmm_latency_mu'].mean(), group['sc_latency_mu'].mean()], 'Average of the latency distribution mean', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_mu'].std(), group['sc_latency_mu'].std()]) make_pretty_generation_plot(folder + 'latpars_s.png', generations, [group['ssmm_latency_s'].mean(), group['sc_latency_s'].mean()], 'Average of the latency distribution standard deviation', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_s'].std(), group['sc_latency_s'].std()]) make_pretty_generation_plot(folder + 'scwaittime_mu.png', generations, [group['sc_waitTimeBetweenTrading_mu'].mean()], 'Average of the chartist waiting time distribution mean', ['Chartists'], y_errorbar=[group['sc_waitTimeBetweenTrading_mu'].std()]) make_pretty_generation_plot(folder + 'sctimehorizon_mu.png', generations, [group['sc_timehorizon_mu'].mean()], 'Average of the chartist time horizon distribution mean', ['Chartists'], y_errorbar=[group['sc_timehorizon_mu'].std()]) def d9(): make_pretty_generation_plot(folder + 'latpars_s.png', generations, [group['ssmm_latency_s'].mean(), group['sc_latency_s'].mean()], 'Average latency std', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_s'].std(), group['sc_latency_s'].std()]) make_pretty_generation_plot(folder + 'latpars_mu.png', generations, [group['ssmm_latency_mu'].mean(), group['sc_latency_mu'].mean()], 'Average latency mean', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_mu'].std(), group['sc_latency_mu'].std()]) make_pretty_generation_plot(folder + 'thinkpars_s.png', generations, [group['ssmm_think_s'].mean(), group['sc_think_s'].mean()], 'Average think time std', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_think_s'].std(), group['sc_think_s'].std()]) make_pretty_generation_plot(folder + 'thinkpars_mu.png', generations, [group['ssmm_think_mu'].mean(), group['sc_think_mu'].mean()], 'Average think time mean', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_think_mu'].std(), group['sc_think_mu'].std()]) make_pretty_generation_plot(folder + 'scwaittime_mu.png', generations, [group['sc_waitTimeBetweenTrading_mu'].mean()], 'Average of the chartist waiting time distribution mean', ['Chartists'], y_errorbar=[group['sc_waitTimeBetweenTrading_mu'].std()]) make_pretty_generation_plot(folder + 'sctimehorizon_mu.png', generations, [group['sc_timehorizon_mu'].mean()], 'Average of the chartist time horizon distribution mean', ['Chartists'], y_errorbar=[group['sc_timehorizon_mu'].std ()]) def d10(): make_pretty_generation_plot(folder + 'latpars_s.png', generations, [group['ssmm_latency_s'].mean(), group['sc_latency_s'].mean()], 'Average latency std', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_s'].std(), group['sc_latency_s'].std()], vline_x = vline_x) fig, ax, filename = make_pretty_generation_plot(folder + 'latpars_mu.png', generations, [group['ssmm_latency_mu'].mean(), group['sc_latency_mu'].mean()], 'Average latency mean', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_mu'].std(), group['sc_latency_mu'].std()], vline_x = vline_x) ax.fill_between(x=[30, 50], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='red', alpha=0.1) ax.fill_between(x=[0, 17], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='blue', alpha=0.1) fig.savefig(filename) fig, ax, filename = make_pretty_generation_plot(folder + 'nAgents.png', generations, [group['ssmm_nAgents'].mean()], 'Average number of agents', ['Market makers'], y_errorbar=[group['ssmm_nAgents'].std()], vline_x = vline_x) ax.fill_between(x=[30, 50], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='red', alpha=0.1) ax.fill_between(x=[0, 17], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='blue', alpha=0.1) fig.savefig(filename) fig, ax, filename = make_pretty_generation_plot(folder + 'time_to_reach_new_fundamental.png', generations, get_stats('time_to_reach_new_fundamental', stats), 'Time to reach fundamental after shock', stats, vline_x = vline_x) ax.fill_between(x=[0, 17], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='blue', alpha=0.1) fig.savefig(filename) fig, ax, filename = make_pretty_generation_plot(folder + 'stdev.png', generations, get_stats('stdev', stats), 'Standard deviation of trade prices entering stability margin', stats, y_logscale=True, vline_x=vline_x) ax.fill_between(x=[30, 50], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='red', alpha=0.1) fig.savefig(filename) fig, ax, filename = make_pretty_generation_plot(folder + 'round_stable.png', generations, get_stats('round_stable', stats), 'Round stable', stats, y_logscale=True, vline_x=vline_x) ax.fill_between(x=[30, 50], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='red', alpha=0.1) fig.savefig(filename) fig, ax, filename = make_pretty_generation_plot(folder + 'overshoot.png', generations, get_stats('overshoot', stats), 'Overshoot', stats, vline_x=vline_x) ax.fill_between(x=[30, 50], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='red', alpha=0.1) ax.fill_between(x=[0, 17], y1=ax.get_ylim()[0], y2=ax.get_ylim()[1], color='blue', alpha=0.1) fig.savefig(filename) def d11(): make_pretty_generation_plot(folder + 'latpars_s.png', generations, [group['ssmm_latency_s'].mean(), group['sc_latency_s'].mean()], 'Average latency std', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_s'].std(), group['sc_latency_s'].std()]) make_pretty_generation_plot(folder + 'latpars_mu.png', generations, [group['ssmm_latency_mu'].mean(), group['sc_latency_mu'].mean()], 'Average latency mean', ['Market makers', 'Chartists'], y_errorbar=[group['ssmm_latency_mu'].std(), group['sc_latency_mu'].std()]) make_pretty_generation_plot(folder + 'nAgents.png', generations, [group['sc_nAgents'].mean()], 'Average number of agents', ['Chartists'], y_errorbar=[group['sc_nAgents'].std()]) from plotting import make_pretty_generation_plot folder = make_issue_specific_figure_folder('82_generation_plots', dataset) fit,par,gen,ids = IO.load_pickled_generation_dataframe(dataset) all_data = concat([fit,par, DataFrame(gen)], axis=1) generations = list(set(all_data['gen'])) group = all_data.groupby('gen') stats = ['min', 'mean', 'median'] make_pretty_generation_plot(folder + 'time_to_reach_new_fundamental.png', generations, get_stats('time_to_reach_new_fundamental', stats), 'Time to reach fundamental after shock', stats, vline_x = vline_x) make_pretty_generation_plot(folder + 'stdev.png', generations, get_stats('stdev', stats), 'Standard deviation of trade prices entering stability margin', stats, y_logscale=True, vline_x=vline_x) make_pretty_generation_plot(folder + 'round_stable.png', generations, get_stats('round_stable', stats), 'Round stable', stats, y_logscale=True, vline_x=vline_x) make_pretty_generation_plot(folder + 'overshoot.png', generations, get_stats('overshoot', stats), 'Overshoot', stats, vline_x=vline_x) eval(dataset)()