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)()
