def plot_fit_consistency(population_fits, plot_true=True, fig_no=1):
fit_means = np.array([pf["pop_params"]["means"] for pf in population_fits])
fit_SDs = np.array([pf["pop_params"]["SDs"] for pf in population_fits])
true_means = population_fits[0]["pop_params_true"]["means"]
true_SDs = population_fits[0]["pop_params_true"]["SDs"]
n_params = fit_means.shape[1]
n_fits = fit_means.shape[0]
x = np.arange(n_fits) / float(n_fits)
ymin = np.min(fit_means - fit_SDs) - 0.2
ymax = np.max(fit_means + fit_SDs) + 0.2
if not len(true_means) == n_params:
plot_true = False
p.figure(fig_no)
p.clf()
for i in range(n_params):
p.subplot(1, n_params, i + 1)
if plot_true:
p.plot([0.45, 0.45], [true_means[i] - true_SDs[i], true_means[i] + true_SDs[i]], "r", linewidth=2)
for f in range(n_fits):
p.plot([x[f], x[f]], [fit_means[f, i] - fit_SDs[f, i], fit_means[f, i] + fit_SDs[f, i]], "b")
p.locator_params(axis="y", nbins=4)
p.xticks([])
p.xlabel(population_fits[0]["param_names"][i])
p.ylim(ymin, ymax)
def plot_error_bars_shrink(result, filename=None):
pylab.rcParams.update({"font.size": 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(8, 10), facecolor="w", edgecolor="k")
num_queries = result["num_queries"]
confidence = result["config"]["confidence"]
dep_means = result["dependence_probability_mean"]
dep_error = result["dependence_probability_error"]
inf_means = result["infer_means"]
inf_error = result["infer_stderr"]
x = result["iteration"]
ax = pylab.subplot(3, 1, 1)
for q in range(num_queries):
pylab.errorbar(x, dep_means[q, :], yerr=dep_error[q, :], alpha=0.7)
pylab.title("Dependence probability")
ax.yaxis.set_major_locator(MaxNLocator(3))
ax.xaxis.set_major_locator(MaxNLocator(5))
pylab.xlabel("iteration")
ax = pylab.subplot(3, 1, 2)
for q in range(num_queries):
pylab.errorbar(x, inf_means[q, :], yerr=inf_error[q, :], alpha=0.7)
pylab.title("Infer. Confidence=%1.2f" % confidence)
pylab.xlabel("iteration")
ax.yaxis.set_major_locator(MaxNLocator(3))
ax.xaxis.set_major_locator(MaxNLocator(5))
num_iters = result["config"]["num_iters"]
num_chains = result["config"]["num_chains"]
num_runs = result["config"]["num_runs"]
prop_missing = result["config"]["prop_missing"]
confidence = result["config"]["confidence"]
txt = """
Left: Dependence probability with standard error calculated over %i runs of %i
chains for %i iterations.
Right: Proportion of missing data successfully imputed with INFER with %1.2f
confidence.
Data used was dha.csv. %1.2f percent of data was removed.
""" % (
num_runs,
num_chains,
num_iters,
confidence,
prop_missing * 100,
)
ax = pylab.subplot(3, 1, 3)
ax.text(0, 0, txt, fontsize=9)
ax.axis("off")
if filename is None:
filename = "Error_bars_shrink-iters=%i_chains=%i_T=%i.png" % (num_iters, num_chains, int(time.time()))
pylab.savefig(filename)
def PlotAbsorbances(samples,
plot_baseline=True,
plot_original=True,
plot_bscorrected=False):
if not isinstance(samples, list):
samples = [samples]
axis_font, legend_font = GetFontsAndSetMPLproperties()
for s in samples:
fig = plt.figure(figsize=(12 / 2.54, 8 / 2.54))
ax0 = fig.add_subplot(111)
ax0.invert_xaxis()
plt.locator_params(nbins=6)
if plot_original:
ax0.plot(s.wavenumber, s.absorbance * 1E4, label='data', color='k')
if plot_baseline:
ax0.plot(s.wavenumber_cut,
s.baseline * 1E4,
label='baseline',
color='r')
if plot_bscorrected:
ax0.plot(s.wavenumber_cut, (s.absorbance_cut - s.baseline) * 1E4,
label=s.name + '_corrected')
legend = plt.legend()
legend.set_draggable(True)
plt.title(s.name)
ax0.set_xlabel('wavenumber / cm$^{-1}$')
ax0.set_ylabel('absorbance / 10$^{-4}$nm$^{-1}$')
plt.show()
def _plot_exponential_fit(fit,
p_e,
pre_post_trials,
last_n,
col='r',
plot_tau=False):
t = np.arange(0, pre_post_trials[1])
double_exp = 'tau_f' in fit.keys()
if double_exp:
exp_traj = _double_exp_choice_traj(
[fit['tau_f'], fit['tau_ratio'], fit['fs_mix']], fit['p_0'], p_e,
t)
else:
exp_traj = _exp_choice_traj(fit['tau'], fit['p_0'], p_e, t)
full_traj = np.hstack([
ut.nans(-pre_post_trials[0] - last_n),
np.ones(last_n) * fit['p_0'], exp_traj
])
plt.plot(np.arange(pre_post_trials[0], pre_post_trials[1]),
full_traj,
col,
linewidth=1.5)
if plot_tau: plt.plot([fit['tau'], fit['tau']], [0, 1], ':' + col)
plt.locator_params(nbins=4)
def plotReporter5bar(fig, ax, strata, pdfFile, plotDataFrame, varList,
yLabelText, ownership, labelYaxis):
plotData = list(plotDataFrame[0])
if 'Fremont-Winema NF' in ownership:
ownership = ownership[:-35]
elif 'JWTR' in ownership:
ownership = 'PC1'
elif 'Mazama' in ownership:
ownership = 'PC2'
elif 'Jeld' in ownership:
ownership = 'PC3'
elif 'Spear' in ownership:
ownership = 'PC4'
elif 'Collins' in ownership:
ownership = 'PC5'
elif 'Corporate' in ownership:
ownership = 'Corporate'
ind = np.arange(len(plotData))
width = 0.35
# reverse order of items to plot
## plotData.reverse()
## varListReverse = varList[::-1]
ax.barh(ind,
plotData,
color=plotDataFrame.positives.map({
True: 'b',
False: 'r'
}))
pl.subplots_adjust(wspace=0.25, hspace=0.10, left=0.2)
pl.tick_params(axis='x', which='major', labelsize=7.5)
pl.tick_params(axis='y', which='major', labelsize=9)
pl.locator_params(axis='x', nbins=5)
# remove the last label on the x axis
## labels = [item.get_text() for item in ax.get_xticklabels()]
## labels[-1] = ''
## ax.set_xticklabels(labels)
if labelYaxis:
ax.set(yticks=np.arange(len(plotData) + 1) + width,
yticklabels=varList + [''],
ylim=[2 * width - 1, len(plotData) + 1])
else:
ax.set(yticks=np.arange(len(plotData) + 1) + width,
yticklabels=[],
ylim=[2 * width - 1, len(plotData) + 1])
ax.text(0.5,
0.92,
ownership,
horizontalalignment='center',
transform=ax.transAxes,
fontsize=9)
def plot_recovers_original_densities(result, filename=None):
pylab.rcParams.update({"font.size": 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(10, 8), facecolor="w", edgecolor="k")
plt = 0
for shape in ["sinwave", "x", "ring", "dots"]:
key = shape + "_original"
X_original = result[key]
ax = pylab.plt.subplot2grid((3, 4), (0, plt))
pylab.scatter(X_original[:, 0], X_original[:, 1], color="blue", edgecolor="none", alpha=0.2)
pylab.title("%s original" % shape)
ax.yaxis.set_major_locator(MaxNLocator(3))
ax.xaxis.set_major_locator(MaxNLocator(3))
key = shape + "_inferred"
X_inferred = result[key]
ax1 = pylab.plt.subplot2grid((3, 4), (1, plt))
pylab.scatter(X_inferred[:, 0], X_inferred[:, 1], color="red", edgecolor="none", alpha=0.2)
pylab.xlim(ax.get_xlim())
pylab.ylim(ax.get_ylim())
pylab.title("%s inferred" % shape)
ax1.yaxis.set_major_locator(MaxNLocator(3))
ax1.xaxis.set_major_locator(MaxNLocator(3))
plt += 1
num_iters = result["config"]["num_iters"]
num_rows = result["config"]["num_rows"]
num_chains = result["config"]["num_chains"]
txt = """
Top panels: zero-correlation datasets consisting of %i points.
Bottom panels: result of SIMULATE %i datapoints after running %i
chains for %i iterations.
""" % (
num_rows,
num_rows,
num_chains,
num_iters,
)
pylab.plt.subplot2grid((3, 3), (2, 0), colspan=3)
ax = pylab.gca()
ax.text(0, 0.5, txt, fontsize=10)
ax.axis("off")
if filename is None:
filename = "Recovers_original_densities-num_rows=%i-num_chains=%i-num_iters=%i-T=%i.png" % (
num_rows,
num_chains,
num_iters,
int(time.time()),
)
pylab.savefig(filename)
def plot_error_bars_shrink(result, filename=None):
pylab.rcParams.update({'font.size': 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(8,10), facecolor='w', edgecolor='k')
num_queries = result['num_queries']
confidence = result['config']['confidence']
dep_means = result['dependence_probability_mean']
dep_error = result['dependence_probability_error']
inf_means = result['infer_means']
inf_error = result['infer_stderr']
x = result['iteration']
ax = pylab.subplot(3,1,1)
for q in range(num_queries):
pylab.errorbar(x, dep_means[q,:], yerr=dep_error[q,:], alpha=.7)
pylab.title('Dependence probability')
ax.yaxis.set_major_locator(MaxNLocator(3))
ax.xaxis.set_major_locator(MaxNLocator(5))
pylab.xlabel('iteration')
ax = pylab.subplot(3,1,2)
for q in range(num_queries):
pylab.errorbar(x, inf_means[q,:], yerr=inf_error[q,:], alpha=.7)
pylab.title('Infer. Confidence=%1.2f' % confidence)
pylab.xlabel('iteration')
ax.yaxis.set_major_locator(MaxNLocator(3))
ax.xaxis.set_major_locator(MaxNLocator(5))
num_iters = result['config']['num_iters']
num_chains = result['config']['num_chains']
num_runs = result['config']['num_runs']
prop_missing = result['config']['prop_missing']
confidence = result['config']['confidence']
txt = '''
Left: Dependence probability with standard error calculated over %i runs of %i
chains for %i iterations.
Right: Proportion of missing data successfully imputed with INFER with %1.2f
confidence.
Data used was dha.csv. %1.2f percent of data was removed.
''' % (num_runs, num_chains, num_iters, confidence, prop_missing*100)
ax = pylab.subplot(3,1,3)
ax.text(0,0,txt, fontsize=9)
ax.axis('off')
if filename is None:
filename = 'Error_bars_shrink-iters=%i_chains=%i_T=%i.png' % \
(num_iters, num_chains, int(time.time()))
pylab.savefig( filename )
def plotOne(b, d, name, chroms, common, shade):
a = b.dropna()
c = d.loc[a.index]
if shade is not None:
for _, row in shade.iterrows():
plt.gca().fill_between([row.gstart, row.gend],
a.min(),
a.max(),
color='b',
alpha=0.3)
plt.scatter(a.index,
a,
s=markerSize,
c=c,
alpha=0.8,
edgecolors='none')
outliers = None
if Outliers is not None:
outliers = Outliers[name].dropna()
if cutoff is not None:
outliers = a[a >= cutoff[name]]
elif top_k is not None:
outliers = a.sort_values(ascending=False).iloc[:top_k]
elif std_th is not None:
outliers = a[a > a.mean() + std_th * a.std()]
if outliers is not None:
if len(outliers):
# if name != 'Number of SNPs':
plt.scatter(outliers.index,
outliers,
s=markerSize,
c='r',
alpha=0.8,
edgecolors='none')
# plt.axhline(outliers.min(), color='k', ls='--')
if common is not None:
for ii in common.index:
plt.axvline(ii, c='g', alpha=0.5)
plt.axis('tight')
plt.xlim(0, a.index[-1])
plt.ylabel(name, fontsize=ticksize * 1.5)
# plt.title('{} SNPs, {} are red.'.format(a.dropna().shape[0], outliers.shape[0]))
plt.xticks([x for x in chroms.mid], [str(x) for x in chroms.index],
rotation=-90,
fontsize=ticksize * 1.5)
plt.setp(plt.gca().get_xticklabels(), visible=False)
plt.locator_params(axis='y', nbins=3)
mpl.rc('ytick', labelsize=ticksize)
if ylim is not None: plt.ylim(ymin=ylim)
def plot_fills_in_the_blanks(result, filename=None):
pylab.rcParams.update({"font.size": 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(10, 8), facecolor="w", edgecolor="k")
prop_missing = result["config"]["prop_missing"]
ax = pylab.subplot(2, 1, 1)
pylab.plot(prop_missing, result["MSE_naive_bayes_indexer"], lw=3, c="red", label="Naive Bayes")
pylab.plot(prop_missing, result["MSE_crp_mixture_indexer"], lw=3, c="blue", label="CRP mixture")
pylab.plot(prop_missing, result["MSE_crosscat_indexer"], lw=3, c="green", label="CrossCat")
ax.set_xticks(prop_missing)
ax.yaxis.set_major_locator(MaxNLocator(3))
pylab.ylabel("MSE")
pylab.xlabel("proportion of data missing")
pylab.legend(loc=4)
num_iters = result["config"]["num_iters"]
num_rows = result["config"]["num_rows"]
num_cols = result["config"]["num_cols"]
num_chains = result["config"]["num_chains"]
impute_samples = result["config"]["impute_samples"]
txt = """
Mean squared error over all imputed missing values (y-axis) for a %i rows by %i table with
variable proportion of missing data (x-axis).
Green line: BayesDB normal configuration
Blue line: BayesDB CRP mixture configuration (one view, no column transitions)
Red line: BayesDB Naive Bayes configuration (one view, one category, only hyperparameter
transitions)
Each imputation was calculated with %i samples from %i chains run for %i iterations.
""" % (
num_rows,
num_cols,
impute_samples,
num_chains,
num_iters,
)
if filename is None:
filename = "Fills_in_blanks-iters=%i_chains=%i_T=%i.png" % (num_iters, num_chains, int(time.time()))
ax = pylab.subplot(2, 1, 2)
ax.text(0, 0.5, txt, fontsize=10)
ax.axis("off")
pylab.savefig(filename)
def plot_recovers_original_densities(result, filename=None):
pylab.rcParams.update({'font.size': 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(10,8), facecolor='w', edgecolor='k')
plt = 0
for shape in ["sinwave", "x", "ring", "dots"]:
key = shape + "_original"
X_original = result[key]
ax = pylab.plt.subplot2grid((3,4), (0, plt))
pylab.scatter( X_original[:,0], X_original[:,1], color='blue', edgecolor='none', alpha=.2 )
pylab.title("%s original" % shape)
ax.yaxis.set_major_locator(MaxNLocator(3))
ax.xaxis.set_major_locator(MaxNLocator(3))
key = shape + "_inferred"
X_inferred = result[key]
ax1 = pylab.plt.subplot2grid((3,4), (1, plt))
pylab.scatter( X_inferred[:,0], X_inferred[:,1], color='red', edgecolor='none', alpha=.2 )
pylab.xlim(ax.get_xlim())
pylab.ylim(ax.get_ylim())
pylab.title("%s inferred" % shape)
ax1.yaxis.set_major_locator(MaxNLocator(3))
ax1.xaxis.set_major_locator(MaxNLocator(3))
plt += 1
num_iters = result['config']['num_iters']
num_rows = result['config']['num_rows']
num_chains = result['config']['num_chains']
txt = '''
Top panels: zero-correlation datasets consisting of %i points.
Bottom panels: result of SIMULATE %i datapoints after running %i
chains for %i iterations with %s datatype.
''' % (num_rows, num_rows, num_chains, num_iters, result['config']['datatype'])
pylab.plt.subplot2grid((3,3), (2,0), colspan=3)
ax = pylab.gca()
ax.text(0,.5,txt, fontsize=10)
ax.axis('off')
if filename is None:
filename = "Recovers_original_densities-num_rows=%i-num_chains=%i-num_iters=%i-T=%i.png" % \
(num_rows, num_chains, num_iters, int(time.time()))
pylab.savefig(filename)
def plotOne(df,maxGen=None,obs=False,mean=True,color='red'):
m=df.mean(1)
s=df.std(1)
if maxGen is not None:
m=m.loc[:maxGen]
s=s.loc[:maxGen]
plt.locator_params(nbins=4);
if color=='red':
m.plot(ax=plt.gca(),legend=False,linewidth=5,color=color)
else:
m.plot(ax=plt.gca(),legend=False,linewidth=3,color=color)
#;plt.gca().axvspan(ft/3, ft/3*2, alpha=0.15, color='black')
x=m.index.values
m=m.values;s=s.values
plt.gca().fill_between(x, m - 2 * s, m + 2 * s, color=color, alpha=0.3)
plt.grid()
def plot_fills_in_the_blanks(result, filename=None):
pylab.rcParams.update({'font.size': 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(10,8), facecolor='w', edgecolor='k')
prop_missing = result['config']['prop_missing']
ax = pylab.subplot(2,1,1)
pylab.plot(prop_missing, result['MSE_naive_bayes_indexer'], lw=3, c='red', label='Naive Bayes')
pylab.plot(prop_missing, result['MSE_crp_mixture_indexer'], lw=3, c='blue', label='CRP mixture')
pylab.plot(prop_missing, result['MSE_crosscat_indexer'], lw=3, c='green', label='CrossCat')
ax.set_xticks(prop_missing)
ax.yaxis.set_major_locator(MaxNLocator(3))
pylab.ylabel('MSE')
pylab.xlabel('proportion of data missing')
pylab.legend(loc=4)
num_iters = result['config']['num_iters']
num_rows = result['config']['num_rows']
num_cols = result['config']['num_cols']
num_chains = result['config']['num_chains']
impute_samples = result['config']['impute_samples']
txt = '''
Mean squared error over all imputed missing values (y-axis) for a %i rows by %i table with
variable proportion of missing data (x-axis).
Green line: BayesDB normal configuration
Blue line: BayesDB CRP mixture configuration (one view, no column transitions)
Red line: BayesDB Naive Bayes configuration (one view, one category, only hyperparameter
transitions)
Each imputation was calculated with %i samples from %i chains run for %i iterations.
''' % (num_rows, num_cols, impute_samples, num_chains, num_iters)
if filename is None:
filename = 'Fills_in_blanks-iters=%i_chains=%i_T=%i.png' % \
(num_iters, num_chains, int(time.time()))
ax = pylab.subplot(2,1,2)
ax.text(0,.5,txt, fontsize=10)
ax.axis('off')
pylab.savefig( filename )
def lagged_log_reg_plot(population_fit, n_back = 4, n_non_lag = 1, fig_no = 1, clf = True):
pop_params = population_fit['pop_params']
n_params = (len(pop_params['means']) - n_non_lag)/n_back
means = pop_params['means']
SDs = pop_params['SDs']
p.figure(fig_no)
if clf:p.clf()
x = range(1,n_back + 1)
for i in range(n_params):
param_means = means[n_non_lag + i::n_params]
param_SDs = SDs[n_non_lag + i::n_params]
p.subplot(n_params, 1, i + 1)
p.errorbar(x, param_means, param_SDs)
p.ylabel(population_fit['param_names'][i+n_non_lag][:-2])
p.plot([0.5,n_back + 0.5],[0,0],'k')
p.locator_params(nbins = 4)
p.xticks(range(1,n_back + 1),[])
p.xlim(0.5,n_back + 0.5)
p.xticks(range(1,n_back + 1),-np.arange(1,n_back + 1))
def pop_fit_comparison(population_fit_A, population_fit_B, fig_no = 1, normalize = False):
'Plot multiple population fits on the same axis for comparison.'
p.figure(fig_no)
p.clf()
pop_params_A = population_fit_A['pop_params']
pop_params_B = population_fit_B['pop_params']
n_params = len(pop_params_A['ranges'])
for i in range(n_params):
p.subplot(1, n_params, i + 1)
_plot_dist(pop_params_A['means'][i], pop_params_A['SDs'][i],
pop_params_A['ranges'][i], col = 'b', normalize = normalize)
_plot_dist(pop_params_B['means'][i], pop_params_B['SDs'][i],
pop_params_B['ranges'][i], col = 'r', normalize = normalize)
p.locator_params('x', nbins = 3)
p.xlabel(population_fit_A['param_names'][i])
p.yticks([])
for i in range(n_params):
p.subplot(1, n_params, i + 1)
p.ylim([0,p.ylim()[1] * 1.1])
def final_figure(n= 3):
"""Make the final figure. For n (default = 3) values of r plot along the first row relative fitness.
That is fitness of the full model minus (or over) fitness in the mixed case.
The second row is Xa and the 3rd row is beta. """
rs = np.linspace(0,1,n)
pl.figure()
for i,r in enumerate(rs):
pl.subplot( 3, n, i+1)
relative_fitness(r = r, steps = 200)
if i == n - 1 and n <= 3:
pl.colorbar( ticks = np.linspace(-1.2,1.2,5))
pl.locator_params( nbins=4)
pl.subplot( 3, n, n + i + 1)
ST_xA(r=r,steps = 200)
if i ==n-1 and n <=3:
pl.colorbar( ticks = np.linspace(0,1,5))
if i ==0:
pl.ylabel("S", fontsize = 20)
pl.locator_params( nbins=4)
pl.subplot( 3, n, 2*n + i + 1)
ST_beta(r=r,steps = 200)
if i ==n-1 and n <= 3:
pl.colorbar( ticks = np.linspace(-1,1,5) )
if i ==n/2:
pl.xlabel("T", fontsize = 20)
pl.locator_params( nbins=4)
pl.savefig("figures\\final_heatmap_%d.png"%n)
def plotOne(b, d, name, chroms,common,shade):
a = b.dropna()
c = d.loc[a.index]
if shade is not None:
for _ , row in shade.iterrows():
plt.gca().fill_between([row.gstart, row.gend], a.min(), a.max(), color='b', alpha=0.3)
plt.scatter(a.index, a, s=markerSize, c=c, alpha=0.8, edgecolors='none')
outliers=None
if Outliers is not None:
outliers=Outliers[name].dropna()
if cutoff is not None:
outliers = a[a >= cutoff[name]]
elif top_k is not None:
outliers = a.sort_values(ascending=False).iloc[:top_k]
elif std_th is not None:
outliers = a[a > a.mean() + std_th * a.std()]
if outliers is not None:
if len(outliers):
# if name != 'Number of SNPs':
plt.scatter(outliers.index, outliers, s=markerSize, c='r', alpha=0.8, edgecolors='none')
# plt.axhline(outliers.min(), color='k', ls='--')
if common is not None:
for ii in common.index: plt.axvline(ii,c='g',alpha=0.5)
plt.axis('tight');
plt.xlim(max(0,a.index[0]-10000), a.index[-1]);
setSize(plt.gca(),ticksize)
plt.ylabel(name, fontsize=ticksize * 1.5)
# plt.title('{} SNPs, {} are red.'.format(a.dropna().shape[0], outliers.shape[0]))
if chroms.shape[0]>1:
plt.xticks([x for x in chroms.mid], [str(x) for x in chroms.index], rotation=-90, fontsize=ticksize * 1.5)
plt.setp(plt.gca().get_xticklabels(), visible=False)
plt.locator_params(axis='y', nbins=4)
mpl.rc('ytick', labelsize=ticksize)
if ylim is not None: plt.ylim(ymin=ylim)
def dists_and_hists_plot(population_fit, fig_no = 1):
''' Plot population distributions and histogram of MAP parameter estimates in true space.
If simulated data, plot true and fitted data seperately.
'''
fig = p.figure(fig_no)
#fig.tight_layout()
p.clf()
pop_params = population_fit['pop_params']
param_ranges = pop_params['ranges']
MAP_params_T = np.array([MAP_fit['params_T'] for MAP_fit in population_fit['MAP_fits'] ])
n_params = np.shape(MAP_params_T)[1]
n_rows = 1
if False:#population_fit.has_key('pop_params_true') & \
#(n_params == len(population_fit['pop_params_true']['means'])):
n_rows = 2
pop_params_true = population_fit['pop_params_true']
if isinstance(pop_params_true['SDs'], float):
pop_params_true['SDs'] = np.ones(n_params) * pop_params_true['SDs']
true_params_T = np.array(population_fit['true_values']['params_T'])
for i in range(n_params):
p.subplot(2,n_params,i+1)
_plot_dist_and_hist(pop_params_true['means'][i], pop_params_true['SDs'][i],
true_params_T[:,i], pop_params['ranges'][i], 'r')
p.locator_params(nbins = 4)
p.subplot(2, n_params, n_params + i + 1)
_plot_dist_and_hist(pop_params_true['means'][i], pop_params_true['SDs'][i],
None, pop_params['ranges'][i], 'r')
for i in range(n_params):
p.subplot(n_rows, n_params, (n_rows-1) * n_params + i + 1)
_plot_dist_and_hist(pop_params['means'][i], pop_params['SDs'][i],
MAP_params_T[:,i], pop_params['ranges'][i],'k')
p.locator_params(nbins = 4)
p.yticks([])
p.xlabel(population_fit['param_names'][i])
if param_ranges[i] == 'unit':
p.xlim(0,1)
def _plot(y, yerr, MAP_params, rng, param_names):
n_ses, n_params = MAP_params.shape
if ebars:
plt.errorbar(np.arange(n_params)+0.5+x_offset, y, yerr, linestyle='',
linewidth=2, color=col, marker='_', markersize=10)
else:
plt.plot(np.arange(n_params)+0.5+x_offset, y, linestyle='', marker='.',
markersize=6, color=col)
if scatter:
for i in range(n_params):
plt.scatter(i+0.4+x_offset+0.2*np.random.rand(n_ses), MAP_params[:,i],
s=4, facecolor=col, edgecolors='none', lw=0)
plt.xlim(0,n_params)
plt.xticks(np.arange(n_params)+0.5, param_names, rotation=-45, ha='left')
if rng == 'unc':
plt.plot(plt.xlim(),[0,0],'k', linewidth=0.5)
elif rng == 'unit':
plt.ylim(0,1)
elif rng == 'pos':
plt.ylim(0, max(plt.ylim()[1], np.max(MAP_params) * 1.2))
plt.locator_params('y', nbins=5)
def plot(data, w, title):
print title
w = pywt.Wavelet(w)
a = data
ca = []
cd = []
for i in xrange(5):
(a, d) = pywt.dwt(a, w, mode)
ca.append(a)
cd.append(d)
rec_a = []
rec_d = []
for i, coeff in enumerate(ca):
coeff_list = [coeff, None] + [None] * i
rec_a.append(pywt.waverec(coeff_list, w))
for i, coeff in enumerate(cd):
coeff_list = [None, coeff] + [None] * i
rec_d.append(pywt.waverec(coeff_list, w))
pylab.figure()
ax_main = pylab.subplot(len(rec_a) + 1, 1, 1)
pylab.title(title)
ax_main.plot(data)
pylab.xlim(0, len(data) - 1)
pylab.locator_params(axis = 'y', nbins = 5)
pylab.subplots_adjust(hspace=.5)
for i, y in enumerate(rec_a):
#print len(data), len(x), len(data) / (2**(i+1))
ax = pylab.subplot(len(rec_a) + 1, 2, 3 + i * 2)
ax.plot(y, 'r')
pylab.xlim(0, 65)
pylab.ylabel("Coef%d" % (i + 1))
pylab.locator_params(axis = 'y', nbins = 5)
for i, y in enumerate(rec_d):
ax = pylab.subplot(len(rec_d) + 1, 2, 4 + i * 2)
ax.plot(y, 'g')
pylab.xlim(0, 65)
#pylab.ylim(min(0,1.4*min(x)), max(0,1.4*max(x)))
pylab.ylabel("D%d" % (i + 1))
pylab.locator_params(axis = 'y', nbins = 5)
def plot(data, w, title):
print title
w = pywt.Wavelet(w)
a = data
ca = []
cd = []
for i in xrange(5):
(a, d) = pywt.dwt(a, w, mode)
ca.append(a)
cd.append(d)
rec_a = []
rec_d = []
for i, coeff in enumerate(ca):
coeff_list = [coeff, None] + [None] * i
rec_a.append(pywt.waverec(coeff_list, w))
for i, coeff in enumerate(cd):
coeff_list = [None, coeff] + [None] * i
rec_d.append(pywt.waverec(coeff_list, w))
pylab.figure()
ax_main = pylab.subplot(len(rec_a) + 1, 1, 1)
pylab.title(title)
ax_main.plot(data)
pylab.xlim(0, len(data) - 1)
pylab.locator_params(axis='y', nbins=5)
pylab.subplots_adjust(hspace=.5)
for i, y in enumerate(rec_a):
#print len(data), len(x), len(data) / (2**(i+1))
ax = pylab.subplot(len(rec_a) + 1, 2, 3 + i * 2)
ax.plot(y, 'r')
pylab.xlim(0, 65)
pylab.ylabel("Coef%d" % (i + 1))
pylab.locator_params(axis='y', nbins=5)
for i, y in enumerate(rec_d):
ax = pylab.subplot(len(rec_d) + 1, 2, 4 + i * 2)
ax.plot(y, 'g')
pylab.xlim(0, 65)
#pylab.ylim(min(0,1.4*min(x)), max(0,1.4*max(x)))
pylab.ylabel("D%d" % (i + 1))
pylab.locator_params(axis='y', nbins=5)
def contourTri(chain, **kwargs):
"""
#Given a chain, labels and a list of which parameters to plot, plots the contours
# Arguments:
# chain=an array of the chain (not using weights, i.e. each row counts only once)
# p= a list of integers: the two parameters you want to plot (refers to two columns in the chain)
#kwargs: labels= the labels of the parameters (list of strings)
# col=a tuple of the two colours for the contour plot
# line=boolean whether or not to just do a line contour plot
# outfile='triangle.png'
# binsize=50
# reconstruct=boolean whether or not to plot reconstruction
# autoscale=boolean whether or not to autoscale axes
# ranges=dictionary of plot range lists, labelled by
# parameter name, e.g. {'A':[0.0,1.0],etc.}
# title=outdir
p is now ignored
"""
# Collate the contour-region info
bundle = chain
TRUNCATE_C = False
FONTSIZE = 15
ROTATION = 60.0
FIGSIZE = (8.27, 11.69)
DPI = 600
#FIGSIZE=(8.27,11.69); DPI=400
AXIS_LABEL_OFFSET = -0.5 #-0.7
X_LABEL_OFFSET = -0.35 #-0.35 #-0.8
Y_LABEL_OFFSET = -0.4 #-0.4 #-0.6
# !!!! BEWARE THE BINSIZE --- PLOT IS A STRONG FUNCTION OF THIS
if 'binsize' in kwargs:
binsize = kwargs['binsize']
else:
binsize = 50
print 'Using binsize = %i' % binsize
if 'labels' in kwargs:
labels = kwargs['labels']
parameters = labels # How did this ever work without??
else:
labels = ['x', 'y']
if 'ranges' in kwargs:
ranges = kwargs['ranges']
else:
ranges = None
if 'title' in kwargs:
title = kwargs['title']
else:
title = ''
if 'autoscale' in kwargs:
autoscale = kwargs['autoscale']
else:
autoscale = True
p = range(len(labels))
pairs = trianglePairs(p)
nparams = len(p)
# Start setting up the plot
ipanel = 0
ax = {}
pylab.clf()
for panel in pairs:
ipanel += 1
H, xedges, yedges = numpy.histogram2d(chain[:, panel[0]],
chain[:, panel[1]],
bins=(binsize, binsize))
x = []
y = []
z = []
for i in range(len(xedges[:-1])):
for j in range(len(yedges[:-1])):
x.append(xedges[:-1][i])
y.append(yedges[:-1][j])
z.append(H[i, j])
SMOOTH = False
if SMOOTH:
sz = 50
smth = 80e6
spl = interpolate.bisplrep(x, y, z, s=smth)
X = numpy.linspace(min(xedges[:-1]), max(xedges[:-1]), sz)
Y = numpy.linspace(min(yedges[:-1]), max(yedges[:-1]), sz)
Z = interpolate.bisplev(X, Y, spl)
else:
X = xedges[:-1]
Y = yedges[:-1]
Z = H
#I think this is the weird thing I have to do to make the contours work properly
X1 = numpy.zeros([len(X), len(X)])
Y1 = numpy.zeros([len(X), len(X)])
for i in range(len(X)):
X1[:, i] = X
Y1[i, :] = Y
X = X1
Y = Y1
N100, N95, N68 = findconfidence(Z)
if 'col' in kwargs:
col = kwargs['col']
else:
col = ('#a3c0f6', '#0057f6') #A pretty blue
# Now construct the subplot
ax[ipanel] = pylab.subplot2grid((nparams, nparams),
panel[::-1]) # Reverse quadrant
if 'line' in kwargs and kwargs['line'] == True:
CS = pylab.contour(X,
Y,
Z,
levels=[N95, N68, N100],
colors=col,
linewidth=100)
else:
CS = pylab.contourf(X, Y, Z, levels=[N95, N68, N100], colors=col)
# Identify points lying within 68 percent contour region
#print ipanel,bundle.shape,chain.shape
#v=CS.collections[0].get_paths()[0].vertices
#w=CS.collections[1].get_paths()[0].vertices
#print v[:,0]
#print v[:,1]
#b=bundle[:,[panel[0],panel[1]]]
#mask=Path(v).contains_points(b)
#mask2=Path(w).contains_points(b)
#print panel[0],panel[1],b[:,0].size,b[:,0][mask].size,b[:,0][mask2].size,labels[panel[0]],labels[panel[1]]
if 'truth' in kwargs and kwargs['truth'] is not None:
truth = kwargs['truth']
#pylab.plot(truth[labels[panel[0]]],truth[labels[panel[1]]],'r+',\
#markersize=20)
if 'labelDict' in kwargs and kwargs['labelDict'] is not None:
labelDict = kwargs['labelDict']
else:
labelDict = dict((name, name) for name in parameters)
# Set the axis labels only for left and bottom:
#print ax[ipanel].get_xlabel(),ax[ipanel].get_ylabel()
if panel[1] == (nparams - 1):
ax[ipanel].set_xlabel(labelDict[labels[panel[0]]], fontsize=18)
ax[ipanel].xaxis.set_label_coords(
0.5, X_LABEL_OFFSET) # align axis labels
ax[ipanel].xaxis.set_major_formatter(FormatStrFormatter('%.2f'))
ax[ipanel].yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
else:
ax[ipanel].set_xlabel('')
ax[ipanel].get_xaxis().set_ticklabels([])
if panel[0] == 0:
ax[ipanel].set_ylabel(labelDict[labels[panel[1]]], fontsize=18)
ax[ipanel].yaxis.set_label_coords(Y_LABEL_OFFSET,
0.5) # align axis labels
#ax[ipanel].xaxis.set_major_formatter(FormatStrFormatter('%.2f'))
ax[ipanel].yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
else:
ax[ipanel].set_ylabel('')
ax[ipanel].get_yaxis().set_ticklabels([])
# Set plot limits
if autoscale:
# HACK FOR C ONLY:
if TRUNCATE_C and panel[0] == 0:
xxlo, xxhi = ax[ipanel].xaxis.get_data_interval()
if xxhi > 1.0e4:
pylab.xlim(xxlo, 1.0e4)
#ax[ipanel].set_xscale('log')
autoscale = True
#locs,labels = plt.xticks()
#plt.xticks(locs, map(lambda x: "%g" % x, locs*1.0e5))
else:
xlo = ranges[labels[panel[0]]][0]
xhi = ranges[labels[panel[0]]][1]
ylo = ranges[labels[panel[1]]][0]
yhi = ranges[labels[panel[1]]][1]
pylab.xlim(xlo, xhi)
pylab.ylim(ylo, yhi)
# Some housekeeping
pylab.xticks(fontsize=FONTSIZE, rotation=ROTATION)
pylab.yticks(fontsize=FONTSIZE, rotation=0)
pylab.locator_params(nbins=4)
# Set up the 1-D plots on the diagonal
for iparam in range(nparams):
# b=numpy.histogram(R,bins=bins)
J, edges = numpy.histogram(chain[:, iparam],
density=True,
bins=binsize)
ax1d = pylab.subplot2grid((nparams, nparams), (iparam, iparam))
pylab.plot(edges[:-1], J, color='k')
#print iparam,nparams,labels[iparam]
if 'truth' in kwargs and kwargs['truth'] is not None:
truth = kwargs['truth']
#pylab.axvline(truth[parameters[iparam]],color='g')
if iparam == 0:
ax1d.set_ylabel(labelDict[labels[iparam]], fontsize=18)
ax1d.yaxis.set_label_coords(Y_LABEL_OFFSET,
0.5) # align axis labels
if iparam == (nparams - 1):
ax1d.set_xlabel(labelDict[labels[iparam]], fontsize=18)
ax1d.xaxis.set_label_coords(0.5,
X_LABEL_OFFSET) # align axis labels
# Set plot limits
#parameters=['x', 'y', 'S', 'sig', 'Q', 'el', 'em', 'R']
if autoscale:
# HACK FOR C ONLY:
if TRUNCATE_C and iparam == 0:
xxlo, xxhi = ax1d.xaxis.get_data_interval()
if xxhi > 1.0e4:
pylab.xlim(xxlo, 1.0e4)
#ax1d.set_xscale('log')
autoscale = True
if not autoscale:
xlo, xhi = ranges[parameters[iparam]]
pylab.xlim(xlo, xhi)
if TRUNCATE_C and iparam == 0:
xxlo, xxhi = ax1d.xaxis.get_data_interval()
if xxhi > 1.0e4:
pylab.xlim(xxlo, 1.0e4)
if iparam < (nparams - 1):
ax1d.get_xaxis().set_ticklabels([])
ax1d.get_yaxis().set_ticklabels([])
pylab.xticks(fontsize=FONTSIZE, rotation=ROTATION)
pylab.yticks(fontsize=FONTSIZE)
pylab.locator_params(nbins=4)
#if iparam == 0: ax1d.set_xscale('log')
#ax1d.set_xscale('linear')
#axinfo=pylab.subplot2grid((nparams,nparams),(0,nparams-3))
axinfo = pylab.subplot2grid((nparams, nparams),
(0, nparams - nparams % 2 - 1))
axinfo.get_xaxis().set_visible(False)
axinfo.get_yaxis().set_visible(False)
pylab.axis('off')
pylab.title(title)
# Plot the truth - this needs to be generalized for non-lumfunc
if 'truth' in kwargs and kwargs['truth'] is not None:
truth = kwargs['truth']
note = ['nparams %i\n truth:' % nparams]
for k, v in truth.items():
notelet = '%s = %4.2e' % (k, v)
note.append(notelet)
#pylab.text(-1,-1,'\n'.join(note))
if 'reconstruct' in kwargs:
reconstruct = kwargs['reconstruct']
axrecon=pylab.subplot2grid((nparams,nparams),(0,nparams-2),\
rowspan=2,colspan=2)
axrecon.set_xscale('log')
axrecon.set_yscale('log')
pylab.xticks(fontsize=FONTSIZE, rotation=60)
pylab.yticks(fontsize=FONTSIZE)
pylab.locator_params(nbins=5)
median_bins = medianArray(reconstruct[0])
dnds = calculateDnByDs(median_bins, reconstruct[1])
dndsN = calculateDnByDs(median_bins, ksNoisy)
print median_bins
print dnds
print 'truth items \n'
print truth.items()
recon = numpy.zeros(numpy.shape(median_bins))
post = numpy.zeros(numpy.shape(median_bins))
print '# i Smedian ks dnds dndsS2.5 NRecon dndsRecon dndsS2.5Recon log10dnds log10dndsR diffR dndsN'
if nparams == 4:
(C,alpha,Smin,Smax)\
=(truth['C'],truth['alpha'],truth['Smin'],truth['Smax'])
area = 10.0 # Hack
# Reconstruct powerLaw points given truth
for i in range(len(median_bins)):
recon[i]=powerLawFuncS(median_bins[i],\
C,alpha,Smin,Smax,area)
post[i]=powerLawFuncS(median_bins[i],\
9.8,-0.63,0.04,14.1,area)
#recon *= lumfunc.ksRaw
#dndsR=lumfunc.calculateDnByDs(median_bins,recon)
# **** XXXX Where does the 1000 come from!? :(( XXXX
dndsR = recon * 1000.0
dndsP = post * 1000.0
# cols: i Smedian ks dnds dndsS2.5 NRecon dndsRecon
# dndsS2.5Recon log10dnds log10dndsR diffR dndsN
for i in range(len(median_bins)):
print '%i %f %i %i %i %i %i %i %f %f %i %i' % (i,median_bins[i],\
reconstruct[-1][i],dnds[i],\
dnds[i]*median_bins[i]**2.5,recon[i],dndsR[i],\
dndsR[i]*median_bins[i]**2.5,numpy.log10(dnds[i]),\
numpy.log10(dndsR[i]),int(dndsR[i]-dnds[i]),dndsN[i])
#print recon
pylab.xlim(reconstruct[0][0], reconstruct[0][-1])
#pylab.ylim(1.0e2,1.0e8)
#pylab.plot(median_bins,dnds*numpy.power(median_bins,2.5)*lumfunc.sqDeg2sr,'+')
power = 2.5
pylab.plot(median_bins,
dnds * sqDeg2sr * numpy.power(median_bins, power), '+')
pylab.plot(median_bins,
dndsR * sqDeg2sr * numpy.power(median_bins, power), '-')
pylab.plot(median_bins,
dndsN * sqDeg2sr * numpy.power(median_bins, power), '+')
pylab.plot(median_bins,
dndsP * sqDeg2sr * numpy.power(median_bins, power), '-')
#pylab.plot(dnds,dndsR*numpy.power(median_bins,1.0))
#b=lumfunc.simtable(lumfunc.bins,a=-1.5,seed=1234,noise=10.0,dump=False)
if 'outfile' in kwargs:
outfile = kwargs['outfile']
pylab.subplots_adjust(wspace=0, hspace=0)
#pylab.show()
pylab.savefig(outfile, figsize=FIGSIZE, dpi=DPI)
print 'Run: open %s' % outfile
pylab.close()
else:
pylab.show()
return bundle
def plotBias():
def computeBias(): # s-shat
print 'computing bias...'
a = pd.read_pickle('{}ROC/{}'.format(utl.outpath, 'HMM')).s
gp = pd.read_pickle(utl.outpath + 'ROC/GP.causal').s
b = pd.concat([a, gp]).sort_index().xs(True, level='causal')
bias = b.groupby(level=range(4)).apply(lambda x: x.name[-1] - x)
bias.to_pickle('{}ROC/bias.df'.format(utl.outpath))
def biash():
a = pd.read_pickle('{}ROC/bias.df'.format(utl.outpath))
a = a[a.index.get_level_values('method') == 'HMM']
a = a + np.random.randn(a.size)
a /= 10
a[a.index.get_level_values('nu0') == 0.1] /= 2
for name, g in a.groupby(level=range(4)):
g -= g.mean();
a.to_pickle('{}ROC/bias.h.df'.format(utl.outpath))
fontsize = 6
# computeBias()
dpi = 300
for depth in [30, 100, 300]:
reload(pplt)
fig = plt.figure(figsize=(5, 5), dpi=dpi)
j = 0
df = pd.read_pickle(utl.outpath + 'ROC/bias.df').loc[depth].reset_index()
df.method = df.method.replace({'HMM': comaleName})
df = df.set_index(pd.read_pickle(utl.outpath + 'ROC/bias.df').loc[depth].index.names).sort_index().s
dfh = pd.read_pickle(utl.outpath + 'ROC/bias.h.df').loc[depth].reset_index()
dfh.method = dfh.method.replace({'HMM': comaleName})
dfh = dfh.set_index(pd.read_pickle(utl.outpath + 'ROC/bias.h.df').loc[depth].index.names).sort_index().s
df[(0.1, comaleName)] += np.random.rand(df[(0.1, comaleName)].shape[0]) / 100 - 0.005
# df[(0.005, 'HMM')] += np.random.rand(df[(0.005, 'HMM')].shape[0]) / 100 - 0.005
ax = []
for nu0 in [0.005, 0.1]:
if j == 0:
ax += [plt.subplot(2, 2, j + 1)]
else:
ax += [plt.subplot(2, 2, j + 1, sharex=ax[-1], sharey=ax[-1])]
a = pd.DataFrame(df.loc[nu0])
a.columns = ['bias']
a['method'] = a.index.get_level_values('method')
a['s'] = a.index.get_level_values('S')
sns.violinplot(x="s", y="bias", hue="method", data=a, linewidth=1,
palette={comaleName: "r", "GP": "darkblue"}, split=True, ax=ax[j]);
if j < 2: ax[j].set_title(r'$\nu_0=${} ({} Sweep)'.format(nu0, ('Soft', 'Hard')[nu0 == 0.005]),
fontsize=fontsize + 2)
# pplt.annotate(r'$\nu_0=${} ({} Sweep)'.format(nu0, ('Soft', 'Hard')[nu0 == 0.005]),xpad=0.05,ypad=1,fontsize=fontsize)
plt.locator_params(axis='y', nbins=5)
pplt.setSize(plt.gca(), fontsize)
ax[j].set_xlabel('$s$', fontsize=fontsize + 2)
# plt.xlabel('$s$', fontsize=fontsize + 2)
ax[j].legend(title='', loc='upper right', fontsize=fontsize + 2)
ax[j].set_ylabel(('Bias ($s-\hat{s}$)', '')[j % 2], fontsize=fontsize + 2)
if j != 1: ax[j].legend_.remove()
pplt.annotate(ABCD[j], fontsize=fontsize + 2, ax=ax[j])
j += 1
for nu0 in [0.005, 0.1]:
if j == 2:
ax += [plt.subplot(2, 2, j + 1)]
else:
ax += [plt.subplot(2, 2, j + 1, sharex=ax[-1], sharey=ax[-1])]
a = pd.DataFrame(dfh.loc[nu0])
a.columns = ['bias']
a['method'] = a.index.get_level_values('method')
a['s'] = a.index.get_level_values('S')
sns.violinplot(x="s", y="bias", hue="method", data=a[a['method'] == comaleName], linewidth=1,
palette={comaleName: "r", "GP": "g"}, ax=ax[j]);
plt.locator_params(axis='y', nbins=5)
pplt.setSize(plt.gca(), fontsize)
ax[j].set_xlabel('$h$', fontsize=fontsize + 2)
ax[j].set_ylabel(('Bias ($h-\hat{h}$)', '')[j % 2], fontsize=fontsize + 2)
pplt.annotate(ABCD[j], fontsize=fontsize + 2, ax=ax[j])
ax[j].legend_.remove()
j += 1
df = df.groupby(level=['method', 'nu0']).describe().round(3).unstack(['method', 'nu0']).loc[
['mean', 'std']].T.reset_index().sort_values('nu0')
df.columns = ['Method', r'$\nu_0$', 'Mean', 'STD']
utl.DataframetolaTexTable(df, fname=utl.paperPath + 'tables/bias.{}.tex'.format(depth))
pplt.savefig('bias.{}'.format(depth), dpi)
def run_plots(args, scores, all_tasks, keys):
global gs
if args.colorcycle:
if ',' in args.colorcycle:
lst = args.colorcycle.split(',')
else:
lst = list(args.colorcycle)
rc('axes', prop_cycle=matplotlib.cycler('color', lst))
rc('lines', linewidth=args.lw)
title = args.title
if not title:
title = os.path.split(args.files[0])[-2]
pylab.suptitle(title, size=18)
goal_xlim = None
axes = [[None for _ in range(len(all_tasks))] for _ in range(len(keys))]
figkws = {}
if args.figsize:
figkws['figsize'] = map(int, args.figsize.split(','))
fig = pylab.figure(1, **figkws)
task_overlays = args.overlay
if gs is None:
gs = gridspec.GridSpec(len(keys), len(all_tasks) / task_overlays)
for ki, key in enumerate(keys):
for i, task in enumerate(all_tasks):
full_plot_index = ki * len(all_tasks) + i
plot_index = full_plot_index // task_overlays
if args.only_plot and plot_index + 1 != int(
args.only_plot.split(',')[0]):
continue
print("Subplot %s/%s" %
(full_plot_index + 1, len(all_tasks) * len(keys)))
sharex = axes[0][i]
if args.only_plot:
newloc = int(args.only_plot.split(',')[1])
ax = fig.add_subplot(gs[newloc - 1])
axes[ki][i] = ax
else:
axes[ki][i] = fig.add_subplot(gs[plot_index], sharex=sharex)
if ki == len(keys) - 1 and args.startx:
plot_startx(key)
if i == 0 and args.starty:
plot_starty(key)
order = get_value(args.order, i)
if order:
order = map(int, order.split(','))
plot_all(plot_results,
scores,
column=key,
taskset=[task],
order=order)
if not args.global_legend and (not args.one_legend or
(ki == len(keys) - 1 and
(i == len(all_tasks) - 1 or 1))):
pylab.legend(loc=legend_locs.get(key, 0))
if not args.titles:
pylab.title('Task %s' % task)
else:
pylab.title(args.titles.split('|')[plot_index])
maxy = None
if key in ('score', 'errors', 'seq-errors'):
maxy = 1
axes[ki][i].yaxis.set_major_formatter(
mtick.FuncFormatter(lambda x, pos: '% 2d\\%%' % (x * 100)))
ylims = map(float,
get_value(args.ylims,
ki).split(',')) if args.ylims else (0, 1)
pylab.ylim(ylims)
xlims = map(float,
get_value(args.xlims,
i).split(',')) if args.xlims else (0, None)
pylab.xlim(xlims)
if args.nbinsx:
pylab.locator_params(axis='x',
nbins=int(get_value(args.nbinsx, i)))
if args.nbinsy:
pylab.locator_params(axis='y',
nbins=int(get_value(args.nbinsy, ki)))
if args.yticks:
pylab.yticks(map(float, get_value(args.yticks, ki).split(',')))
axes[ki][i].xaxis.set_major_formatter(
mtick.FuncFormatter(lambda x, pos: '%dk' % (x // 1000)
if x else '0'))
rect = [0, 0, 1, .92]
if args.global_legend:
if not args.only_plot:
ax = [row for row in axes if row[0]][0][0]
lines, labels = ax.get_legend_handles_labels()
my_labels = args.global_legend.split('|')
if my_labels == ['1']:
my_labels = labels
if my_labels != ['0']:
if my_labels != ['2']:
fig.legend(lines,
my_labels,
loc='lower center',
ncol=2,
labelspacing=0.)
rect = [0, 0.1, 1, 0.92]
gs.tight_layout(fig, rect=rect)
if args.save_to:
pylab.savefig(args.save_to)
else:
pylab.show()
def plot(best, best_rs, best_v, best_d, best_r):
init_plotting_isi(16, 8)
#___________________Plot final results
#
if eval(inp_dic['SYNTHETIC_F']):
vel_list = [velocity_min, velocity_max, best_v, velocity_real]
dep_list = [depth_min, depth_max, best_d, depth_real]
vpvs_list = [vpvs_min, vpvs_max, best_r, vpvs_real]
colors = ['k', 'k', 'b', 'r']
labels = ['Min', 'Max', 'Best', 'Real']
else:
vel_list = [
velocity_min,
velocity_max,
best_v,
]
dep_list = [depth_min, depth_max, best_d]
vpvs_list = [vpvs_min, vpvs_max, best_r]
colors = ['r', 'k', 'g']
labels = ['Min', 'Max', 'Best']
ax = plt.subplot(121)
[i.set_linewidth(0.6) for i in ax.spines.itervalues()]
for v, d, c, l in zip(vel_list, dep_list, colors, labels):
xs = []
ys = []
x = array(v)
y = array(d)
for i, j in zip(x, y):
xs.append(i)
xs.append(i)
ys.append(j)
ys.append(j)
xs.pop(-1)
ys.pop(0)
xs.append(xs[-1])
ys.append(max(inp_dic['PLT_DP_RNG']))
if l == 'Min':
ax.plot(array(xs),
-array(ys),
linewidth=1.5,
color='k',
linestyle='--',
label=l)
elif l == 'Max':
ax.plot(array(xs),
-array(ys),
linewidth=1.5,
color='k',
linestyle='-.',
label=l)
else:
ax.plot(array(xs),
-array(ys),
linewidth=1.5,
color=c,
linestyle='-',
label=l)
ax.set_xlabel('Velocity [km/s]')
ax.set_ylabel('Depth [km]')
ax.set_xlim(inp_dic['PLT_VP_RNG'])
ax.set_ylim(-array(inp_dic['PLT_DP_RNG'])[::-1])
ax.locator_params(axis='x', nbins=6)
ax.locator_params(axis='y', nbins=6)
ax.grid()
ax.legend(loc=3)
ax = plt.subplot(122)
[i.set_linewidth(0.6) for i in ax.spines.itervalues()]
for r, d, c, l in zip(vpvs_list, dep_list, colors, labels):
xs = []
ys = []
x = array(r)
y = array(d)
for i, j in zip(x, y):
xs.append(i)
xs.append(i)
ys.append(j)
ys.append(j)
xs.pop(-1)
ys.pop(0)
xs.append(xs[-1])
ys.append(max(inp_dic['PLT_DP_RNG']))
if l == 'Min':
ax.plot(array(xs),
-array(ys),
linewidth=1.5,
color='k',
linestyle='--',
label=l)
elif l == 'Max':
ax.plot(array(xs),
-array(ys),
linewidth=1.5,
color='k',
linestyle='-.',
label=l)
else:
ax.plot(array(xs),
-array(ys),
linewidth=1.5,
color=c,
linestyle='-',
label=l)
ax.set_xlabel('VpVs [km/s]')
ax.set_ylabel('Depth [km]')
ax.set_xlim(inp_dic['PLT_R_RNG'])
ax.set_ylim(-array(inp_dic['PLT_DP_RNG'])[::-1])
ax.locator_params(axis='x', nbins=6)
ax.locator_params(axis='y', nbins=6)
ax.grid()
ax.legend(loc=2)
plt.tight_layout()
plt.savefig(dbase_name + '.tiff', dpi=300)
plt.close()
#__________StdDev (V,D,R)
models = loadtxt('models.dat')
model_std = std(models, axis=0)[0]
model_men = mean(models, axis=0)[0]
best = array([best_v, best_d, best_r]).flatten()
tot_ax = ceil(models.shape[1] / 4.)
init_plotting_isi(16, 16)
plt.rcParams['xtick.labelsize'] = 6
plt.rcParams['ytick.labelsize'] = 6
plt.rcParams['axes.labelsize'] = 6
for par in range(models.shape[1]):
ax = plt.subplot(tot_ax, 4, par + 1)
[i.set_linewidth(0.6) for i in ax.spines.itervalues()]
ax.text(0.50,
1.18,
'Parameter-%d' % (par + 1),
fontsize=6,
transform=ax.transAxes,
ha='center',
va='top')
mu = mean(models[:, par])
sig = std(models[:, par])
x = linspace(mu - 3 * sig, mu + 3 * sig, 100)
data = models[:, par]
a, b, c = plt.hist(data, 50, color='r', linewidth=0, alpha=.6)
plt.vlines(best[par], 0, max(a), color='g', zorder=20, linewidth=2)
plt.vlines(mu, 0, max(a), color='b', zorder=20, linewidth=2)
plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
plt.locator_params(axis='x', nbins=6)
plt.locator_params(axis='y', nbins=4)
plt.tight_layout(True)
plt.savefig('models_stat.tiff', dpi=300)
plt.close()
def firasPlot(individualDataDict,
xaxislabel,
yaxislabel,
graphType=None,
colormap = 'YlOrRd'):
'''This produces the bubble plots '''
xL = []
yL = []
area = []
colour = []
areaScalingFactor = 1.7E4
# Plot the y=x line
plt = pylab.subplot(111)
pylab.plot(numpy.arange(0,100),numpy.arange(0,100),linewidth=4,color='g')
pylab.xlabel(xaxislabel,fontsize=30)
pylab.ylabel(yaxislabel,fontsize=30)
pylab.text(1.5,1.2,'No-Change line',fontsize=12)
# Set the axis limits
pylab.tick_params(axis='both', which='major', labelsize=16)
pylab.xlim(0,100)
pylab.ylim(0,100)
for it,val in individualDataDict.iteritems():
try:
coord = [float(g) for g in it.strip('[]').split(',')]
except ValueError: # excludes all blank keys
continue
xL.append(coord[0])
yL.append(coord[1])
area.append(areaScalingFactor*val/sum(individualDataDict.values()))
colour.append('k')
if graphType is None:
for it,val in individualDataDict.iteritems():
try:
coord = [float(g) for g in it.strip('[]').split(',')]
except ValueError: # excludes all blank keys
continue
if val > 0:
pylab.text(coord[0],
coord[1],
val,
size=16,
horizontalalignment='center',
verticalalignment='center',
color='w')
sct = pylab.scatter(xL,
yL,
s=area,
c = colour,
linewidths=2,
edgecolor='k')
#sct.set_alpha(0.65)
pylab.locator_params(axis = 'x', nbins = 6)
pylab.locator_params(axis = 'y', nbins = 6)
elif graphType == 'heatMap':
heatmap = numpy.empty(shape=[101,101])*numpy.nan
for xcoord,ycoord,areaVal in zip(xL,yL,area):
# Get back the number of students
n = areaVal*sum(individualDataDict.values()) / areaScalingFactor
heatmap[ycoord,xcoord] = n
# pylab.text(xcoord,
# ycoord,
# math.trunc(n),
# size=16,
# horizontalalignment='center',
# verticalalignment='center',
# color='k')
# http://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.block_reduce
heatmap_reduced = block_reduce(heatmap, block_size=(10, 10), func=scipy.nansum)
pylab.imshow(heatmap_reduced,
interpolation='None',
origin='lower',
cmap=colormap)
pylab.colorbar()
pylab.xlabel(xaxislabel,fontsize=30)
pylab.ylabel(yaxislabel,fontsize=30)
# Set reduced the axis limits
pylab.tick_params(axis='both', which='major', labelsize=16)
pylab.xlim(0,heatmap_reduced.shape[0])
pylab.ylim(0,heatmap_reduced.shape[1])
return heatmap
def cell_morphs3d(cells_select_df, morphologies, fig, skip=100, color='k'):
ax = fig.gca(projection='3d')
col = 'k'
RotX = np.array([
[1, 0, 0], # rotate around x axis
[0, 0, 1],
[0, 1, 0]
])
ncells_select = len(cells_select_df.index)
rows_display = range(0, ncells_select, skip)
cells_display_df = cells_select_df.iloc[rows_display]
for gid, cell_prop in cells_display_df.iterrows():
x_soma = cell_prop[
'x_soma'] # needed to do those in sequence because Series did not inherite the dtype from DataFrame
y_soma = cell_prop[
'y_soma'] # need to look for a more elegant solution to this
z_soma = cell_prop['z_soma']
pos_soma = np.array([x_soma, y_soma, z_soma])
phi_y = cell_prop['rotation_angle_yaxis']
phi_z = cell_prop['rotation_angle_zaxis']
RotY = rotation_matrix([0, 1, 0], phi_y)
RotZ = rotation_matrix([0, 0, 1], -phi_z)
RotYZ = RotY.dot(RotZ) # apply two rotations
model_id = cell_prop['model_id']
morph_segs_start = morphologies[model_id]["segs_start"]
morph_segs_end = morphologies[model_id]["segs_end"]
segs_start = pos_soma + np.dot(
morph_segs_start,
RotYZ.T) # use the tranposed matrix since we multiply on the right
segs_end = pos_soma + np.dot(morph_segs_end, RotYZ.T)
pos_soma = np.dot(pos_soma, RotX.T) * 1E-3
segs_start = np.dot(segs_start, RotX.T) * 1E-3
segs_end = np.dot(
segs_end, RotX.T
) * 1E-3 # for display purposes switch z and y, convert to mm:
col_segs = build_collection3d(segs_start, segs_end)
ax.add_collection(col_segs) # plot segments
ax.scatter(pos_soma[0],
pos_soma[1],
pos_soma[2],
color='red',
alpha=0.4) # plot somata
set_axes_equal(ax)
ax.set_aspect('equal')
ax.set_xlim([-0.8, 0.8])
ax.set_zlim([-1.2, 0.2])
ax.set_ylim([-0.8, 0.8])
# ax.autoscale_view(True,True,True)
plt.locator_params(nbins=4)
ax.set_xlabel('lat')
ax.set_ylabel('lat')
ax.set_zlabel('depth')
crystal.calc_g0_gH(Energy)
thBragg= float(layer1.calc_Bragg_angle(Energy).subs(layer1.structure.subs).evalf())
angle=pl.linspace(0.992, 1.008,501)*thBragg
crystal.calc_reflectivity(angle, Energy)
layer1.calc_amplitudes(angle, Energy)
Sub.calc_amplitudes(angle, Energy)
XRl = layer1.XR
XRs = Sub.XR
XT = layer1.XT
crystal.print_values(angle, Energy)
pl.plot(data[:,0], data[:,1], label='GID_sl', color='red')
# pl.plot(angle-thBragg,abs(XT)**2-1)
pl.plot(pl.degrees(angle-thBragg),abs(XRl)**2, label='dynXRD', color='black')
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)
pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.2,0.2)
pl.yscale('log')
pl.rc('font', size=18)
pl.legend(loc="upper left", prop={'size':19})
pl.locator_params(axis = 'x', nbins=4)
pl.savefig('pics/test11.eps')
pl.show()
# if (int(data_read[i][2].replace('.', '')) < 100):
# name_of_maps.append(data_read[i][0])
# teamrank.append(int(data_read[i][2].replace('.', '')))
name_of_maps.append(data_read[i][0])
teamrank.append(int(data_read[i][2].replace('.', '')))
ind = np.argsort(teamrank)
sorted_maps = [name_of_maps[i] for i in ind]
sorted_ranks = [teamrank[i] for i in ind]
return sorted_ranks, sorted_maps, nick_name
sorted_ranks_list, sorted_maps_list, name = get_player_data(nickname)
x_val1 = list(range(0, len(sorted_ranks_list)))
# plot
ax1 = plt.subplot()
t = x_val1
plt.scatter(x_val1, sorted_ranks_list, s=5, c=t, cmap='viridis')
plt.ylabel('Team ranks')
plt.title(name + " team ranks")
plt.grid()
plt.locator_params(axis='y', nbins=15)
plt.locator_params(axis='x', nbins=len(sorted_maps_list))
ax1.set_yticks([0, 5, 10], minor=True)
ax1.grid(which='minor', linestyle='--', linewidth='0.5', color='k')
ax1.set_xlim(0, len(sorted_maps_list))
ax1.set_xticklabels(sorted_maps_list, rotation=90, fontsize=8)
plt.show()
interpolation='none')
pl.title('pw-rigid mean')
pl.axis('off')
pl.xlim([0, 100])
pl.ylim([220, 320])
pl.axis('off')
pl.subplot(4, 3, 5)
pl.scatter(r_raw, r_rig, s=50, c='red')
pl.axis('tight')
pl.plot([0, 1], [0, 1], 'k--')
pl.xlabel('raw')
pl.ylabel('rigid')
pl.xlim([0.2, .45])
pl.ylim([.2, .45])
pl.locator_params(nbins=4)
pl.subplot(4, 3, 6)
pl.scatter(r_rig, r_el, s=50, c='red')
pl.plot([0, 1], [0, 1], 'k--')
pl.ylabel('pw-rigid')
pl.xlabel('rigid')
pl.xlim([0.3, .45])
pl.ylim([.3, .45])
pl.locator_params(nbins=4)
pl.subplot(4, 3, 4)
pl.plot(np.arange(0, 3000 * .2, 0.2), r_el)
pl.plot(np.arange(0, 3000 * .2, 0.2), r_rig)
pl.plot(np.arange(0, 3000 * .2, 0.2), r_raw)
pl.xlim([220, 320])
t1 = map(int, parsedate(ts[ind]))
date_obj1 = datetime.datetime(year = t1[0], month = t1[1], day = t1[2], hour = t1[3], minute = t1[4], second = t1[5])
tweet_time.append((date_obj1 - reference_date).total_seconds())
seconds = tweet_time[-1] + 1 # The total number of seconds from the start_time
binarized = numpy.zeros(seconds)
binarized[tweet_time] = 1
axarr[axind].vlines(numpy.arange(seconds)[binarized==1], -0.5, 0.5)
axarr[axind].yaxis.set_visible(False)
pylab.locator_params(axis = 'x', nbins = 5)
pylab.xlabel('Time (s)')
pylab.savefig('_num_tweets.pdf')
pylab.show()
# pylab.figure()
# pylab.hist(interarrivals, bins = numpy.unique(interarrivals).shape[0], normed = True)
# pylab.show()
# Q: How to deal with *night-time*?
# pylab.figure()
# pylab.hist(num_tweets[0,:], bins = 200, normed = True)
# pylab.xlabel('Number of Tweets Made')
# pylab.ylabel('Count of Users Making that Number of Tweets')
# pylab.show()
def plot_reasonably_calibrated_errors(result, filename=None):
pylab.rcParams.update({'font.size': 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(10,8), facecolor='w', edgecolor='k')
num_cols = result['config']['num_cols']
ax = pylab.subplot(2,3,1)
pylab.plot([0,1],[0,1], color='black', lw=3)
for col in range(num_cols):
X = numpy.cumsum(result['actual_frequencies'][col])
Y = numpy.cumsum(result['inferred_P_cc'][col])
pylab.plot(X, Y, color='green', alpha = .5, lw=2)
pylab.ylabel('Inferred frequencies')
pylab.xlabel('Actual frequencies')
ax.set_yticks([0,.5,1])
ax.set_xticks([0,.5,1])
pylab.title('CrossCat')
pylab.xlim([0,1])
pylab.ylim([0,1])
ax = pylab.subplot(2,3,2)
pylab.plot([0,1],[0,1], color='black', lw=3)
for col in range(num_cols):
X = numpy.cumsum(result['actual_frequencies'][col])
Y = numpy.cumsum(result['inferred_P_crp'][col])
pylab.plot(X, Y, color='blue', alpha = .5, lw=2)
pylab.ylabel('Inferred frequencies')
pylab.xlabel('Actual frequencies')
ax.set_yticks([0,.5,1])
ax.set_xticks([0,.5,1])
pylab.title('CRP mixture')
pylab.xlim([0,1])
pylab.ylim([0,1])
ax = pylab.subplot(2,3,3)
pylab.plot([0,1],[0,1], color='black', lw=3)
for col in range(num_cols):
X = numpy.cumsum(result['actual_frequencies'][col])
Y = numpy.cumsum(result['inferred_P_nb'][col])
pylab.plot(X, Y, color='red', alpha = .5, lw=2)
pylab.ylabel('Inferred frequencies')
pylab.xlabel('Actual frequencies')
ax.set_yticks([0,.5,1])
ax.set_xticks([0,.5,1])
pylab.title('Naive Bayes')
pylab.xlim([0,1])
pylab.ylim([0,1])
ax = pylab.subplot(2,3,4)
num_iters = result['config']['num_iters']
num_rows = result['config']['num_rows']
num_chains = result['config']['num_chains']
num_views = result['config']['num_views']
num_clusters = result['config']['num_clusters']
prop_missing = result['config']['prop_missing']
multinomial_categories = result['config']['multinomial_categories']
txt = '''
Cumulated frequency plots over missing values for multinomial data. Each line
represents the distribution of a column. Y-axis is the inferred distribution
and the x-axis is the actual distribution. Each line can be thought of as a
multinomial P-P plot using normalized frequencies over missing values.
BayesDB: normal configuration
BayesDB CRP mixture configuration: one view, no column transitions
BayesDB Naive Bayes configuration: one view, one category, only hyperparameter
transitions
The table was %i rows by %i cols with %i views and %i categories per view. Each
column's data was generates from a multinomial distribution with %i values. %1.2f
percent of the data was removed.
%i chains of where run for %i iterations for each configuration.
''' % (num_rows, num_cols, num_views, num_clusters, multinomial_categories, prop_missing*100, \
num_chains, num_iters)
ax.text(0,0,txt, fontsize=9)
ax.axis('off')
if filename is None:
filename = 'Reasonably_calibrated=%i_chains=%i_T=%i.png' % \
(num_iters, num_chains, int(time.time()))
pylab.savefig( filename )
def true_vs_fitted_session_params(population_fit):
''' For a set of simulated sessions plot the fitted parameter values
against the true paramter values to assess goodness of fit. If the
population fit includes ML fits, these are plotted as well as the MAP_fit
fits and some metrics of the difference in fit quality are provided.'''
#Unpack true and fitted parameter values into arrays.
true_params_U = np.array(population_fit['true_values']['params_U']).T
true_params_T = np.array(population_fit['true_values']['params_T']).T
MAP_params_U = np.array([MAP_fit['params_U'] for MAP_fit in population_fit['MAP_fits'] ]).T
MAP_params_T = np.array([MAP_fit['params_T'] for MAP_fit in population_fit['MAP_fits'] ]).T
n_params = np.shape(true_params_U)[0]
n_sessions = np.shape(true_params_U)[1]
cols = (np.arange(n_sessions) + 0.01)/n_sessions
n_rows = 2
p.figure(2)
p.clf()
if not population_fit['ML_fits'] is None:
ML_params_U = np.array([ML_fit['params_U'] for ML_fit in population_fit['ML_fits'] ]).T
ML_params_T = np.array([ML_fit['params_T'] for ML_fit in population_fit['ML_fits'] ]).T
#Evaluate and print fit errors.
ML_mean_abs_error_T = np.mean(np.abs(ML_params_T - true_params_T), 1)
MAP_mean_abs_error_T = np.mean(np.abs(MAP_params_T - true_params_T), 1)
mean_abs_error_MAP_bonus = ML_mean_abs_error_T - MAP_mean_abs_error_T
ML_error_of_mean_T = np.abs(np.mean(ML_params_T, 1) - np.mean(true_params_T, 1))
MAP_error_of_mean_T = np.abs(np.mean(MAP_params_T, 1) - np.mean(true_params_T, 1))
error_of_mean_MAP_bonus = ML_error_of_mean_T - MAP_error_of_mean_T
print('MAP bonus - mean absolute error: {}'.format(mean_abs_error_MAP_bonus))
print('MAP bonus - error of mean : {}'.format(error_of_mean_MAP_bonus))
n_rows = 4
for true_params_U_i, true_params_T_i, ML_params_U_i, ML_params_T_i, i in \
zip(true_params_U, true_params_T, ML_params_U, ML_params_T, range(n_params)):
p.subplot(4, n_params, 2 * n_params + i + 1)
p.scatter(true_params_U_i, ML_params_U_i, c = cols, cmap = 'hsv', vmin = 0., vmax = 1.)
p.plot([min(true_params_U_i), max(true_params_U_i)], [min(true_params_U_i), max(true_params_U_i)] , 'k')
p.locator_params(axis = 'x', nbins = 4, tight = True)
p.subplot(4, n_params, 3 * n_params + i + 1)
p.scatter(true_params_T_i, ML_params_T_i, c = cols, cmap = 'hsv', vmin = 0., vmax = 1.)
p.plot([min(true_params_T_i), max(true_params_T_i)], [min(true_params_T_i), max(true_params_T_i)] , 'k')
p.locator_params(axis = 'x', nbins = 4, tight = True)
p.subplot(4, n_params, 1 + 2 * n_params)
p.title('ML Fits: Unconstrained space')
p.subplot(4, n_params, 1 + 3 * n_params)
p.title('ML Fits: True space')
for true_params_U_i, true_params_T_i, MAP_params_U_i, MAP_params_T_i, i in \
zip(true_params_U, true_params_T, MAP_params_U, MAP_params_T, range(n_params)):
p.subplot(n_rows, n_params, i + 1)
p.scatter(true_params_U_i, MAP_params_U_i, c = cols, cmap = 'hsv', vmin = 0., vmax = 1.)
p.plot([min(true_params_U_i), max(true_params_U_i)], [min(true_params_U_i), max(true_params_U_i)] , 'k')
p.locator_params(axis = 'x', nbins = 4, tight = True)
p.subplot(n_rows, n_params, 1 * n_params + i + 1)
p.scatter(true_params_T_i, MAP_params_T_i, c = cols, cmap = 'hsv', vmin = 0., vmax = 1.)
p.plot([min(true_params_T_i), max(true_params_T_i)], [min(true_params_T_i), max(true_params_T_i)] , 'k')
p.locator_params(axis = 'x', nbins = 4, tight = True)
p.subplot(n_rows, n_params, 1)
p.title('MAP Fits: Unconstrained space')
p.subplot(n_rows, n_params, 1 + n_params)
p.title('MAP Fits: True space')
for i in range(n_params):
p.subplot(n_rows, n_params, i + 1 + (n_rows - 1) * n_params)
p.xlabel(population_fit['param_names'][i])
max_shft], cmap='gray', vmax=vmax, interpolation='none')
pl.title('pw-rigid mean')
pl.axis('off')
pl.xlim([0, 100])
pl.ylim([220, 320])
pl.axis('off')
pl.subplot(4, 3, 5)
pl.scatter(r_raw, r_rig, s=50, c='red')
pl.axis('tight')
pl.plot([0, 1], [0, 1], 'k--')
pl.xlabel('raw')
pl.ylabel('rigid')
pl.xlim([0.2, .45])
pl.ylim([.2, .45])
pl.locator_params(nbins=4)
pl.subplot(4, 3, 6)
pl.scatter(r_rig, r_el, s=50, c='red')
pl.plot([0, 1], [0, 1], 'k--')
pl.ylabel('pw-rigid')
pl.xlabel('rigid')
pl.xlim([0.3, .45])
pl.ylim([.3, .45])
pl.locator_params(nbins=4)
pl.subplot(4, 3, 4)
pl.plot(np.arange(0, 3000 * .2, 0.2), r_el)
pl.plot(np.arange(0, 3000 * .2, 0.2), r_rig)
pl.plot(np.arange(0, 3000 * .2, 0.2), r_raw)
n, bins, patches = P.hist(out[:, col_j],
50,
normed=1,
histtype='stepfilled',
color='white')
y = P.normpdf(bins, m, s)
P.plot(bins, y, 'b--', linewidth=1.5)
ax.annotate(r"$\epsilon = %.3g\%%$" % (s / m * 100),
xy=(0.5, 0.125),
xycoords='axes fraction',
horizontalalignment='center',
verticalalignment='center')
P.xlabel(name)
ax.set_yticklabels('', visible=False)
P.locator_params(axis='x', nbins=3)
xticks = [m - 3 * s, m, m + 3 * s]
ax.set_xlim([m - 4 * s, m + 4 * s])
ax.set_xticks(xticks)
ax.set_xticklabels(['%.3g' % xtick for xtick in xticks])
#ax.minorticks_on()
#"""
plt.tight_layout()
print(outstr)
plt.subplots_adjust(top=0.9)
plt.savefig(os.path.join('learn_plots', '16Cyg-c.png'))
plt.close()
def _plot_exponential_fit(fit, p_1, pre_post_trials, last_n, col = 'r'):
t = np.arange(0,pre_post_trials[1])
p_traj = np.hstack([ut.nans(-pre_post_trials[0]-last_n), np.ones(last_n) * fit['p_0'], \
_exp_choice_traj(fit['tau'], fit['p_0'], p_1, t)])
p.plot(range(pre_post_trials[0], pre_post_trials[1]),p_traj, col, linewidth = 2)
p.locator_params(nbins = 4)
def plotNull(subp, nu0=0.005, fontsize=5):
obs = pd.read_pickle(utl.outpath + 'markov/neutral.obs.{}.pkl'.format(nu0))
T = Markov.computeTransition(0, N=1000)
dfplt = pd.concat([pd.Series({'scale': 10, 'xlim': [0.0, 0.01], 'ylim': [0, 1]}, name=(0.005, 1)),
pd.Series({'scale': 30, 'xlim': [0.06, 0.14], 'ylim': [0, 0.15]}, name=(0.1, 1)),
pd.Series({'scale': 30, 'xlim': [0.0, 0.015], 'ylim': [0, 0.3]}, name=(0.005, 10)),
pd.Series({'scale': 45, 'xlim': [0.0, 0.2], 'ylim': [0, 0.025]}, name=(0.1, 10)),
pd.Series({'scale':30, 'xlim':[0.0,0.03],'ylim': [0,0.2]},name=(0.005,100)),pd.Series({'scale':50, 'xlim':[0.00,0.4],'ylim': [0,0.004]},name=(0.1,100))
],axis=1).T
markov=T.loc[nu0].copy(True);markov.name='Markov Chain'
xx=np.arange(0,1,0.00001)
N=200; tau=1;h=2*nu0*(1-nu0);sig2=h*tau/N;brownian=stats.norm(nu0, sig2).pdf(xx);
brownian=pd.Series(brownian,index=xx);brownian/=brownian.sum();brownian.name='Brownian Motion';brownian*=dfplt.loc[(nu0,tau)].scale
pplt.setSize(plt.gca(), fontsize=fontsize)
plt.subplot(3, 3, subp[0]);
brownian.plot(color='r');
markov.plot(color='b');
o=pd.Series(obs.X[1].flatten()).value_counts().sort_index();o=o/o.sum();
if nu0==0.1:
counts,limits=np.histogram(obs.X[1].flatten(),bins=500,range=[0,1]);centers = 0.5*(limits[1:]+limits[:-1]);o=pd.Series(counts,index=centers);o=o/(obs.X.shape[1]*obs.X.shape[2]*4)
o.plot(color='g')
plt.xlim(dfplt.loc[(nu0, tau)].xlim);
plt.ylim(dfplt.loc[(nu0, tau)].ylim);
plt.locator_params(nbins=3)
pplt.annotate(r'$s=0$, $\nu_0=${}, $\tau$={}'.format(nu0, tau), fontsize=fontsize)
plt.ylabel(r'$P(\nu_\tau|\nu_0)$')
tau=10
for _ in range(9):
markov=markov.dot(T)
N=200;h=2*nu0*(1-nu0);sig2=h*tau/N;brownian=stats.norm(nu0, sig2).pdf(xx)
brownian=pd.Series(brownian,index=xx);brownian/=brownian.sum();brownian.name='Brownian Motion';
brownian*=dfplt.loc[(nu0,tau)].scale
pplt.setSize(plt.gca(), fontsize=fontsize)
plt.title('({})'.format(subptitle[subp[0] - 1]), fontsize=fontsize)
plt.subplot(3, 3, subp[1]);
brownian.plot(color='r');
markov.plot(color='b');
o=pd.Series(obs.X[10].flatten()).value_counts().sort_index();o=o/o.sum();
if nu0==0.1:
counts,limits=np.histogram(obs.X[10].flatten(),bins=100,range=[0,1]);centers = 0.5*(limits[1:]+limits[:-1]);o=pd.Series(counts,index=centers);o=o/(obs.X.shape[1]*obs.X.shape[2]*20)
o.plot(color='g')
plt.xlim(dfplt.loc[(nu0, tau)].xlim);
plt.ylim(dfplt.loc[(nu0, tau)].ylim);
plt.locator_params(nbins=3)
pplt.annotate(r'$s=0$, $\nu_0=${}, $\tau$={}'.format(nu0, tau), loc=1, fontsize=fontsize)
pplt.setSize(plt.gca(), fontsize=fontsize)
tau=100
for _ in range(90):
markov=markov.dot(T)
N=200;h=2*nu0*(1-nu0);sig2=h*tau/N;brownian=stats.norm(nu0, sig2).pdf(xx)
brownian=pd.Series(brownian,index=xx);brownian/=brownian.sum();brownian.name='Brownian Motion';
brownian*=dfplt.loc[(nu0,tau)].scale
plt.title('({})'.format(subptitle[subp[1] - 1]), fontsize=fontsize)
plt.subplot(3, 3, subp[2]);
brownian.plot(color='r');
markov.plot(color='b')
o=pd.Series(obs.X[100].flatten()).value_counts().sort_index();o=o/o.sum();
if nu0==0.1:
counts,limits=np.histogram(obs.X[100].flatten(),bins=30,range=[0,1]);centers = 0.5*(limits[1:]+limits[:-1]);o=pd.Series(counts,index=centers);o=o/(obs.X.shape[1]*obs.X.shape[2]*60)
o.name = 'Observation';
o.plot(color='g')
plt.xlim(dfplt.loc[(nu0, tau)].xlim);
plt.ylim(dfplt.loc[(nu0, tau)].ylim);
plt.locator_params(nbins=3)
pplt.annotate(r'$s=0$, $\nu_0=${}, $\tau$={}'.format(nu0, tau), loc=1, fontsize=fontsize)
if subp[2] == 3:
plt.legend(loc='center right', fontsize=fontsize)
pplt.setSize(plt.gca(), fontsize=fontsize)
plt.title('({})'.format(subptitle[subp[2] - 1]), fontsize=fontsize)
# pylab.plot(np.arange(DELAY_MAX + 1) * average_sampling_time, acf[i, :], "k-")
# Plot min and mac auto-correlation for each lag from ensemble
pylab.fill_between(np.arange(DELAY_MAX + 1) * average_sampling_time,
acf.min(axis=0),
acf.max(axis=0),
color="0.75")
# Load Kernel ACF computed using Kira's method
kernel_acf = pylab.loadtxt("kernel_acf_dongge.txt")
pylab.plot(kernel_acf[:, 0], kernel_acf[:, 1], "k-")
pylab.xlabel("Time lag (a)")
pylab.ylabel("Autocorrelation")
pylab.xlim(0, DELAY_TIME_MAX)
pylab.ylim(-0.4, 1)
# Enable minor ticks
pylab.minorticks_on()
# Set number of ticks and tick labels
pylab.locator_params(axis="y", tight=True, nbins=5)
pylab.axhline(y=0, color="k", linestyle="dashed")
pylab.savefig("dongge_acf.pdf")
pylab.show()
layer1.calc_orientation_from_angle(psi, v_perp)
crystal=reflectivity.Sample(Sub, layer1)
#crystal.calc_layer_Miller()
crystal.set_Miller(R)
crystal.calc_g0_gH(Energy)
thBragg= float(Sub.calc_Bragg_angle(Energy).subs(Sub.structure.subs).evalf())
angle=pl.linspace(0.987, 1.013,501)*thBragg
#XRl = layer1.calc_reflection_amplitude(angle, Energy)
#XRs = Sub.calc_reflection_amplitude(angle, Energy)
# XT = layer1.calc_transmission_amplitude(angle, Energy)
XR=crystal.calc_reflectivity(angle, Energy)
crystal.print_values(angle, Energy)
pl.plot(data[:,0], data[:,1] , label='GID_sl', color='red')
# pl.plot(angle-thBragg,abs(XT)**2)
# pl.plot(angle-thBragg,abs(XRl)**2)
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)
pl.plot(pl.degrees(angle-thBragg),abs(XR)**2, label='dynXRD', color='black')
#pl.plot(angle-thBragg,abs(XRs)**2)
#pl.plot(angle-thBragg,abs(XRl)**2)
pl.yscale('log')
pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.2,0.2)
pl.rc('font', size=18)
pl.legend(loc="upper left", prop={'size':19})
pl.locator_params(axis = 'x', nbins=4)
pl.savefig('pics/test14.eps')
pl.show()
def plot_star(star, predict, y_names, out_dir=plot_dir):
## Regular histograms
middles = np.mean(predict, 0)
stds = np.std(predict, 0)
#outstr = star
num_ys = predict.shape[1]
rows, cols, sqrt = get_rc(num_ys)
plt.figure(figsize=(6.97522*2, 4.17309*2), dpi=400,
facecolor='w', edgecolor='k')
for (pred_j, name) in enumerate(y_names[0:num_ys]):
(m, s) = (middles[pred_j], stds[pred_j])
if num_ys%2==0 or num_ys%3==0 or int(sqrt)==sqrt:
ax = plt.subplot(rows, cols, pred_j+1)
elif pred_j%2==0 and pred_j == num_ys-1:
ax = plt.subplot2grid((rows, cols), (pred_j//2, 1), colspan=2)
else:
ax = plt.subplot2grid((rows, cols), (pred_j//2, (pred_j%2)*2),
colspan=2)
n, bins, patches = ax.hist(predict[:,pred_j], 50, normed=1,
histtype='stepfilled', color='white')
#if y_central is not None:
# mean = np.mean(y_central[:,pred_j])
# std = np.std(y_central[:,pred_j])
#
# plot_line(mean, n, bins, plt, 'r--')
# plot_line(mean+std, n, bins, plt, 'r-.')
# plot_line(mean-std, n, bins, plt, 'r-.')
q_16, q_50, q_84 = corner.quantile(predict[:,pred_j], [0.16, 0.5, 0.84])
q_m, q_p = q_50-q_16, q_84-q_50
plot_line(q_50, n, bins, plt, 'k--')
plot_line(q_16, n, bins, plt, 'k-.')
plot_line(q_84, n, bins, plt, 'k-.')
# Format the quantile display.
fmt = "{{0:{0}}}".format(".3g").format
title = r"${{{0}}}_{{-{1}}}^{{+{2}}}$"
title = title.format(fmt(q_50), fmt(q_m), fmt(q_p))
ax.annotate(r"$\epsilon = %.3g\%%$" % (s/m*100),
xy=(0.99, 0.12), xycoords='axes fraction',
horizontalalignment='right', verticalalignment='right')
P.xlabel(y_latex[y_names[pred_j]] + " = " + title)
P.locator_params(axis='x', nbins=3)
xs = [max(0, m-4*s), m+4*s]
xticks = [max(0, m-3*s), m, m+3*s]
ax.set_xticks(xticks)
ax.set_xlim(xs)
ax.set_xticklabels(['%.3g'%xtick for xtick in xticks])
ax.set_yticklabels('',visible=False)
ax.set_frame_on(False)
ax.get_xaxis().tick_bottom()
ax.axes.get_yaxis().set_visible(False)
#xmin, xmax = ax1.get_xaxis().get_view_interval()
ymin, ymax = ax.get_yaxis().get_view_interval()
ax.add_artist(mpl.lines.Line2D(xs, (ymin, ymin),
color='black', linewidth=2))
#ax.minorticks_on()
plt.tight_layout()
plt.savefig(os.path.join(out_dir, star + '.pdf'), dpi=400)
plt.close()
'csv/carry_errors_big.csv',
dict(label='Train on random examples'),
)
make_plot(
'csv/carry_errors_big.baddt.csv',
dict(label='Train with some hard examples'),
)
#pylab.xlabel("Number of carries $k$")
#pylab.legend(loc=0, prop={'size': legsize})
pylab.gca().yaxis.set_major_formatter(
mtick.FuncFormatter(lambda x, pos: '% 2d%%' % (x * 100)))
if not vertical:
pylab.xlabel("Number of carries $k$")
pylab.ylabel("Error rate")
pylab.title("Binary", size=titlesize)
pylab.locator_params(axis='y', nbins=4) #
pylab.subplot(*(orientation + (2, )))
make_plot(
'csv/carry_errors_add_large.csv',
dict(label='Train on random examples'),
)
make_plot(
'csv/carry_errors_addt_large.csv',
dict(label='Train with some hard examples'),
)
pylab.xlabel("Number of carries $k$")
#pylab.legend(loc=0, prop={'size': legsize})
if vertical:
pylab.ylabel("Error rate")
pylab.gca().yaxis.set_major_formatter(
joystick_handle = jh
if jj == 0:
handles.append(th)
ax.set_xlabel('x [m]', fontsize=fontsize)
ax.set_ylabel('y [m]', fontsize=fontsize)
pl.axis('equal')
ax.set_xlim([-15, 6])
ax.set_ylim([-8, 2])
ax.tick_params(labelsize=fontsize)
pl.legend((handles[0][0], handles[1][0], joystick_handle[0][0]),
(names[0], names[1], 'Joystick'),
loc='best',
fancybox=True,
framealpha=0.5,
numpoints=1)
pl.locator_params(nbins=8)
pl.tight_layout()
pl.subplots_adjust(left=0.17, right=0.95, top=0.95, bottom=0.15)
abs_dist = np.zeros([len(planner_missions[0])])
joy_dist = np.zeros([len(planner_missions[0])])
fused_missions = planner_missions_background
fused_missions.append(planner_missions[0])
for miss in fused_missions:
for ii, m in enumerate(miss):
abs_dist[ii] += m.distance()
joy_dist[ii] += pc_util.compute_joystick_distance(m)
autonomous_ratio = 100 * (1 - joy_dist / abs_dist)
if save_figures:
i = 0
textfs = 32
markersize = 200
fig = pl.figure()
pl.subplots_adjust(left=0.1,
bottom=0.1,
right=0.9,
top=0.88,
wspace=0.35,
hspace=0.1)
pl.subplot(1, 2, 1)
pl.locator_params(nbins=7)
# pl.scatter(norms, wrongs_d[i], alpha=0.75, s=markersize, label='desired B-tensors')
pl.scatter(norms,
wrongs_d[i],
alpha=0.75,
s=markersize,
label=r'Fit using $\mathbf{{B}}$',
edgecolors=None)
# pl.scatter(norms, propers_d[i], alpha=0.75, s=markersize, label='actual B-tensors')
pl.scatter(norms,
propers_d[i],
alpha=0.75,
s=markersize,
label=r'Fit using $\mathbf{{B}}_a$',
edgecolors=None)
k = max(max(propers_d[i]), max(wrongs_d[i]))
def plot_reasonably_calibrated_errors(result, filename=None):
pylab.rcParams.update({"font.size": 8})
pylab.locator_params(nbins=3)
fig = pylab.figure(num=None, figsize=(10, 8), facecolor="w", edgecolor="k")
num_cols = result["config"]["num_cols"]
ax = pylab.subplot(2, 3, 1)
pylab.plot([0, 1], [0, 1], color="black", lw=3)
for col in range(num_cols):
X = numpy.cumsum(result["actual_frequencies"][col])
Y = numpy.cumsum(result["inferred_P_cc"][col])
pylab.plot(X, Y, color="green", alpha=0.5, lw=2)
pylab.ylabel("Inferred frequencies")
pylab.xlabel("Actual frequencies")
ax.set_yticks([0, 0.5, 1])
ax.set_xticks([0, 0.5, 1])
pylab.title("CrossCat")
pylab.xlim([0, 1])
pylab.ylim([0, 1])
ax = pylab.subplot(2, 3, 2)
pylab.plot([0, 1], [0, 1], color="black", lw=3)
for col in range(num_cols):
X = numpy.cumsum(result["actual_frequencies"][col])
Y = numpy.cumsum(result["inferred_P_crp"][col])
pylab.plot(X, Y, color="blue", alpha=0.5, lw=2)
pylab.ylabel("Inferred frequencies")
pylab.xlabel("Actual frequencies")
ax.set_yticks([0, 0.5, 1])
ax.set_xticks([0, 0.5, 1])
pylab.title("CRP mixture")
pylab.xlim([0, 1])
pylab.ylim([0, 1])
ax = pylab.subplot(2, 3, 3)
pylab.plot([0, 1], [0, 1], color="black", lw=3)
for col in range(num_cols):
X = numpy.cumsum(result["actual_frequencies"][col])
Y = numpy.cumsum(result["inferred_P_nb"][col])
pylab.plot(X, Y, color="red", alpha=0.5, lw=2)
pylab.ylabel("Inferred frequencies")
pylab.xlabel("Actual frequencies")
ax.set_yticks([0, 0.5, 1])
ax.set_xticks([0, 0.5, 1])
pylab.title("Naive Bayes")
pylab.xlim([0, 1])
pylab.ylim([0, 1])
ax = pylab.subplot(2, 3, 4)
num_iters = result["config"]["num_iters"]
num_rows = result["config"]["num_rows"]
num_chains = result["config"]["num_chains"]
num_views = result["config"]["num_views"]
num_clusters = result["config"]["num_clusters"]
prop_missing = result["config"]["prop_missing"]
multinomial_categories = result["config"]["multinomial_categories"]
txt = """
Cumulated frequency plots over missing values for multinomial data. Each line
represents the distribution of a column. Y-axis is the inferred distribution
and the x-axis is the actual distribution. Each line can be thought of as a
multinomial P-P plot using normalized frequencies over missing values.
BayesDB: normal configuration
BayesDB CRP mixture configuration: one view, no column transitions
BayesDB Naive Bayes configuration: one view, one category, only hyperparameter
transitions
The table was %i rows by %i cols with %i views and %i categories per view. Each
column's data was generates from a multinomial distribution with %i values. %1.2f
percent of the data was removed.
%i chains of where run for %i iterations for each configuration.
""" % (
num_rows,
num_cols,
num_views,
num_clusters,
multinomial_categories,
prop_missing * 100,
num_chains,
num_iters,
)
ax.text(0, 0, txt, fontsize=9)
ax.axis("off")
if filename is None:
filename = "Reasonably_calibrated=%i_chains=%i_T=%i.png" % (num_iters, num_chains, int(time.time()))
pylab.savefig(filename)
#make g(t)
g[n] = []
#doing the sum for each t and populate g(t)
for i in t:
g_i = ([(c_k * numpy.sin(w_k * i))
for c_k, w_k in zip(c_karray, w_karray)])
g[n].append(sum(g_i))
#plotting in a cutie way
n_plots = len(n_array)
cols = 2
rows = n_plots / cols
pylab.figure(1)
pylab.suptitle("Square waveform simulation", fontsize=14)
for h, n in zip(range(1, n_plots + 1, 1), n_array):
pylab.subplot(rows, cols, h)
pylab.plot(t / T, g[n], label='n = %d' % n) #setting period as x-unit
pylab.legend(prop={'size': 10})
pylab.locator_params(nbins=4)
pylab.grid()
#not really elegant, but less boring...
if (h == 3):
pylab.ylabel('Simulated Signal [arb.un.]', size='large')
if (h == 5) or (h == 6):
pylab.xlabel('Time [T]', size='large')
pylab.show()
def draw_ST_space(alpha = 0, debug = False, points = 11, reps = 2, force = False, file_format = 'png', output = True, **kwargs):
"""
Takes model III and plots the results over all of ST space. Two heat maps
are created, one for x_bar and one for beta_bar.
Params
======
alpha : float [0,1] {0} :
alpha, i.e. r genetic assortment.
debug : bool {False}
Set to true to very quickly run the model to see if it is working.
points : int {11}
Number of descrete points to break up the space into.
reps : int {2}
Number of times to repeat the model.
force : bool {False}
The function will pickle the outputs, set to true to force the
function to regenerate the data.
file_format : str {'png'}
Type of figure file to save. Anything that matplotlib will accept
output : bool {True}
Set to False to not save data and figure. You'll only be able to
see the outputs if you're running interactively.
kwargs :
Additional keyword arguments passed to GP_evo model.
"""
label_size = 18
tick_label_size = 15
legend_label_size = 13
##We don't want this to be the integer 1 or 0, it messes with the formatting!
alpha = float(alpha)
Ss = np.linspace(-1,4,points)
Ts = np.linspace(0,4,points)
beta_data_file = os.path.join( data_dir, "ST_sweep_beta_%.2f"%alpha )
x_data_file = os.path.join( data_dir, "ST_sweep_x_%.2f"%alpha )
#See if the data has been generated already
try:
##Bit of a hack
if force:
raise IOError
f1 = open( beta_data_file,'rb')
data_beta_bar = pickle.load( f1 )
f1.close()
f2 = open( x_data_file, 'rb' )
data_x_bar = pickle.load( f2)
f1.close()
print "Data Found"
except IOError:
print "No Data Found, generating ..."
data_x_bar = np.zeros( ( points, points, reps ) )
data_beta_bar = np.zeros( ( points, points, reps ) )
for k in xrange(reps):
print "Rep:",k + 1
for i,S in enumerate( Ss ):
for j,T in enumerate( Ts ):
#print S,T
if debug:
mod = GP_evo(S,T, alpha = alpha, x_points = 3, beta_points = 2, makeGraphs = False, printInfo = False, **kwargs)
else:
mod = GP_evo(S,T, alpha = alpha, makeGraphs = False, printInfo = False, **kwargs)
mod.go()
data_x_bar[i,j,k] = mod.mean_x
data_beta_bar[i,j,k] = mod.mean_b
##Save the data
if output:
print "Saving data at " + beta_data_file
f1 = open( beta_data_file,'wb')
pickle.dump( data_beta_bar, f1 )
f1.close()
print "Saving data at " + x_data_file
f2 = open( x_data_file,'wb')
pickle.dump( data_x_bar, f2)
f2.close()
##Create a red green blue array for x data
# x_mean = np.mean( data_x_bar, 2 )
# RGB_data = np.array( [[ [ 1 - x_mean[i,j], 0 , x_mean[i,j], 0.1 ] for i in xrange(points) ] for j in xrange(points) ] )
#cmap = pl.get_cmap('Reds')
##Create a colour map using seaborn
cmap_linear = mpl.colors.ListedColormap( sns.light_palette((210, 90, 60), input="husl", n_colors = 101) )
##For diverging colour
cmap_diverging = mpl.colors.ListedColormap( sns.diverging_palette(10, 220, sep=80, n=101) )
f = pl.figure()
pl.subplot(121)
pl.imshow( np.mean( data_x_bar, 2), origin = [Ts[0], Ss[0]], interpolation = 'nearest',\
extent = [ Ts[0],Ts[-1],Ss[0],Ss[-1] ], vmin = 0, vmax = 1, cmap = cmap_linear )
# pl.imshow( RGB_data, origin = [Ts[0], Ss[0]], interpolation = 'nearest',\
# extent = [ Ts[0],Ts[-1],Ss[0],Ss[-1] ], vmin = 0, vmax = 1, cmap = cmap)
pl.title('$\\bar{x}$', fontsize = label_size)
pl.xlabel('T', fontsize = label_size)
pl.ylabel('S', fontsize = label_size)
pl.plot( [ Ts[0], Ts[-1] ],[ 0,0 ],color='black', linewidth = 2.5 )
pl.plot( [ 1, 1 ],[ Ss[0],Ss[-1] ],'--',color='black', linewidth = 2.5 )
pl.plot( [ 0, 3 ],[ 2, -1 ],'--',color='black', linewidth = 2.5 )
cb = pl.colorbar(shrink = .62, ticks = np.linspace( 0, 1, 6 ) )
cb.ax.tick_params(labelsize=legend_label_size)
##Fidle with the axis lables
pl.tick_params(axis='both', which='major', labelsize=tick_label_size)
pl.locator_params(axis = 'x', nbins=4)
##Turn grid lines off
pl.grid('off')
pl.subplot(122)
pl.imshow( np.mean( data_beta_bar, 2), origin = [Ts[0], Ss[0]], interpolation = 'nearest',\
extent = [ Ts[0],Ts[-1],Ss[0],Ss[-1] ], vmin = -1, vmax = 1, cmap = cmap_diverging )
pl.title('$\\bar{\\beta}$', fontsize = label_size)
pl.xlabel('T', fontsize = label_size)
#pl.ylabel('S', fontsize = label_size)
pl.plot( [ Ts[0], Ts[-1] ],[ 0,0 ],color='black', linewidth = 2.5 )
pl.plot( [ 1, 1 ],[ Ss[0],Ss[-1] ],'--',color='black', linewidth = 2.5 )
pl.plot( [ 0, 3 ],[ 2, -1 ],'--',color='black', linewidth = 2.5 )
cb = pl.colorbar(shrink = .62, ticks = np.linspace( -1, 1, 6 ))
cb.ax.tick_params(labelsize=legend_label_size)
##Fidle with the axis lables
pl.tick_params(axis='both', which='major', labelsize=tick_label_size)
pl.locator_params(axis = 'x', nbins=4)
##Turn grid lines off
pl.grid('off')
fig_file = os.path.join( graph_dir, "alpha_{:.2}.{}".format( alpha, file_format) )
if output:
print "saving figure at " + fig_file
pl.savefig( fig_file, bbox_inches='tight')
else:
return f
def p(prior):
ng = NG(**prior)
print("Mode of prior: %2.2f, %2.2fP / %2.2fS" %
(ng.mu, (ng.alpha - .5) / ng.beta, p2s((ng.alpha - .5) / ng.beta)))
M, P = meshgrid(linspace(-2, 2, 151), linspace(s2p(6.5), s2p(0.15), 1051))
clf()
subplot(2, 3, 1)
contourf(M, p2s(P), NG(**prior)(M, P), 51)
axhline(p2s((ng.alpha - .5) / ng.beta), color='k')
pyplot.locator_params(nbins=4)
ylabel('Sample STD')
xlabel('Sample Mean')
title('Prior believe')
subplot(2, 3, 2)
title(r'$log(P(\mu>0|Stimulus))$')
pH1 = PestH1Vec(ng)(M, P, 10)
contourf(M, p2s(P), pH1, 11)
contour(M, p2s(P), pH1, [.5], colors='k')
pyplot.locator_params(nbins=4)
xlabel('Sample Mean')
yticks([])
subplot(2, 3, 3)
title(r'$log \frac{P(\mu>0|Stimulus)}{P(\mu<0|Stimulus)}$')
dP = log(PestH1Vec(ng)(M, P, 10)) - log((1 - PestH1Vec(ng)(M, P, 10)))
CS = contourf(M, p2s(P), dP, 11)
contour(M, p2s(P), dP, [0.0], colors='k')
pyplot.locator_params(nbins=4)
xlabel('Sample Mean')
yticks([])
#axvline(0.075, color='k')
'''
subplot(2,3,4)
em, es = linspace(-5.5, 5.5, 51), linspace(0, 5.5, 151)
sm, ss, phit = foo([.1, .1, .1], prior, side=-1)
out = bar(sm, ss, phit, em, es)
print out.shape
print phit
contourf(centers(em), centers(es), out, linspace(0, 1, 11), cmap=winter())
contour(M, p2s(P), PestH1Vec(ng)(M,P, 10), [0.5], colors='k')
fa = []
for i, (yl, yh) in enumerate(zip(es[:-1], es[1:])):
idy = (yl<ss) & (ss<=yh)
fa.append(sum(phit[idy]>0.5)/float(sum(idy)))
subplot(2,3,5)
sm, ss, phit = foo([.1, .1, .1], prior, side=1)
out = bar(sm, ss, phit, em, es)
print phit
contourf(centers(em), centers(es), out, linspace(0, 1, 11), cmap=winter())
contour(M, p2s(P), PestH1Vec(ng)(M,P, 10), [0.5], colors='k')
subplot(2,3,6)
hit = []
for i, (yl, yh) in enumerate(zip(es[:-1], es[1:])):
idy = (yl<ss) & (ss<=yh)
hit.append(sum(phit[idy]>0.5)/float(sum(idy)))
plot(centers(es), hit, label='hits')
plot(centers(es), fa, label='fa')
legend()
#xlim([.75, 1.75])
xlabel('STD')
'''
return prior
def cell_morphs3d(cells_select_df, morphologies,fig,skip=100,color='k'):
ax = fig.gca(projection='3d')
col='k'
RotX = np.array([[1, 0, 0], # rotate around x axis
[0, 0, 1],
[0, 1, 0]])
ncells_select = len(cells_select_df.index)
rows_display = range(0,ncells_select,skip)
cells_display_df = cells_select_df.iloc[rows_display]
for gid,cell_prop in cells_display_df.iterrows():
x_soma = cell_prop['x_soma'] # needed to do those in sequence because Series did not inherite the dtype from DataFrame
y_soma = cell_prop['y_soma'] # need to look for a more elegant solution to this
z_soma = cell_prop['z_soma']
pos_soma = np.array([x_soma,y_soma,z_soma])
phi_y = cell_prop['rotation_angle_yaxis']
phi_z = cell_prop['rotation_angle_zaxis']
RotY = rotation_matrix([0,1,0],phi_y)
RotZ = rotation_matrix([0,0,1],-phi_z)
RotYZ = RotY.dot(RotZ) # apply two rotations
model_id = cell_prop['model_id']
morph_segs_start = morphologies[model_id]["segs_start"]
morph_segs_end = morphologies[model_id]["segs_end"]
segs_start = pos_soma + np.dot(morph_segs_start,RotYZ.T) # use the tranposed matrix since we multiply on the right
segs_end = pos_soma + np.dot(morph_segs_end,RotYZ.T)
pos_soma = np.dot(pos_soma,RotX.T)*1E-3
segs_start = np.dot(segs_start,RotX.T)*1E-3
segs_end = np.dot(segs_end,RotX.T)*1E-3 # for display purposes switch z and y, convert to mm:
col_segs = build_collection3d(segs_start,segs_end)
ax.add_collection(col_segs) # plot segments
ax.scatter(pos_soma[0], pos_soma[1], pos_soma[2],color='red',alpha=0.4) # plot somata
set_axes_equal(ax)
ax.set_aspect('equal')
ax.set_xlim([-0.8,0.8])
ax.set_zlim([-1.2,0.2])
ax.set_ylim([-0.8,0.8])
# ax.autoscale_view(True,True,True)
plt.locator_params(nbins=4)
ax.set_xlabel('lat')
ax.set_ylabel('lat')
ax.set_zlabel('depth')
def main(experiment):
swapped = False
use_geodesic = True
experiments = dict(
cat=dict(
file1='meshes/tosca/cat0.mat',
file2='meshes/tosca/cat2.mat',
mu=[0.7],
Ks=np.arange(10, 50, 5),
),
david=dict(
file1='meshes/tosca_holes/david0_halfed.obj',
file2='meshes/tosca_holes/david10_nolegs_nohead.obj',
mu=[0.7],
Ks=np.arange(10, 50, 5),
),
hand=dict(
file1='meshes/hand_868.obj',
file2='meshes/hand_868_holes2.obj',
mu=[5.0],
Ks=np.arange(10, 50, 2),
),
)
if experiment not in experiments:
print "Usage: python %s <experiment>" % sys.argv[0]
print "where experiment is one of: %s" % (', '.join(
experiments.keys()))
sys.exit(1)
exp = experiments[experiment]
file1, file2 = exp['file1'], exp['file2']
mu, Ks = exp['mu'], exp['Ks']
print "this will take a while..."
# load meshes
verts1, tris1, verts2, tris2, ij = load_shape_pair(file1,
file2,
check=False,
normalize=False)
if swapped: # swapped?
verts2, tris2, verts1, tris1 = verts1, tris1, verts2, tris2
ij = ij[:, ::-1]
if use_geodesic:
D = compute_geodesic_distance_matrix(verts1, tris1)
eigenvector_algorithms = [
('MHB', partial(cmm.manifold_harmonics, scaled=False)),
]
for cmu in mu:
name = 'CMHB' if len(mu) == 1 else 'CMHB %f' % (cmu)
eigenvector_algorithms.append((name,
partial(cmm.compressed_manifold_modes,
mu=cmu,
maxiter=10000,
verbose=0,
scaled=False)))
mapping_algorithms = [
('rotation', partial(align.optimal_rotation, allow_reflection=True)),
#('permutation', partial(align.optimal_permutation, allow_reflection=True)),
]
print "computing basis functions (first mesh)"
runs = [(K, name, algo) for K in Ks
for name, algo in eigenvector_algorithms]
Phis1 = Parallel(-1)(delayed(algo)(verts1, tris1, K)
for K, name, algo in runs)
print "computing basis functions (second mesh)"
Phis2 = Parallel(-1)(delayed(algo)(verts2, tris2, K)
for K, name, algo in runs)
# run for different number of eigenfunctions K
errors_per_mapping_algorithm = defaultdict(lambda: defaultdict(list))
C_by_mapping_algorithm = defaultdict(lambda: defaultdict(list))
for (K, eigenvector_algorithm_name,
algo), Phi1, Phi2 in zip(runs, Phis1, Phis2):
for mapping_algorithm_name, mapping_algorithm in mapping_algorithms:
# compute the mapping between the eigenfunctions
C = mapping_algorithm(Phi1[ij[:, 0]].T, Phi2[ij[:, 1]].T)
Phi1_rot = np.dot(C, Phi1.T).T
# for all points in shape 2 where there is a correspondence to shape 1 (all j),
# find corresponding point i in shape 1
tree = cKDTree(Phi1_rot)
distance_eigenspace, nearest = tree.query(Phi2[ij[:, 1]])
ij_corr = np.column_stack((ij[:, 0], nearest))
# compute error
if use_geodesic:
errors = D[ij_corr[:, 0], ij_corr[:, 1]]
else:
errors = veclen(verts1[ij_corr[:, 0]] - verts1[ij_corr[:, 1]])
mean_error = np.mean(errors)
errors_per_mapping_algorithm[mapping_algorithm_name][
eigenvector_algorithm_name].append(mean_error)
C_by_mapping_algorithm[mapping_algorithm_name][
eigenvector_algorithm_name].append(C)
print "%s/%s (K=%d) %.2f" % (mapping_algorithm_name,
eigenvector_algorithm_name, K,
mean_error)
for mapping_algorithm_name, C_by_trial in C_by_mapping_algorithm.iteritems(
):
for trial_name, Cs in C_by_trial.iteritems():
# just use the last rotation matrix computed
C = Cs[-2]
pl.figure(mapping_algorithm_name + '_' + trial_name,
figsize=(4, 3.5))
plot_functional_map(reorder_functional_map(C), newfig=False)
pl.subplots_adjust(left=0.01, right=1, top=0.95, bottom=0.05)
show_correspondence(
verts1,
tris1,
verts2,
tris2,
ij,
points=5,
color_only_correspondences=True,
colormap='Paired', #offset_factor=(-1.8, +0.0, 0.),
show_spheres=False,
blend_factor=1.0,
block=False)
for mapping_algorithm_name, errors_per_trial in errors_per_mapping_algorithm.iteritems(
):
#pl.rcParams.update({'font.size': 6})
pl.figure(mapping_algorithm_name + '_' + file1 + '_' + file2,
figsize=(2.5, 2.5))
pl.rc('text', usetex=False)
style_by_name = dict(CMHB=dict(c=(6 / 255., 50 / 255., 100 / 255.),
lw=2),
MHB=dict(c=(121 / 255., 6 / 255., 34 / 255.),
lw=1))
for trial_name, errors in sorted(errors_per_trial.items(),
key=lambda (k, v): k):
print trial_name, errors
style = style_by_name.get(trial_name, {})
pl.plot(Ks, errors, label=trial_name, **style)
pl.locator_params(nbins=4)
pl.legend().draggable()
pl.autoscale(tight=True)
pl.ylim(bottom=0)
pl.grid()
pl.xlabel(r'$K$')
pl.ylabel(r'geodesic error')
pl.tight_layout()
pl.show()
def plot_star(star, predict, y_names, out_dir=plot_dir, nbins=10):
## Regular histograms
middles = np.mean(predict, 0)
stds = np.std(predict, 0)
#outstr = star
num_ys = predict.shape[1]
rows, cols, sqrt = get_rc(num_ys)
plt.figure(figsize=(6.97522 * 2, 4.17309 * 2),
dpi=400,
facecolor='w',
edgecolor='k')
for (pred_j, name) in enumerate(y_names[0:num_ys]):
(m, s) = (middles[pred_j], stds[pred_j])
if num_ys % 2 == 0 or num_ys % 3 == 0 or int(sqrt) == sqrt:
ax = plt.subplot(rows, cols, pred_j + 1)
elif pred_j % 2 == 0 and pred_j == num_ys - 1:
ax = plt.subplot2grid((rows, cols), (pred_j // 2, 1), colspan=2)
else:
ax = plt.subplot2grid((rows, cols),
(pred_j // 2, (pred_j % 2) * 2),
colspan=2)
n, bins, patches = ax.hist(predict[:, pred_j], nbins, density=1) #,
#histtype='stepfilled', color='white')
if star == 'Sun' or star == 'Tagesstern' or star == '5774694':
if name is 'age':
plot_line(4.572, n, bins, plt, 'r--')
if name is 'M':
plot_line(1, n, bins, plt, 'r--')
#if y_central is not None:
# mean = np.mean(y_central[:,pred_j])
# std = np.std(y_central[:,pred_j])
#
# plot_line(mean, n, bins, plt, 'r--')
# plot_line(mean+std, n, bins, plt, 'r-.')
# plot_line(mean-std, n, bins, plt, 'r-.')
q_16, q_50, q_84 = corner.quantile(predict[:, pred_j],
[0.16, 0.5, 0.84])
q_m, q_p = q_50 - q_16, q_84 - q_50
plot_line(q_50, n, bins, plt, 'k--')
plot_line(q_16, n, bins, plt, 'k-.')
plot_line(q_84, n, bins, plt, 'k-.')
# Format the quantile display.
fmt = "{{0:{0}}}".format(".3g").format
title = r"${{{0}}}_{{-{1}}}^{{+{2}}}$"
title = title.format(fmt(q_50), fmt(q_m), fmt(q_p))
ax.annotate(r"$\epsilon = %.3g\%%$" % (s / m * 100),
xy=(0.99, 0.12),
xycoords='axes fraction',
horizontalalignment='right',
verticalalignment='right')
P.xlabel(y_latex[y_names[pred_j]] + " = " + title)
P.locator_params(axis='x', nbins=3)
xs = [m - 4 * s, m + 4 * s] #[max(0, m-4*s), m+4*s]
xticks = [m - 3 * s, m, m + 3 * s] #[max(0, m-3*s), m, m+3*s]
ax.set_xticks(xticks)
ax.set_xlim(xs)
ax.set_xticklabels(['%.3g' % xtick for xtick in xticks])
ax.set_yticklabels('', visible=False)
ax.set_frame_on(False)
ax.get_xaxis().tick_bottom()
ax.axes.get_yaxis().set_visible(False)
#xmin, xmax = ax1.get_xaxis().get_view_interval()
ymin, ymax = ax.get_yaxis().get_view_interval()
ax.add_artist(
mpl.lines.Line2D(xs, (ymin, ymin), color='black', linewidth=2))
#ax.minorticks_on()
plt.tight_layout()
plt.savefig(os.path.join(out_dir, star + '.pdf'), dpi=400)
plt.close()
data_lines = f.readlines()[3:]
data = np.loadtxt(data_lines)
# plot numerical and exact solution in first subplot
# plot error in second subplot
plt.figure(1, figsize=(7.0,3.0))
plt.subplot(1,2,1)
plot1 = plt.plot(data[:,3], data[:,1], 'ro')
plot2 = plt.plot(data[:,4], data[:,1], '-b+', linewidth=2)
plt.xlabel('x-velocity (m/s)',labelpad=20)
plt.ylabel('y (m)')
plt.xlim(0.0, 20.0)
plt.ylim(0.0, 0.01)
plt.legend([plot1, plot2], ('MFIX','Exact'), 'best')
plt.title('(a)',x=0.5,y=-0.4)
plt.subplot(1,2,2)
plot3 = plt.plot(data[:,5], data[:,1], '-b+')
plt.xlabel('Error (m/s)',labelpad=20)
plt.ylabel('y (m)')
plt.locator_params(axis='x',nbins=5)
plt.title('(b)',x=0.5,y=-0.4)
plt.subplots_adjust(wspace=0.5)
plt.savefig('tfm01_01.png', bbox_inches='tight')
plt.close(1)
# Say we want detect extrema using parabolic method
emd = eemd.EMD
emd.extrema_detection = "parabol"
# Execute EEMD on S
eIMFs = eemd.eemd(S)
return eIMFs
if __name__ == "__main__":
# Define signal
data = cwru_input.read_matdata('../data/12k_Drive_End_B007_0_118.mat')
print(data.shape)
S = data[0:400]
t = np.linspace(0, 1, 400)
eIMFs = eemd(S)
nIMFs = eIMFs.shape[0]
# Plot results
plt.figure(figsize=(12, 9))
plt.subplot(nIMFs + 1, 1, 1)
plt.plot(t, S, 'r')
for n in range(nIMFs):
plt.subplot(nIMFs + 1, 1, n + 2)
plt.plot(t, eIMFs[n], 'g')
plt.ylabel("eIMF %i" % (n + 1))
plt.locator_params(axis='y', nbins=5)
plt.xlabel("Time [s]")
plt.tight_layout()
plt.savefig('105', dpi=120)
plt.show()
def export_ts(ts, user_id, num_bins, toplot = False, saveplot = True, iresolution = None):
if iresolution != None:
fname = 'timeseries/byday-{0}s-{1}.dat'.format(iresolution, user_id)
else:
fname = 'timeseries/byday-1s-{0}.dat'.format(user_id)
ofile = open(fname, 'w')
if toplot == True or saveplot == True:
f, axarr = pylab.subplots(len(ts), sharex = True)
if iresolution != None:
num_bins_coarse = num_bins / iresolution # Account for the fact that we plan to coarsen the timeseries
for axind, day in enumerate(ts):
if len(axarr) == 1:
ax = axarr
else:
ax = axarr[axind]
if day[0] == None: # We've hit on a day that didn't have any Twitter activity
binarized = numpy.zeros(num_bins)
else: # The day has legitimate tweets
binarized = binarize_timeseries(day, num_bins)
if iresolution != None:
binarized = coarse_resolution(binarized, iresolution = iresolution)
if day[0] != None: # We only need to plot the raster if there are points to plot
if toplot == True or saveplot == True:
plot_raster(binarized, num_bins_coarse, axarr, axind)
else: # We still need to fix how the axes look, even when we don't plot
if toplot == True or saveplot == True:
ax.yaxis.set_visible(False)
else:
if day[0] != None:
if toplot == True or saveplot == True:
plot_raster(binarized, num_bins, axarr, axind)
else: # We still need to fix how the axes look, even when we don't plot
if toplot == True or saveplot == True:
ax.yaxis.set_visible(False)
for symbol in binarized:
ofile.write("{0}".format(int(symbol)))
ofile.write("\n")
if toplot == True or saveplot == True:
if iresolution == None:
pylab.xlabel('Time (each time tick corresponds to 1 s)')
else:
pylab.xlabel('Time (each time tick corresponds to {} s)'.format(iresolution))
pylab.locator_params(axis = 'x', nbins = 5)
if saveplot == True:
if iresolution == None:
pylab.savefig('raster-1s-{0}.pdf'.format(user_id))
else:
pylab.savefig('raster-{0}s-{1}.pdf'.format(iresolution, user_id))
pylab.close(f)
if toplot == True:
pylab.show()
ofile.close()
def PlotSuperposition(fit_results,
composite_sample,
pure_samples,
k_min=None,
k_max=None,
interactive_plot=False,
output_folder=None):
d_vec = fit_results["d_vec"]
if not interactive_plot:
plt.ioff()
plt.close()
axis_font, legend_font = GetFontsAndSetMPLproperties()
fig = plt.figure(figsize=(12 / 2.54, 8 / 2.54))
ax0 = fig.add_subplot(111)
plt.locator_params(nbins=6)
ax0.plot(composite_sample.wavenumber,
composite_sample.absorbance,
linewidth=2,
label='data',
color='r')
fill_colors = ['b', 'g', 'm', 'r', 'c', 'm', 'k']
hatches = ['/' * 3, '\\' * 3, '-' * 3, '*' * 3, 'o' * 3, 'O' * 3, '.' * 3]
composite_sample_baseline_cut_fit = composite_sample.baseline[
np.logical_and(composite_sample.wavenumber_cut > k_min,
composite_sample.wavenumber_cut < k_max)]
for k, s in enumerate(pure_samples):
ax0.fill_between(s.wavenumber_cut_fit,
composite_sample_baseline_cut_fit,
d_vec[k] * s.absorbance_corr_cut_fit +
composite_sample_baseline_cut_fit,
label='fit {}'.format(s.name),
alpha=0.5,
linewidth=0,
color=fill_colors[k],
hatch=hatches[k])
absorbance_fit = np.dot(
d_vec, np.vstack([s.absorbance_corr_cut_fit for s in pure_samples
])) + composite_sample_baseline_cut_fit
ax0.plot(composite_sample.wavenumber_cut_fit,
absorbance_fit,
'k--',
dashes=(3, 3),
label='fit',
linewidth=2)
ax0.plot(composite_sample.wavenumber_cut,
composite_sample.baseline,
linewidth=1.5,
color='k',
label='baseline')
ax0.set_xlabel('wavenumber / cm$^{-1}$')
ax0.set_ylabel('absorbance')
min_, max_ = np.min(absorbance_fit), np.max(absorbance_fit)
ax0.set_ylim([min_ - (max_ - min_) / 10, max_ + (max_ - min_) / 10])
if k_min != None:
ax0.set_xlim([k_min, ax0.get_xlim()[1]])
if k_max != None:
ax0.set_xlim([ax0.get_xlim()[0], k_max])
legend = ax0.legend(loc='best', prop=legend_font, handlelength=3)
legend.set_draggable(True)
ax0.invert_xaxis()
if output_folder != None:
if not os.path.exists(output_folder):
os.makedirs(output_folder)
plt.savefig(
os.path.join(output_folder,
'FTIR_' + composite_sample.name + '.png'))
if interactive_plot:
plt.show()
def main():
# prepare data
verts, tris = load_mesh('meshes/bumpy_cube6.obj')
K = 8 + 6 + 12
mu = 20.0
maxiter = 500
num_experiments = 1
# prepare data structures
ResultData = namedtuple('ResultData', 'Phi info logger')
data_per_algo = defaultdict(list)
# parameters passed to algorithms - to be fair,
# turn off automatic penalty adjustment in our method
# set check_interval = 1 to force callback to be called in every iteration
algorithms = [
('osher', cmm.solve_compressed_osher,
dict()),
('ours', cmm.solve_compressed_splitorth,
dict(auto_adjust_penalty=False, check_interval=1)),
]
# run the algorithm with same input mesh and
# different random initializations
print "will now run the method with %d different initializations" % num_experiments
print "the primal residual with our method should consistently be lower compared to Oshers et al."
for random_seed in range(num_experiments):
np.random.seed(random_seed)
Phi_init = np.random.random((len(verts), K))
print "--"
print "running experiment %d" % random_seed
for name, method, options in algorithms:
Phi, info, logger = test_convergence(
verts, tris, K, mu,
Phi_init, method, maxiter, **options)
print name, info['r_primal']
data_per_algo[name].append(ResultData(Phi, info, logger))
# visualize results
import matplotlib
if len(sys.argv) > 1:
matplotlib.use('pgf') # TODO PGF
else:
matplotlib.use('WxAgg')
import pylab as pl
pl.rc('text', usetex=True)
pl.rc('font', size=6)
pl.figure(figsize=(0.9, 1.1))
plot_fun = pl.semilogy
plot_fun(data_per_algo['osher'][0].logger.r_primals, c='r',
label=r'osher')
plot_fun(data_per_algo['ours'][0].logger.r_primals, c='g',
label=r'ours')
pl.legend(loc='center right').draggable()
pl.locator_params(nbins=4, axis='x')
pl.xlabel('iteration')
pl.ylabel(r'$ \left\Vert r \right\Vert_2$')
pl.gca().yaxis.set_major_locator(matplotlib.ticker.LogLocator(numticks=4))
if len(sys.argv) > 2:
pl.savefig(sys.argv[1]) #, bbox_inches='tight')
else:
pl.ion()
pl.show()
# let us first visualize the modes where things go wrong
# which are most probably those where the primal residual is very high
Q = data_per_algo['osher'][0].info['Q']
P = data_per_algo['osher'][0].info['P']
worst_first = ((Q - P)**2).sum(axis=0).argsort()[::-1]
show_weights(
verts, tris,
(data_per_algo['osher'][0].Phi[:, worst_first],
data_per_algo['ours'][0].Phi[:, worst_first]),
('osher', 'ours')
)
