def cumulative_distribution(
data,
scaled=False,
survival=False,
label="Cumulative",
fill=False,
target_length=np.inf,
downsample_method="geom",
flip=False,
preserve_ends=0,
**kwargs
):
"""
plots cumulative (or survival) step distribution
"""
data = np.sort(data)
if survival:
data = data[::-1]
y = np.arange(data.size + 1, dtype=float)
if scaled:
y /= y[-1]
x = np.concatenate([data, data[[-1]]])
if len(x) > target_length:
if downsample_method == "geom":
x, y = log_downsample(x, y, target_length=target_length, flip=flip)
elif downsample_method == "even_end":
x, y = downsample(
x, y, target_length=target_length, preserve_ends=preserve_ends
)
else:
raise Exception("invalid downsample_method")
plt.step(x, y, label=label, **kwargs)
if fill:
plt.fill_between(x, y, alpha=0.5, step="pre", **kwargs)
def _print_summary(self):
#self.fig.clf()
try:
from IPython.display import clear_output
clear_output(True)
finally:
pass
pylab.figure(figsize=(20, 20))
for i, key in enumerate(sorted(self.history.keys())):
pylab.subplot((len(self.history) % self.col) + 1, self.col, i + 1)
x = numpy.array([i[0] for i in self.history[key]])
mean = numpy.array([i[1] for i in self.history[key]])
std = numpy.array([i[2] for i in self.history[key]])
max = numpy.array([i[3] for i in self.history[key]])
min = numpy.array([i[4] for i in self.history[key]])
pylab.fill_between(x, min, max, facecolor='r', alpha=0.1)
pylab.fill_between(x,
mean - std,
mean + std,
facecolor='b',
alpha=0.2)
pylab.plot(x, mean, label="mean")
pylab.title(key)
pylab.legend()
pylab.show()
def confidence_intervals(X,
Y,
c,
label="",
mid_50_percentile=False,
lw=2,
ls="-"):
X, Y = np.array(X), np.array(Y)
low, upp = st.t.interval(0.99,
Y.shape[0] - 1,
loc=np.mean(Y, axis=0),
scale=st.sem(Y))
plt.fill_between(np.mean(X, axis=0), low, upp, alpha=0.5, color=c, lw=0)
plt.plot(np.mean(X, axis=0),
np.mean(Y, axis=0),
lw=lw,
ls=ls,
c=c,
label=label)
if mid_50_percentile:
plt.fill_between(np.mean(X, axis=0),
np.percentile(Y, 25, axis=0),
np.percentile(Y, 75, axis=0),
alpha=.25,
color=c)
def plot_precision_recall_curve(y_true, y_pred_scores, nclasses, pos_label=1):
"""
:param y_true:
:param y_pred_scores:
:param pos_label:
:return:
"""
for cls_index, cls in enumerate(nclasses):
average_precision = average_precision_score(
y_true[:, cls_index], y_pred_scores[:, cls_index])
precision, recall, _ = precision_recall_curve(y_true[:, cls_index],
y_pred_scores[:,
cls_index],
pos_label=pos_label)
plt.step(recall, precision, color='b', alpha=0.2, where='post')
plt.fill_between(recall, precision, step='post', alpha=0.2, color='b')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title('Precision-Recall curve for class "{0}": AP={1:0.2f}'.format(
cls.capitalize(), average_precision))
def plot_learning_curve(estimator, title, X, y, cv=5, train_sizes=np.linspace(0.1, 1, 20)):
plt.figure(figsize=(8, 8))
plt.title(title,fontsize=14)
plt.xlabel("Number of training samples",fontsize=14)
plt.ylabel("Accuracy score",fontsize=14)
#设置坐标轴刻度
plt.yticks(np.linspace(0, 1, 20))
train_sizes, train_scores, test_scores= learning_curve(estimator, X, y, cv=cv,train_sizes=train_sizes)
print(train_sizes)
plt.xticks(train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
# Plot learning curve
plt.grid(True)
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,train_scores_mean + train_scores_std, alpha=0.1,color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,test_scores_mean + test_scores_std, alpha=0.1,color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color="r",label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",label="Cross-validation score")
plt.legend(loc="best",fontsize=14)
# plt.savefig('./validation_curve.png', dpi=300)
return plt
def learn_curve_plot(estimator,title,X,y,cv=None,train_sizes=np.linspace(0.1,1.0,5)):
'''
:param estimator: the model/algorithem you choose
:param title: plot title
:param x: train data numpy array style
:param y: target data vector
:param xlim: axes x lim
:param ylim: axes y lim
:param cv:
:return: the figure
'''
plt.figure()
train_sizes,train_scores,test_scores=\
learning_curve(estimator,X,y,cv=cv,train_sizes=train_sizes)
'''this is the key score function'''
train_scores_mean=np.mean(train_scores,axis=1)
train_scores_std=np.std(train_scores,axis=1)
test_scores_mean=np.mean(test_scores,axis=1)
test_scores_std=np.std(test_scores,axis=1)
plt.fill_between(train_sizes,train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std,alpha=0.1,color='b')
plt.fill_between(train_sizes,test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std,alpha=0.1,color='g')
plt.plot(train_sizes,train_scores_mean,'o-',color='b',label='training score')
plt.plot(train_sizes,test_scores_mean,'o-',color='g',label='cross valid score')
plt.xlabel('training examples')
plt.ylabel('score')
plt.legend(loc='best')
plt.grid('on')
plt.title(title)
plt.show()
def plot_pyro(model, ideal, sd_val=1):
#plot_observed_data=False, plot_predictions=False, n_prior_samples=0,
x_test = ideal[0]
p_test = ideal[1]
plt.figure(figsize=(12, 6))
plt.plot(model.X.numpy(), model.y.numpy(), 'kx')
Xtest = torch.Tensor(x_test) # test inputs
with torch.no_grad():
if type(model) in (pyro.contrib.gp.models.VariationalSparseGP,
pyro.contrib.gp.models.VariationalGP):
mean, cov = model(Xtest, full_cov=True)
else:
mean, cov = model(Xtest, full_cov=True, noiseless=False)
sd = cov.diag().sqrt() # standard deviation at each input point x
mean_p = model.likelihood.response_function(mean)
inf, sup = mean - sd_val * sd, mean + sd_val * sd
inf_p = model.likelihood.response_function(inf)
sup_p = model.likelihood.response_function(sup)
plt.plot(Xtest.numpy(), mean_p.numpy(), 'b', lw=2) # plot the mean
plt.plot(Xtest.numpy(), p_test, 'r--', lw=2) # plot real landscape
plt.fill_between(
Xtest.numpy().reshape(
-1), # plot the two-sigma uncertainty about the mean
inf_p.numpy().reshape(-1),
sup_p.numpy().reshape(-1),
color='C0',
alpha=0.3)
def printAccCurve(regType='OLS'):
for time in times:
curveData = np.array(
list(
csv.reader(
open(
'./5-accCurveNoSameTake-' + time + '_' + regType +
'.csv', 'r')))).astype(float)
CIi = []
CIa = []
for l in curveData:
CIi.append(l[0] - (1.96 * (l[1] / math.sqrt(l[5]))))
CIa.append(l[0] + (1.96 * (l[1] / math.sqrt(l[5]))))
#plt.axhline(1.2)
# Set up dashed lines
for y in np.arange(0.1, 1.11, 0.1):
plt.axhline(y, color='k', ls='--', alpha=0.25)
Xs = range(5, 121, 5)
plt.plot(Xs, curveData[:, 4], label='Maximum')
plt.plot(Xs, curveData[:, 2], label='Median')
plt.plot(Xs, curveData[:, 0], label='Mean')
plt.plot(Xs, CIi, 'k', alpha=0.2, label='95% Confidence Interval')
plt.plot(Xs, CIa, 'k', alpha=0.2)
plt.fill_between(Xs, CIi, CIa, facecolor='k', alpha=0.1)
plt.plot(Xs, curveData[:, 3], label='Minimum')
plt.title('Accuracy Curves for ' + time + ',' + regType)
plt.legend(loc='best')
plt.xlabel('Time Points')
plt.ylabel('Accuracy')
plt.show()
def plot_fit_function(self, num_points=100):
'''
try:
x_coords = np.linspace(self.x_vec[0], self.x_vec[-1], num_points)
except Exception as message:
print 'no x axis information specified', message
return
'''
if self.landscape:
for trace in self.landscape:
try:
#plt.clear()
plt.plot(self.x_vec, trace)
plt.fill_between(self.x_vec,
trace + float(self.span) / 2,
trace - float(self.span) / 2,
alpha=0.5)
except Exception:
print 'invalid trace...skip'
plt.axhspan(self.y_vec[0],
self.y_vec[-1],
facecolor='0.5',
alpha=0.5)
plt.show()
else:
print 'No trace generated.'
def visualise_posterior(model, X_test, Y_test, Y_test_pred, mixture=True, title=None, new_fig=False):
''' Visualising posterior predictive (a single distribution) '''
if new_fig:
plt.figure(figsize=(5,5))
#f, ax = plt.subplots(1, 1, figsize=(8, 8))
if mixture:
sample_means, sample_stds = get_posterior_predictive_means_stds(Y_test_pred)
sample_stds = torch.nan_to_num(sample_stds, nan=1e-5)
lower, upper = get_posterior_predictive_uncertainty_intervals(sample_means, sample_stds)
pred_mean = sample_means.mean(dim=0)
else:
lower, upper = Y_test_pred.confidence_region()
lower=lower.detach().numpy()
upper=upper.detach().numpy()
pred_mean = Y_test_pred.mean.numpy()
plt.plot(X_test.numpy(), pred_mean, 'b-', label='Mean')
plt.scatter(model.covar_module.inducing_points.detach(), [-2.5]*model.num_inducing, c='r', marker='x', label='Inducing')
plt.fill_between(X_test.detach().numpy(), lower, upper, alpha=0.5, label=r'$\pm$2\sigma', color='g')
plt.scatter(model.train_x.numpy(), model.train_y.numpy(), c='k', marker='x', alpha=0.7, label='Train')
plt.plot(X_test, Y_test, color='b', linestyle='dashed', alpha=0.7, labeL='True')
#ax.set_ylim([-3, 3])
plt.legend(fontsize='small')
plt.title(title)
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)):
plt.figure()
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel("Training examples")
plt.ylabel("Score")
train_sizes, train_scores, test_scores = learning_curve(
estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.grid()
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1, color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
label="Cross-validation score")
plt.legend(loc="best")
plt.show()
return train_sizes, train_scores_mean, test_scores_mean
def transition_related_averaging_run(self, simulation_data, smoothing_kernel_width = 200, sampling_interval = [-50, 150], plot = True ): """docstring for transition_related_averaging""" transition_occurrence_times = self.transition_occurrence_times(simulation_data = simulation_data, smoothing_kernel_width = smoothing_kernel_width) # make sure only valid transition_occurrence_times survive transition_occurrence_times = transition_occurrence_times[(transition_occurrence_times > -sampling_interval[0]) * (transition_occurrence_times < (simulation_data.shape[0] - sampling_interval[1]))] # separated into on-and off periods: transition_occurrence_times_separated = [transition_occurrence_times[::2], transition_occurrence_times[1::2]] mean_time_course, std_time_course = np.zeros((2, sampling_interval[1] - sampling_interval[0], 5)), np.zeros((2, sampling_interval[1] - sampling_interval[0], 5)) if transition_occurrence_times_separated[0].shape[0] > 2: for k in [0,1]: averaging_interval_times = np.array([transition_occurrence_times_separated[k] + sampling_interval[0],transition_occurrence_times_separated[k] + sampling_interval[1]]).T interval_data = np.array([simulation_data[avit[0]:avit[1]] for avit in averaging_interval_times]) mean_time_course[k] = interval_data.mean(axis = 0) std_time_course[k] = (interval_data.std(axis = 0) / np.sqrt(interval_data.shape[0])) if plot: f = pl.figure(figsize = (10,8)) for i in range(simulation_data.shape[1]): s = f.add_subplot(simulation_data.shape[1], 1, 1 + i) for j in [0,1]: pl.plot(np.arange(mean_time_course[j].T[i].shape[0]), mean_time_course[j].T[i], ['r--','b--'][j], linewidth = 2.0 ) pl.fill_between(np.arange(mean_time_course[j].shape[0]), mean_time_course[j].T[i] + std_time_course[j].T[i], mean_time_course[j].T[i] - std_time_course[j].T[i], ['r','b'][j], alpha = 0.2) s.set_title(self.variable_names[i]) pl.draw() return (mean_time_course, std_time_course)
def _print_summary(self):
# self.fig.clf()
try:
from IPython.display import clear_output
clear_output(True)
finally:
pass
pylab.figure(figsize=(20, 20))
x = numpy.array([i[0] for i in self.history])
mean = numpy.array([i[1] for i in self.history])
std = numpy.array([i[2] for i in self.history])
max = numpy.array([i[3] for i in self.history])
min = numpy.array([i[4] for i in self.history])
pylab.fill_between(x, min, max, facecolor='r', alpha=0.1)
pylab.fill_between(x, mean - std, mean + std, facecolor='b', alpha=0.2)
pylab.plot(
x,
mean,
"+-",
label="mean",
)
pylab.legend()
pylab.show()
print(f"mean:{mean[-1]}, std:{std[-1]}, max:{max[-1]}, min:{min[-1]}")
def plot_beta_dist( ctr, trials, success, alphas, betas, turns ):
"""
Pass in the ctr, trials and success, alphas, betas returned
by the `experiment` function and the number of turns
and plot the beta distribution for all the arms in that turn
"""
subplot_num = len(turns) / 2
x = np.linspace( 0.001, .999, 200 )
fig = plt.figure( figsize = ( 14, 7 ) )
for idx, turn in enumerate(turns):
plt.subplot( subplot_num, 2, idx + 1 )
for i in range( len(ctr) ):
y = beta( alphas[i] + success[ turn, i ],
betas[i] + trials[ turn, i ] - success[ turn, i ] ).pdf(x)
line = plt.plot( x, y, lw = 2, label = "arm {}".format( i + 1 ) )
color = line[0].get_color()
plt.fill_between( x, 0, y, alpha = 0.2, color = color )
plt.axvline( x = ctr[i], color = color, linestyle = "--", lw = 2 )
plt.title("Posteriors After {} turns".format(turn) )
plt.legend( loc = "upper right" )
return fig
def estimateErrorBlocking(valuesIn,minBlocks=10,makePlot=False):
if len(valuesIn)<minBlocks:
raise NotEnoughData()
values=valuesIn
errors=[]
Ms=[]
i=len(values)
while i>=minBlocks:
values=block(values,i)
errors.append(np.sqrt(np.mean(values**2)-np.mean(values)**2)/sqrt(i))
i=i/2
errors=np.array(errors)
Ms=2**np.linspace(0,len(errors),num=len(errors))
index2=1./np.sqrt(Ms)
params,covs=optimize.curve_fit(lambda x,a,b: a*x + b,index2,errors)
res=stats.linregress(index2,errors)
errorsFit=[np.sqrt(covs[0][0]),np.sqrt(covs[1][1])]
if makePlot:
x=np.linspace(np.min(Ms),np.max(Ms),num=1000)
plt.plot(Ms,errors,"o")
plt.plot(x,params[1] + params[0]/np.sqrt(x))
y1=params[1]-errorsFit[1] + (params[0]-errorsFit[0])/np.sqrt(x)
y2=params[1]+errorsFit[1] + (params[0]+errorsFit[0])/np.sqrt(x)
plt.fill_between(x, y1, y2, where=y2 >= y1, interpolate=True,alpha=0.2)
plt.plot(x,params[1]+0*x ,"--")
return [params[1],errorsFit[1],abs(params[0]/(params[1]*sqrt(np.max(Ms))))]
def plot_micro_prec_recall(precision, recall, average_precision):
"""
Created an average precision plot, micro-averaged over all classes
:param precision: dict.
:param recall: dict.
:param average_precision: dict.
:return: plot
"""
sns.set()
sns.set_style("dark")
plt.figure()
plt.step(recall['micro'],
precision['micro'],
color='b',
alpha=0.2,
where='post')
plt.fill_between(recall["micro"],
precision["micro"],
step='post',
alpha=0.2,
color='b')
plt.xlabel('Recall', fontsize=18)
plt.ylabel('Precision', fontsize=18)
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title(
'Average precision score, micro-averaged over all classes: AP={0:0.2f}'
.format(average_precision["micro"]),
fontsize=24)
plt.show()
def ocean():
dmax = 1650.e3
dp = np.linspace(0., dmax, 3301)
zp = maketopo.shelf1(dp)
plt.clf()
plt.plot(dp*1e-3,zp,'k-',linewidth=3)
plt.fill_between(dp*1e-3,zp,0.,where=(zp<0.), color=[0,0.5,1])
plt.xlim([0.,1650])
plt.ylim([-4500.,500])
plt.title("Topography as function of radius",fontsize=18)
plt.xlabel("kilometers from center",fontsize=15)
plt.ylabel("meters",fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.savefig('topo1.png')
#plt.savefig('topo1.tif')
print "Cross-section plot in topo1.png"
plt.xlim([1500,1650])
plt.ylim([-200.,20])
plt.title("Topography of shelf and beach",fontsize=18)
plt.xlabel("kilometers from center",fontsize=15)
plt.ylabel("meters",fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.savefig('topo2.png')
#plt.savefig('topo2.tif')
print "Zoom near shore in topo2.png"
def showMeanSTDMetric(metric_name, m_table, title, output_fn = None):
pl.figure()
ax = pl.subplot(111)
#pl.set_context("talk", font_scale=1, rc={"lines.linewidth": 0.2})
siz = table.shape[0]
# ax=pl.errorbar(range(siz),m_table[metric_name],yerr=m_table[metric_name], fmt='o')
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
pl.fill_between(range(siz), m_table[metric_name+'_mean'] - m_table[metric_name+'_std'],
m_table[metric_name+'_mean'] + m_table[metric_name+'_std'], color="#3F5D7D",alpha=0.8, lw=0.001)
pl.plot(range(siz), m_table[metric_name+'_mean'], color="r", lw=2)
labels = range(1,siz,30)
#g = sns.FacetGrid(m_table)
#g.map(pl.errorbar, "csv_path", metric_name, yerr= m_table[metric_name+'_std'] , marker="o")
pl.xticks(labels,labels,fontsize=9)
pl.title(title)
pl.xlabel('Image ID 1 ~ ' + str(siz))
if ( output_fn is None):
output_fn = data_DIR+'/'+metric_name+title+'.mean_std.pdf'
pl.savefig(output_fn)
pl.show()
def plot_effective_mass(data_file,settings_file="input.xml",label="",param_file="effective_mass_t.dat",factor=1,fit_lines=True):
root=ET.parse(settings_file).getroot()
skip=int(root.find("measures").find("winding_number").attrib["skip"])
time_step=float(root.find("method").find("delta_tau").text)
fit_mean=[]
fit_low=[]
fit_up=[]
data=tools.read_matrix_from_file(data_file)
data[1]=data[1]*factor
data[2]=data[2]*factor
#plt.ylim(0,1)
if (os.path.isfile(param_file) and fit_lines==True):
with open(param_file,"r") as f:
cut_low=int(f.readline())
cut_heigh=int(f.readline())
params=f.readline().split();
errors=f.readline().split();
a=(time_step*(skip+1))
for x in (data[0][cut_low:cut_heigh]*a):
#values.append(effective_mass_exp_curve(float(x),float(params[0]),float(params[1]),float(params[2])))
fit_mean.append(hyperbole(float(x),float(params[0]),float(params[1])*a))
fit_low.append(hyperbole(float(x),float(params[0])-float(errors[0]),float(params[1])*a - float(errors[1])*a))
fit_up.append(hyperbole(float(x),float(params[0])+float(errors[0]),float(params[1])*a + float(errors[1])*a))
plt.plot(data[0][cut_low:cut_heigh]*a,fit_mean,linewidth=4)
plt.fill_between(data[0][cut_low:cut_heigh]*a,fit_low,fit_up,alpha=0.4)
return plt.errorbar(data[0]*time_step*(skip+1),data[1]/(data[0]*time_step*(skip+1)), yerr=data[2]/(data[0]*time_step*(skip+1)),label=label,fmt='o',ms=1)
def plot_posterior_linear(params_fname, fig_fname, control=False, M=20):
# load dataset
data = np.loadtxt('./sandbox/hh_data.txt')
# use the voltage and potasisum current
data = data / np.std(data, axis=0)
y = data[:, :4]
xc = data[:, [-1]]
# init hypers
Dlatent = 2
Dobs = y.shape[1]
T = y.shape[0]
if control:
x_control = xc
no_panes = 5
else:
x_control = None
no_panes = 4
model_aep = aep.SGPSSM_Linear(y,
Dlatent,
M,
lik='Gaussian',
prior_mean=0,
prior_var=1000,
x_control=x_control)
model_aep.load_model(params_fname)
my, vy, vyn = model_aep.get_posterior_y()
vy_diag = np.diagonal(vy, axis1=1, axis2=2)
vyn_diag = np.diagonal(vyn, axis1=1, axis2=2)
cs = ['k', 'r', 'b', 'g']
labels = ['V', 'm', 'n', 'h']
plt.figure()
t = np.arange(T)
for i in range(4):
yi = y[:, i]
mi = my[:, i]
vi = vy_diag[:, i]
vin = vyn_diag[:, i]
plt.subplot(no_panes, 1, i + 1)
plt.fill_between(t,
mi + 2 * np.sqrt(vi),
mi - 2 * np.sqrt(vi),
color=cs[i],
alpha=0.4)
plt.plot(t, mi, '-', color=cs[i])
plt.plot(t, yi, '--', color=cs[i])
plt.ylabel(labels[i])
plt.xticks([])
plt.yticks([])
if control:
plt.subplot(no_panes, 1, no_panes)
plt.plot(t, x_control, '-', color='m')
plt.ylabel('I')
plt.yticks([])
plt.xlabel('t')
plt.savefig(fig_fname)
if control:
plot_model_with_control(model_aep, '', '_linear_with_control')
else:
plot_model_no_control(model_aep, '', '_linear_no_control')
def showMeanSTDMetric(metric_name, m_table, title, output_fn=None):
pl.figure()
ax = pl.subplot(111)
#pl.set_context("talk", font_scale=1, rc={"lines.linewidth": 0.2})
siz = table.shape[0]
# ax=pl.errorbar(range(siz),m_table[metric_name],yerr=m_table[metric_name], fmt='o')
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
pl.fill_between(
range(siz),
m_table[metric_name + '_mean'] - m_table[metric_name + '_std'],
m_table[metric_name + '_mean'] + m_table[metric_name + '_std'],
color="#3F5D7D",
alpha=0.8,
lw=0.001)
pl.plot(range(siz), m_table[metric_name + '_mean'], color="r", lw=2)
labels = range(1, siz, 30)
#g = sns.FacetGrid(m_table)
#g.map(pl.errorbar, "csv_path", metric_name, yerr= m_table[metric_name+'_std'] , marker="o")
pl.xticks(labels, labels, fontsize=9)
pl.title(title)
pl.xlabel('Image ID 1 ~ ' + str(siz))
if (output_fn is None):
output_fn = data_DIR + '/' + metric_name + title + '.mean_std.pdf'
pl.savefig(output_fn)
pl.show()
def plot_link(model, transfo = lambda x:x, percentiles = None, link = True,
likelihood = False, n_measures = None):
Xgrid = np.linspace(0, np.pi, 200)[:, np.newaxis]
mu_f, var_f = model._raw_predict(Xgrid, full_cov=False, kern=None)
s_f = np.random.randn(mu_f.shape[0], 1000) * np.sqrt(var_f) + mu_f
s_f = transfo(s_f)
if(link):
if(likelihood):
s_p = model.likelihood(s_f, Y_metadata={'trials':n_measures})
else:
s_p = model.likelihood.gp_link.transf(s_f)
else:
s_p = s_f
mu_p = np.mean(s_p, axis = 1)
if(percentiles is None):
var_p = np.std(s_p, axis = 1)
muplus = mu_p + 1.96 * var_p
muminus = mu_p - 1.96 * var_p
else:
muminus, muplus = np.percentile(s_p, percentiles, axis = 1)
X_data, Y_data = model.X, model.Y
x = np.squeeze(Xgrid)
xd = np.squeeze(X_data)
yd = np.squeeze(transfo(Y_data))
plt.plot(x, mu_p, 'b', label = 'proxy')
plt.fill_between(x, muminus, muplus, color = 'blue', alpha = 0.5, label = 'confidence')
plt.scatter(xd, yd, c='black', marker='x', label = 'observations')
def get_metrics(model, X, Y):
x = np.linspace(-1, 1.2, 1000).reshape(-1, 1)
x_var = Variable(torch.FloatTensor(x))
if isinstance(model, BayesMLP):
# Make several predictions
list_preds = []
for i in range(100):
list_preds.append(model(x_var).data.cpu().numpy())
preds = np.stack(list_preds)
plt.scatter(X, Y, s=5, color="C0")
plt.plot(x, np.median(preds, 0), color="C1")
upper = np.median(preds, 0) + np.std(preds, 0)
lower = np.median(preds, 0) - np.std(preds, 0)
plt.fill_between(x[:, 0],
lower[:, 0],
upper[:, 0],
color='C1',
alpha=0.2)
plt.show()
else:
preds = model(x_var).data.cpu().numpy()
plt.scatter(X, Y, s=5, color="C0")
plt.plot(x, preds, color="C1")
plt.show()
def plot_beta_dist(ctr, trials, success, alphas, betas, turns):
"""
Pass in the ctr, trials and success, alphas, betas returned
by the `experiment` function and the number of turns
and plot the beta distribution for all the arms in that turn
"""
subplot_num = len(turns) / 2
x = np.linspace(0.001, .999, 200)
fig = plt.figure(figsize=(14, 7))
for idx, turn in enumerate(turns):
plt.subplot(subplot_num, 2, idx + 1)
for i in range(len(ctr)):
y = beta(alphas[i] + success[turn, i],
betas[i] + trials[turn, i] - success[turn, i]).pdf(x)
line = plt.plot(x, y, lw=2, label="arm {}".format(i + 1))
color = line[0].get_color()
plt.fill_between(x, 0, y, alpha=0.2, color=color)
plt.axvline(x=ctr[i], color=color, linestyle="--", lw=2)
plt.title("Posteriors After {} turns".format(turn))
plt.legend(loc="upper right")
return fig
def make_graph(folder, c, i):
ls = "dotted"
if "f100" in folder:
ls = "dashed"
if "f1000" in folder or "qlearning" in folder:
ls = "solid"
df = pd.read_csv("{}/{}/{}".format(directory_path, folder, data_path))
x = np.array(df.loc[:, x_axis].values)
y = np.array(df.loc[:, y_axis].values)
#print x
#print y
if rolling_mean == 1:
y = pd.Series(y).rolling(window=rolling_width).mean()
#print y
split = folder.split("_")
index = None
for i in range(len(split)):
if re.match("f" + r"[0-9]+", split[i]):
index = i
if update_freq_label == True and index:
plt.plot(x, y, color = c, label = re.search(r'[0-9]+', split[index]).group(), linestyle = ls)
else:
plt.plot(x, y, color = c, label="{}".format(folder), linestyle = ls)
if mode == "test" and variance == True:
reward_std = np.array(df.loc[:, "reward_std"].values)
plt.fill_between(x, y+reward_std, y-reward_std, facecolor=c, alpha=0.3)
def SNPhot_plotter_filt(obs, gp, filt=b'r'):
df = obs[obs.FLT == filt]
x = df.MJD.values
y = df.FLUXCAL.values
dy = df.FLUXCALERR.values
colors = {b'g': 'g', b'r': 'r', b'i': 'c', b'z': 'm'}
pred = pred_var = 0.
if gp is not None:
x_pred = np.linspace(x.min() - 100., x.max() + 100., 1000)
pred, pred_var = gp.predict(y, x_pred, return_var=True)
#pred, pred_cov = gp.predict(y, x_pred, return_cov=True)
pred_sig = np.sqrt(np.abs(pred_var))
plt.fill_between(x_pred,
pred - 2 * pred_sig,
pred + 2 * pred_sig,
color=colors[filt],
alpha=0.2)
plt.plot(x_pred, pred, "k", lw=1.5, alpha=0.5)
plt.ylim(
np.append(np.append(y - dy * 1.1, [0]), [pred - pred_sig]).min(),
np.append(y + dy * 1.1, [pred + pred_sig]).max())
plt.errorbar(x, y, yerr=dy, fmt=".k", capsize=0)
plt.xlim(x.min() - 30, x.max() + 30)
plt.title(filt)
return plt
def plot(self, gp_num=0):
"""
Plot the mixture of Gaussian Processes.
"""
from matplotlib import pylab as plt
from matplotlib import cm
XX = np.linspace(self.X.min(), self.X.max())[:, None]
YY_mu, YY_var = self.predict_components(XX)
plt.scatter(self.X,
self.Y,
c=self.phi[:, gp_num],
cmap=cm.RdBu,
vmin=0.,
vmax=1.,
lw=0.5)
plt.colorbar(label='GP {} assignment probability'.format(gp_num))
GPy.plotting.matplot_dep.Tango.reset()
for i in range(self.phi.shape[1]):
col = GPy.plotting.matplot_dep.Tango.nextMedium()
plt.fill_between(XX[:, 0],
YY_mu[:, i] - 2 * np.sqrt(YY_var[:, i]),
YY_mu[:, i] + 2 * np.sqrt(YY_var[:, i]),
alpha=0.1,
facecolor=col)
plt.plot(XX, YY_mu[:, i], c=col, lw=2)
def nova_plot():
erg2mev=624151.
fig=plot.figure()
yrange = [1e-6,2e-4]
xrange = [1e-1,1e5]
plot.fill_between([0.2,10e3],[yrange[1],yrange[1]],[yrange[0],yrange[0]],facecolor='yellow',interpolate=True,color='yellow',alpha=0.5)
plot.annotate('AMEGO',xy=(3,9e-5),xycoords='data',fontsize=26,color='black')
lat=ascii.read("data/NMon2012.LAT.dat",names=['energy','en_low','en_high','flux','flux_err','tmp'])
plot.scatter(lat['energy'],lat['flux']*erg2mev,color='red')
plot.errorbar(lat['energy'],lat['flux']*erg2mev,xerr=[lat['en_low'],lat['en_high']],yerr=lat['flux_err']*erg2mev,ecolor='red',capsize=0,fmt='none')
latul=ascii.read("data/NMon2012.LAT.limits.dat",names=['energy','en_low','en_high','flux','tmp1','tmp2','tmp3','tmp4'])
plot.errorbar(latul['energy'],latul['flux']*erg2mev,xerr=[latul['en_low'],latul['en_high']],yerr=0.5*latul['flux']*erg2mev,uplims=True,ecolor='red',capsize=0,fmt='none')
plot.scatter(latul['energy'],latul['flux']*erg2mev,color='red')
leptonic=ascii.read("data/sp-NMon12-IC-best-fit-1MeV-30GeV.txt",names=['energy','flux'],data_start=1)
hadronic=ascii.read("data/sp-NMon12-pi0-and-secondaries.txt",names=['energy','flux1','flux2'],data_start=1)
plot.plot(leptonic['energy'],leptonic['flux']*erg2mev,'r--',color='black',lw=2,label='Leptonic')
plot.plot(hadronic['energy'],hadronic['flux2']*erg2mev,color='black',lw=2,label='Hadronic+Secondary Leptons')
plot.legend(loc='upper right',fontsize='small',frameon=False,framealpha=0.5)
plot.xscale('log')
plot.yscale('log')
plot.ylim(yrange)
plot.xlim(xrange)
plot.xlabel(r'Energy (MeV)')
plot.ylabel(r'Energy$^2 \times $ Flux (Energy) (erg cm$^{-2}$ s$^{-1}$)')
plot.title('Nova V339 Del 2013')
plot.savefig('Nova_SED.png', bbox_inches='tight')
plot.savefig('Nova_SED.eps', bbox_inches='tight')
plot.show()
plot.close()
def extractEffectiveMass(df,cut_low=0,cut_right=None,n_cuts=5,makePlot=False):
if cut_right==None:
cut_right=max(df["t"])
window=(cut_right-cut_low)/n_cuts
slope=np.zeros(n_cuts)
intercept=np.zeros(n_cuts)
slopeError=np.zeros(n_cuts)
interceptError=np.zeros(n_cuts)
for i in range(0,n_cuts):
# select the right intervals for the linear fit
cut_low_current=cut_low + i*window
cut_high_current=cut_low + (i+1)*window
df1=df[(df["t"]>cut_low_current) & (df["t"]<cut_high_current) ]
if len(df1["t"]) <= 3:
raise not_enough_data()
params,covs=curve_fit(linear,df1["t"],df1["W"],sigma=df1["deltaW"],maxfev=100000)
slope[i]=params[0]
intercept[i]=params[1]
slopeError[i]=sqrt(covs[0][0])
interceptError[i]=sqrt(covs[1][1])
if makePlot==True:
up=(slope[i]+slopeError[i])+(intercept[i]+interceptError[i])/df1["t"]
down=(slope[i]-slopeError[i])+(intercept[i]-interceptError[i])/df1["t"]
plt.fill_between(df1["t"],up,down,alpha=0.4)
plt.errorbar(np.array(df1["t"]),np.array(df1["W"])/np.array(df1["t"]),np.array(df1["deltaW"])/np.array(df1["t"]),fmt="or")
return np.array([slope.mean(),sqrt( slopeError.mean()**2 + slope.var())])
def plot_spectra(eigval_col, savename="spectrum_onetrial.jpg", figdir=savedir, fig=None, label="BP"):
"""A local function to compute these figures for different subspaces. """
eigmean = eigval_col.mean(axis=0)
eiglim = np.percentile(eigval_col, [5, 95], axis=0)
sortidx = np.argsort(-np.abs(eigmean))
eigmean = np.abs(eigmean[sortidx])
eiglim = eiglim[:, sortidx]
eigN = len(eigmean)
if fig is None:
fig, axs = plt.subplots(1, 2, figsize=[10, 5])
else:
# plt.figure(fig.number)
plt.figure(num=fig.number)
axs = fig.axes
plt.sca(axs[0])
plt.plot(range(eigN), eigmean, alpha=0.6)
plt.fill_between(range(eigN), eiglim[0, :], eiglim[1, :], alpha=0.3, label=label)
plt.ylabel("eigenvalue")
plt.xlabel("eig id")
plt.legend()
plt.sca(axs[1])
plt.plot(range(eigN), np.log10(eigmean), alpha=0.6)
plt.fill_between(range(eigN), np.log10(eiglim[0, :]), np.log10(eiglim[1, :]), alpha=0.3, label=label)
plt.ylabel("eigenvalue(log)")
plt.xlabel("eig id")
plt.legend()
st = plt.suptitle("Hessian Spectrum of StyleGAN\n (error bar for [5,95] percentile among all samples)")
plt.savefig(join(figdir, savename), bbox_extra_artists=[st]) # this is working.
# fig.show()
return fig
def plot_statistics_of(cvar, monitoring):
''' plots min/max/mean timeseries,
takes variable without suffix as string (e.g. dynstat_sst)'''
meanvar = monitoring[monitoring.gcmvariable == cvar +
'_mean'].gcmvalue.values
minvar = monitoring[monitoring.gcmvariable == cvar +
'_min'].gcmvalue.values
maxvar = monitoring[monitoring.gcmvariable == cvar +
'_max'].gcmvalue.values
fig = plt.figure(figsize=[12, 8])
plt.subplot(121)
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m/%Y'))
plt.gca().xaxis.set_major_locator(mdates.MonthLocator())
plt.gca().xaxis.set_minor_formatter(mdates.DateFormatter('%d'))
plt.gca().xaxis.set_minor_locator(mdates.DayLocator())
plt.fill_between(monitoring['dates'], minvar, maxvar, color='grey')
plt.plot(monitoring['dates'], meanvar, 'r.')
plt.title('range and mean ' + cvar)
plt.gcf().autofmt_xdate()
plt.subplot(122)
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m/%Y'))
plt.gca().xaxis.set_major_locator(mdates.MonthLocator())
plt.gca().xaxis.set_minor_formatter(mdates.DateFormatter('%d'))
plt.gca().xaxis.set_minor_locator(mdates.DayLocator())
plt.plot(monitoring['dates'], meanvar, 'r.')
plt.title('zoom on mean ' + cvar)
plt.gcf().autofmt_xdate()
plt.show()
def get_test_result(model, lr, isplot = True):
print(dataset_filename)
tasks = pickle.load(open(dataset_filename, "rb"))
tasks_test = get_torch_tasks(tasks["tasks_test"], task_id_list[0], start_id = num_train_tasks, num_forward_steps = forward_steps[-1], is_oracle = is_oracle, is_cuda = is_cuda)
task_keys_all = list(tasks_test.keys())
mse_list_all = []
for i in range(int(len(tasks_test) / 100)):
print("{0}:".format(i))
task_keys_iter = task_keys_all[i * 100: (i + 1) * 100]
tasks_test_iter = {task_key: tasks_test[task_key] for task_key in task_keys_iter}
mse = plot_quick_learn_performance(model, tasks_test_iter, is_time_series = is_time_series, forward_steps = forward_steps, lr = lr, epochs = 20, isplot = isplot)['model_0'].mean(0)
mse_list_all.append(mse)
mse_list_all = np.array(mse_list_all)
info_dict["mse_test_lr_{0}".format(lr)] = mse_list_all
pickle.dump(info_dict, open(filename + "info.p", "wb"))
print("mean:")
print(mse_list_all.mean(0))
print("std:")
print(mse_list_all.std(0))
if isplot:
plt.figure(figsize = (8,6))
mse_list_all = np.array(mse_list_all)
mse_mean = mse_list_all.mean(0)
mse_std = mse_list_all.std(0)
plt.fill_between(range(len(mse_mean)), mse_mean - mse_std * 1.96 / np.sqrt(int(len(tasks_test) / 100)), mse_mean + mse_std * 1.96 / np.sqrt(int(len(tasks_test) / 100)), alpha = 0.3)
plt.plot(range(len(mse_mean)), mse_mean)
plt.title("{0}, {1}-shot regression, lr = {2}".format(task_id_list[0], num_shots, lr), fontsize = 20)
plt.xlabel("Number of gradient steps", fontsize = 18)
plt.ylabel("Mean Squared Error", fontsize = 18)
plt.show()
return mse_list_all
def visualize(sample, lib, **kwargs):
lab = ["out. temp", "indoor temp", "Hvac W", "Sun W"]
col = ["blue", "green", "red", "orange"]
xrange = np.arange(sample.shape[0])
ax1 = plt.subplot(111)
ax1.set_ylabel("°C")
plt.title(lib)
plt.plot(sample[:, 1], label=lab[1], color=col[1])
plt.plot(sample[:, 0], label=lab[0], color=col[0])
if len(kwargs):
# you can plot 4 extra curves
icons = [':', '--', 'o', '*']
indice = 0
for key, vals in kwargs.items():
plt.plot(vals,
icons[indice],
markersize=2,
label="{}.".format(key))
indice += 1
plt.legend(loc='upper left')
ax2 = ax1.twinx()
ax2.set_ylabel("W")
plt.plot(sample[:, 2], label=lab[2], color=col[2])
plt.fill_between(xrange, 0, sample[:, 2], color=col[2], alpha=0.2)
plt.plot(sample[:, 3], label=lab[3], color=col[3])
plt.fill_between(xrange, 0, sample[:, 3], color=col[3], alpha=0.4)
plt.legend(loc='upper right')
plt.show()
def spectra_montage(GANlist, fnlist, ylog=True, xnorm=False, ynorm=True, shade=True, xlim=(-25, 525), ylim=None,\
lw=1, fn="spectra_synopsis_log_rank"):
fig = plt.figure(figsize=[5,4.5])
for i, GAN in enumerate(GANlist):
with np.load(join(rootdir, fnlist[i])) as data:
eigval_col = data["eigval_col"]
if eigval_col[:, -1].mean() > eigval_col[:, 0].mean():
eigval_col = eigval_col[:, ::-1]
eva_mean = eigval_col.mean(axis=0)
eva_lim = np.percentile(eigval_col, [5, 95], axis=0)
# eva_lim_pos = np.maximum(eva_lim, cutoffR * eva_mean.max())
eva_lim_pos = eva_lim.copy()
if ylog:
negmask = eva_lim_pos[0, :] < 0
eva_lim_pos[0, negmask] = eva_mean[negmask]
xnormalizer = len(eva_mean) if xnorm else 1
ynormalizer = eva_mean.max() if ynorm else 1
ytfm = np.log10 if ylog else lambda x: x
plt.plot(np.arange(len(eva_mean))/xnormalizer, ytfm(eva_mean / ynormalizer), alpha=.8, lw=lw, label=GAN) # ,
# eigval_arr.std(axis=0)
if shade:
plt.fill_between(np.arange(len(eva_mean))/xnormalizer, ytfm(eva_lim_pos[0, :] / ynormalizer),
ytfm(eva_lim_pos[1, :] / ynormalizer), alpha=0.1)
plt.ylabel("log10(eig/eigmax)" if ylog else "eig/eigmax")
plt.xlabel("rank normalized to latent dim" if xnorm else "ranks")
plt.xlim(xlim)
if ylim is not None: plt.ylim(ylim)
plt.title("Spectra Compared Across GANs")
plt.legend(loc="best")
plt.savefig(join(rootdir, fn+".png"))
plt.savefig(join(rootdir, fn+".pdf"))
plt.show()
return fig
def ocean():
dmax = 1650.e3
dp = np.linspace(0., dmax, 3301)
zp = maketopo.shelf1(dp)
plt.clf()
plt.plot(dp * 1e-3, zp, 'k-', linewidth=3)
plt.fill_between(dp * 1e-3, zp, 0., where=(zp < 0.), color=[0, 0.5, 1])
plt.xlim([0., 1650])
plt.ylim([-4500., 500])
plt.title("Topography as function of radius", fontsize=18)
plt.xlabel("kilometers from center", fontsize=15)
plt.ylabel("meters", fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.savefig('topo1.png')
#plt.savefig('topo1.tif')
print("Cross-section plot in topo1.png")
plt.xlim([1500, 1650])
plt.ylim([-200., 20])
plt.title("Topography of shelf and beach", fontsize=18)
plt.xlabel("kilometers from center", fontsize=15)
plt.ylabel("meters", fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.savefig('topo2.png')
#plt.savefig('topo2.tif')
print("Zoom near shore in topo2.png")
def plot_corridor(x,y,axis=1,alpha=0.2,**kwargs):
x = np.array(x,dtype=float)
from matplotlib.pylab import fill_between, plot
fill_between(x, y.mean(axis)-y.std(axis), y.mean(axis)+y.std(axis),alpha=alpha,**kwargs)
plot(x, y.mean(axis)+y.std(axis),'-',alpha=alpha,**kwargs)
plot(x, y.mean(axis)-y.std(axis),'-',alpha=alpha,**kwargs)
plot(x,y.mean(axis),**kwargs)
def plot_total_dos(self, **kwargs):
"""
Plots the total DOS
Args:
**kwargs: Variables for matplotlib.pylab.plot customization (linewidth, linestyle, etc.)
Returns:
matplotlib.pylab.plot
"""
try:
import matplotlib.pylab as plt
except ImportError:
import matplotlib.pyplot as plt
fig = plt.figure(1, figsize=(6, 4))
ax1 = fig.add_subplot(111)
ax1.set_xlabel("E (eV)", fontsize=14)
ax1.set_ylabel("DOS", fontsize=14)
for i, energies in enumerate(self.energies):
plt.fill_between(energies,
self.t_dos[i],
label="spin {}".format(i),
**kwargs)
plt.legend()
return plt
def plot_nowcast(model, updates):
fig = plt.figure(figsize=(20, 10))
y = model.trace['y_hat_%s' % model.name]
ddf = pd.DataFrame(
[
np.percentile(y, 50, axis=0),
np.max(y, axis=0),
np.min(y, axis=0),
]
).T
ddf["ds"] = model.data["ds"]
ddf.columns = ["y_hat", "y_low", "y_high", "ds"]
ddf["orig_y"] = model.data["y"]
ddf.plot("ds", "y_hat", ax=plt.gca())
plt.fill_between(
ddf["ds"].values,
ddf["y_low"].values.astype(float),
ddf["y_high"].values.astype(float),
alpha=0.3,
)
ddf.plot("ds", "orig_y", style="k.", ax=plt.gca(), alpha=0.3)
for update in updates:
plt.axvline(
update, color="C3", lw=1, ls="dotted"
)
plt.grid(axis="y")
return fig
def my_hist(data, bins, range, field, color, label):
#plt.hist(data, bins, label=label, alpha=0.2, normed=True,
# range=range, color=color)
y, bin_edges = np.histogram(data, bins=bins, normed=True)
bin_centers = 0.5 * (bin_edges[1:] + bin_edges[:-1])
plt.fill_between(bin_centers, y, color=color, alpha=0.2, label=label)
plt.xlabel('$log_{10}($ ' + field+' $)$')
plt.ylabel('Density')
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)):
"""
Generate a simple plot of the test and traning learning curve.
Parameters
----------
estimator : object type that implements the "fit" and "predict" methods
An object of that type which is cloned for each validation.
title : string
Title for the chart.
X : array-like, shape (n_samples, n_features)
Training vector, where n_samples is the number of samples and
n_features is the number of features.
y : array-like, shape (n_samples) or (n_samples, n_features), optional
Target relative to X for classification or regression;
None for unsupervised learning.
ylim : tuple, shape (ymin, ymax), optional
Defines minimum and maximum yvalues plotted.
cv : integer, cross-validation generator, optional
If an integer is passed, it is the number of folds (defaults to 3).
Specific cross-validation objects can be passed, see
sklearn.cross_validation module for the list of possible objects
n_jobs : integer, optional
Number of jobs to run in parallel (default 1).
"""
plt.figure()
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel("Training examples")
plt.ylabel("Score")
train_sizes, train_scores, test_scores = learning_curve(
estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.grid()
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1, color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
label="Cross-validation score")
plt.legend(loc="best")
return plt
def plot_particles(PARTICLE_FILENAME, TRUTH_FILENAME, OUT_FILENAME):
T_DELTA = 1/30.
a = np.load(PARTICLE_FILENAME)
truth = pickle.load(open(TRUTH_FILENAME, 'r'))
weights = a['weights']
particles = a['particles']
truth_state = truth['state'][:len(particles)]
STATEVARS = ['x', 'y', 'xdot', 'ydot', 'phi', 'theta']
vals = dict([(x, []) for x in STATEVARS])
for p in particles:
for v in STATEVARS:
vals[v].append([s[v] for s in p])
for v in STATEVARS:
vals[v] = np.array(vals[v])
pylab.figure()
for vi, v in enumerate(STATEVARS):
if 'dot' in v:
v_truth = np.diff(truth_state[v[0]])/T_DELTA
else:
v_truth = truth_state[v]
v_bar = np.average(vals[v], axis=1, weights=weights)
x = np.arange(0, len(v_bar))
cred = np.zeros((len(x), 2), dtype=np.float)
for ci, (p, w) in enumerate(zip(vals[v], weights)):
cred[ci] = util.credible_interval(p, w)
pylab.subplot(len(STATEVARS) + 1,1, 1+vi)
pylab.plot(v_truth, color='g', linestyle='-',
linewidth=1)
pylab.plot(x, v_bar, color='b')
pylab.fill_between(x, cred[:, 0],
cred[:, 1], facecolor='b',
alpha=0.4)
pylab.ylim([np.min(v_truth),
np.max(v_truth)])
pylab.subplot(len(STATEVARS) + 1, 1, len(STATEVARS)+1)
# now plot the # of particles consuming 95% of the prob mass
real_particle_num = []
for w in weights:
w = w / np.sum(w) # make sure they're normalized
w = np.sort(w)[::-1] # sort, reverse order
wcs = np.cumsum(w)
wcsi = np.searchsorted(wcs, 0.95)
real_particle_num.append(wcsi)
pylab.plot(real_particle_num)
pylab.savefig(OUT_FILENAME)
def plot_label(label,offset=0):
Y = df.groupby(cut)[label].mean()
YERR = df.groupby(cut)[label].std()
X = df.groupby(cut)["L-cut"].mean()
color = current_palette.next()
plt.plot(X+offset,Y,label=label,lw=2,color=color)
plt.fill_between(X+offset,Y+YERR, Y-YERR,alpha=0.15,color=color)
return X,Y
def make_test_graph(directory_path, comment):
df = pd.read_csv("{}/{}/evaluation/evaluation.csv".format(directory_path, comment))
total_step = np.array(df.loc[:, "total_step"].values)
reward_mean = np.array(df.loc[:, "reward_mean"].values)
reward_std = np.array(df.loc[:, "reward_std"].values)
#step_mean = np.array(df.loc[:, "step_mean"].values, dtype=np.float)
#step_std = np.array(df.loc[:, "step_std"].values, dtype=np.float)
plt.figure()
plt.plot(total_step, reward_mean, color="red")
plt.fill_between(total_step, reward_mean+reward_std, reward_mean-reward_std, facecolor='red', alpha=0.3)
plt.savefig("{}/{}/evaluation/reward.png".format(directory_path, comment))
def plot_pr(auc_score, precision, recall, label=None):
pylab.figure(num=None, figsize=(6, 5))
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('Recall')
pylab.ylabel('Precision')
pylab.title('P/R (AUC=%0.2f) / %s' % (auc_score, label))
pylab.fill_between(recall, precision, alpha=0.5)
pylab.grid(True, linestyle='-', color='0.75')
pylab.plot(recall, precision, lw=1)
pylab.show()
def plot_auc(self, auc_score, tpr, fpr, label=None):
pylab.figure(num = None, figsize=(6, 5))
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('False Positive Rate')
pylab.ylabel('True Positive Rate')
pylab.title('ROC (AUC=%0.2f) / %s' % (auc_score, label))
pylab.fill_between(fpr, tpr, alpha=0.5)
pylab.grid(True, linestyle='-', color='0.75')
pylab.plot(fpr, tpr, lw=1)
pylab.show()
def plot_pr(auc_score, name, precision, recall, label=None):
pylab.figure(num=None, figsize=(6, 5))
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('Recall')
pylab.ylabel('Precision')
pylab.title('P/R (AUC=%0.2f) / %s' % (auc_score, label))
pylab.fill_between(recall, precision, alpha=0.5)
pylab.grid(True, linestyle='-', color='0.75')
pylab.plot(recall, precision, lw=1)
filename = name.replace(" ", "_")
pylab.savefig(os.path.join(CHART_DIR, "pr_" + filename + ".png"))
def plot_roc(auc_score, name, fpr, tpr):
pylab.figure(num=None, figsize=(6, 5))
pylab.plot([0, 1], [0, 1], "k--")
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel("False Positive Rate")
pylab.ylabel("True Positive Rate")
pylab.title("Receiver operating characteristic (AUC=%0.2f)\n%s" % (auc_score, name))
pylab.legend(loc="lower right")
pylab.grid(True, linestyle="-", color="0.75")
pylab.fill_between(tpr, fpr, alpha=0.5)
pylab.plot(fpr, tpr, lw=1)
pylab.savefig(os.path.join(CHART_DIR, "roc_" + name.replace(" ", "_") + ".png"))
def plot_pr(auc_score, name, phase, precision, recall, label=None):
pylab.clf()
pylab.figure(num=None, figsize=(5, 4))
pylab.grid(True)
pylab.fill_between(recall, precision, alpha=0.5)
pylab.plot(recall, precision, lw=1)
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('Recall')
pylab.ylabel('Precision')
pylab.title('P/R curve (AUC=%0.2f) / %s' % (auc_score, label))
filename = name.replace(" ", "_")
pylab.savefig(os.path.join(CHART_DIR, "pr_%s_%s.png"%(filename, phase)), bbox_inches="tight")
def plot_pr(auc_score, name, phase, precision, recall, label=None):
from matplotlib import pylab
pylab.clf()
pylab.figure(num=None, figsize=(5, 4))
pylab.grid(True)
pylab.fill_between(recall, precision, alpha=0.5)
pylab.plot(recall, precision, lw=1)
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('Recall')
pylab.ylabel('Precision')
pylab.title('P/R curve (AUC=%0.2f) / %s' % (auc_score, label))
filename = name.replace(" ", "_")
def plot_pr(auc_score, precision, recall, label=None):
pylab.figure(num=None, figsize=(6, 5))
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('Recall')
pylab.ylabel('Precision')
pylab.title('P/R (AUC=%0.2f) / %s' % (auc_score, label))
pylab.fill_between(recall, precision, alpha=0.5)
pylab.grid(True, linestyle='-', color='0.75')
pylab.plot(recall, precision, lw=1)
pylab.savefig("test.png")
pylab.show()
# #读取
# movie_data = sp.load('movie_data.npy')
# movie_target = sp.load('movie_target.npy')
# x = movie_data
# y = movie_target
# #BOOL型特征下的向量空间模型，注意，测试样本调用的是transform接口
# count_vec = TfidfVectorizer(binary = False, decode_error = 'ignore', \
# stop_words = 'english')
# average = 0
# testNum = 10
# for i in range(0, testNum):
# #加载数据集，切分数据集80%训练，20%测试
# x_train, x_test, y_train, y_test \
# = train_test_split(movie_data, movie_target, test_size = 0.2)
# x_train = count_vec.fit_transform(x_train)
# x_test = count_vec.transform(x_test)
# #训练LR分类器
# clf = LogisticRegression()
# clf.fit(x_train, y_train)
# y_pred = clf.predict(x_test)
# p = np.mean(y_pred == y_test)
# print(p)
# average += p
# #准确率与召回率
# answer = clf.predict_proba(x_test)[:,1]
# precision, recall, thresholds = precision_recall_curve(y_test, answer)
# report = answer > 0.5
# print(classification_report(y_test, report, target_names = ['neg', 'pos']))
# print("average precision:", average/testNum)
# print("time spent:", time.time() - start_time)
# plot_pr(0.5, precision, recall, "pos")
def fitconf(xdata,ydata,errx,erry,covxy,nboot=1000,bcesMethod='ort',linestyle='',conf=0.683,confcolor='gray',xplot=None,front=False,**args): """ This is a wrapper that given the input data performs the BCES fit, get the orthogonal parameters and plot the best-fit line and confidence band (generated using analytical methods). I decided to put together these commands in a method because I have been using them very frequently. Assumes you initialized the plot window before calling this method. Usage: >>> a1,b1,erra1,errb1,cov1=nemmen.fitconf(x[i],y[i],errx[i],erry[i],covxy[i],nboot,bces,linestyle='k',confcolor='LightGrey') Explanation of some arguments: - xplot: if provided, will compute the confidence band in the X-values provided with xplot - front: if True, then will plot the confidence band in front of the data points; otherwise, will plot it behind the points """ import bces.bces from . import stats from . import misc # Selects the desired BCES method i=misc.whichbces(bcesMethod) # Performs the BCES fit a,b,erra,errb,cov=bces.bces.bcesp(xdata,errx,ydata,erry,covxy,nboot) # Plots best-fit if xplot==None: x=numpy.linspace(xdata.min(),xdata.max(),100) else: x=xplot pylab.plot(x,a[i]*x+b[i],linestyle,**args) fitm=numpy.array([ a[i],b[i] ]) # array with best-fit parameters covm=numpy.array([ (erra[i]**2,cov[i]), (cov[i],errb[i]**2) ]) # covariance matrix def func(x): return x[1]*x[0]+x[2] # Plots confidence band lcb,ucb,xcb=stats.confbandnl(xdata,ydata,func,fitm,covm,2,conf,x) if front==True: zorder=10 else: zorder=None pylab.fill_between(xcb, lcb, ucb, alpha=0.3, facecolor=confcolor, zorder=zorder) return a,b,erra,errb,cov
def plot(self, gp_num=0):
"""
Plot the mixture of Gaussian Processes.
Supports plotting 1d and 2d regression.
"""
from matplotlib import pylab as plt
from matplotlib import cm
XX = np.linspace(self.X.min(), self.X.max())[:, None]
if self.Y.shape[1] == 1:
plt.scatter(self.X, self.Y, c=self.phi[:, gp_num], cmap=cm.RdBu, vmin=0., vmax=1., lw=0.5)
plt.colorbar(label='GP {} assignment probability'.format(gp_num))
try:
Tango = GPy.plotting.Tango
except:
Tango = GPy.plotting.matplot_dep.Tango
Tango.reset()
for i in range(self.phi.shape[1]):
YY_mu, YY_var = self.predict(XX, i)
col = Tango.nextMedium()
plt.fill_between(XX[:, 0],
YY_mu[:, 0] - 2 * np.sqrt(YY_var[:, 0]),
YY_mu[:, 0] + 2 * np.sqrt(YY_var[:, 0]),
alpha=0.1,
facecolor=col)
plt.plot(XX, YY_mu[:, 0], c=col, lw=2);
elif self.Y.shape[1] == 2:
plt.scatter(self.Y[:, 0], self.Y[:, 1], c=self.phi[:, gp_num], cmap=cm.RdBu, vmin=0., vmax=1., lw=0.5)
plt.colorbar(label='GP {} assignment probability'.format(gp_num))
try:
Tango = GPy.plotting.Tango
except:
Tango = GPy.plotting.matplot_dep.Tango
Tango.reset()
for i in range(self.phi.shape[1]):
YY_mu, YY_var = self.predict(XX, i)
col = Tango.nextMedium()
plt.plot(YY_mu[:, 0], YY_mu[:, 1], c=col, lw=2);
else:
raise NotImplementedError('Only 1d and 2d regression can be plotted')
def make_loss_graph(directory_path, comment, fixed_q_update_counter):
df = pd.read_csv("{}/{}/loss/{}_loss.csv".format(directory_path, comment, fixed_q_update_counter))
total_step = np.array(df.loc[:, "total_step"].values)
loss_mean = np.array(df.loc[:, "loss_mean"].values)
loss_std = np.array(df.loc[:, "loss_std"].values)
penalty_mean = np.array(df.loc[:, "penalty_mean"].values)
penalty_std = np.array(df.loc[:, "penalty_std"].values)
plt.figure()
plt.plot(total_step, loss_mean, color="red")
plt.fill_between(total_step, loss_mean+loss_std, loss_mean-loss_std, facecolor='red', alpha=0.3)
plt.savefig("{}/{}/loss/{}_loss.png".format(directory_path, comment, fixed_q_update_counter))
plt.figure()
plt.plot(total_step, penalty_mean, color="blue")
plt.fill_between(total_step, penalty_mean+penalty_std, penalty_mean-penalty_std, facecolor='blue', alpha=0.3)
plt.savefig("{}/{}/loss/{}_penalty.png".format(directory_path, comment, fixed_q_update_counter))
def plot_roc(auc_score, tpr, fpr, label=None):
pylab.clf()
pylab.figure(num=None, figsize=(5, 4))
pylab.grid(True)
pylab.plot([0, 1], [0, 1], 'k--')
pylab.plot(fpr, tpr)
pylab.fill_between(fpr, tpr, alpha=0.5)
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('False Positive Rate')
pylab.ylabel('True Positive Rate')
pylab.title('ROC curve (AUC = %0.2f) / %s Vs Rest' %
(auc_score, label), verticalalignment="bottom")
pylab.legend(loc="lower right")
pylab.show()
def plot_roc(auc_score, name, tpr, fpr, label=None):
pylab.clf()
pylab.figure(num=None, figsize=(5, 4))
pylab.grid(True)
pylab.plot([0, 1], [0, 1], "k--")
pylab.plot(fpr, tpr)
pylab.fill_between(fpr, tpr, alpha=0.5)
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel("False Positive Rate")
pylab.ylabel("True Positive Rate")
pylab.title("ROC curve (AUC = %0.2f) / %s" % (auc_score, label), verticalalignment="bottom")
pylab.legend(loc="lower right")
filename = name.replace(" ", "_")
pylab.savefig(os.path.join(CHART_DIR, "roc_" + filename + ".png"), bbox_inches="tight")
def plot_pr(auc_score, name, phase, precision, recall, label=None):
"""This function plots the ROC curve"""
pylab.clf()
pylab.figure(num=None, figsize=(10, 6))
pylab.grid(True)
pylab.fill_between(recall, precision, alpha=0.5)
pylab.plot(recall, precision, lw=1)
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel('Recall')
pylab.ylabel('Precision')
pylab.title('P/R curve (AUC=%0.2f) / %s' % (auc_score, label))
filename = name.replace(" ", "_")
# pylab.show()
# pylab.savefig(os.path.join(".", "pr_%s_%s.png"%(filename, phase))
pylab.savefig("pr_%s_%s.png" % (filename, phase))
def plot_pr(auc_score, name, precision, recall, label=None):
"""
Plots Precision-Recall curves.
"""
pylab.clf()
pylab.figure(num=None, figsize=(5, 4))
pylab.grid(True)
pylab.fill_between(recall, precision, alpha=0.5)
pylab.plot(recall, precision, lw=1)
pylab.xlim([0.0, 1.0])
pylab.ylim([0.0, 1.0])
pylab.xlabel("Recall")
pylab.ylabel("Precision")
pylab.title("P/R curve (AUC = %0.2f) / %s" % (auc_score, label))
filename = name.replace(" ", "_")
pylab.savefig(os.path.join(CHART_DIR, "pr_" + filename + ".png"), bbox_inches="tight")