def __init__(self, fmt, set_label_fun=None, label_fmt=None, unit=None):
FormatStrFormatter.__init__(self, fmt)
self.engfmt = EngFormatter(unit="", places=2)
self.set_label_fun = set_label_fun
self.default_unit = unit
self._label_unit = None
self.set_label_fmt(label_fmt)
self.label_template = None
def __call__(self, x, pos=None):
locs = [abs(y) for y in self.locs if abs(y) != 0]
if locs and max(locs) / min(locs) <= 10000:
_, exponent = _help_format_sci(max(locs), 2)
div = 10 ** exponent
for dig in range(3):
digs = [abs((int((elem / div) * 10 ** dig) -
(elem / div) * 10 ** dig)) for elem in self.locs]
if max(digs) < 0.001:
self.fmt = "%%.%df" % dig
break
else:
self.fmt = "%%.%df" % self.digs
if self.set_label_fun and self.label_template:
prefix = si_exp_to_prefixes.get(exponent, "q")
if prefix == "q":
prefix = ""
div = 1
self.fmt = "%%.%de" % self.digs
xlabel = self.label_template % dict(prefix=prefix,
powerprefix=exponent)
self.set_label_fun(xlabel)
return FormatStrFormatter.__call__(self, x / div, pos)
else:
self.engfmt.locs = self.locs
return self.engfmt(x, pos)
def __call__(self, x, pos=None):
div = 1
prefix = ""
for dig in range(3):
digs = [abs((int((elem / div) * 10 ** dig) -
(elem / div) * 10 ** dig)) for elem in self.locs]
if max(digs) < 0.001:
self.fmt = "%%.%df" % dig
break
else:
self.fmt = "%.3f"
if self.set_label_fun and self.label_template:
xlabel = self.label_template % dict(prefix=prefix)
self.set_label_fun(xlabel)
return FormatStrFormatter.__call__(self, x / div, pos)
def plot_hist_w_stats(ax, x_data, x_name, x_units, res=50, norm=1.0,
weights=None, cum=False, htype="bar", align="mid",
rwidth=None, n_label="Fractional Counts", xmin=None,
xmax=None, nmin=None, nmax=None, xinc=6, ninc=6,
color="b", title=None, tloc="t", xl=True, xt=True,
yl=True, yt=True, moments=4, quartiles=3, modes=False,
sloc="il", *args, **kwargs):
'''
Creates a single histogram plot with a text box showing the desired stats.
Input: ax = axis handle
x_data = list or numpy array containing x-axis data
x_name = Label name of x-axis
x_units = Units for x-axis
res = Histogran bin resolution. A sequence can be used to
provide unequally spaced bins. (default=50)
norm = Histogram normalization (eg False, 100), (default=1.0)
weights = list or numpy array of the same dimention as x_data to
weight each x point contribution. (default=None)
cum = Cumulative or not? (default=False)
htype = Histogram type: bar, barstacked, step, stepfilled
(default="bar")
align = Bar alignment: left, mid, right (default="mid")
rwidth = Specifies the bar width for htype=bar,barstacked
(default=None)
n_label = y-axis label
xmin = minimum value for x axis (default=None)
xmax = maximum value for x axis (default=None)
nmin = minimum value for y axis (default=None)
nmax = maximum value for y axis (default=None)
xinc = number of tick incriments for x variable (default 6)
ninc = number of tick incriments for y variable (default 6)
color = Color value (default="b", blue)
title = plot title (default is none)
tloc = title location: t=top, r=right, l=left, b=bottom
(default="t")
xl = Include x label (default is True)
xt = Include x ticks (default is True)
yl = Include y label (default is True)
yt = Include y ticks (default is True)
moments = Include moments (mean, standard deviation, skew,
kurtosis) of the distribution. The number corresponds
to the maximum moment that will be included. 3, for
example, will include the mean, standard deviation, and
skew. (default=4)
quartiles = Include quartiles (1st, 2nd=median, 3rd). 1=median only,
2=1st and 3rd only, 3=all (default=3)
modes = Include mode(s) (default=False)
sloc = Text location requires two specifiers. The first letter
may be i=inside plot, o=outside plot. The second letter
may be r=right, l=left, b=bottom, t=top. (default="il")
'''
# Add histogram to specified subplot
n,bins,patches=ax.hist(x_data, res, normed=norm, weights=weights,
cumulative=cum, histtype=htype, align=align,
rwidth=rwidth, color=color)
# Set the x, and y ranges if desired
if(xmin is None):
xmin = np.nanmin(x_data)
if(xmax is None):
xmax = np.nanmax(x_data)
if(nmin is None):
nmin = np.nanmin(n)
if(nmax is None):
nmax = np.nanmax(n)
# Configure axis
if yt:
width = (nmax - nmin) / ninc
if width > 0.0:
ytics = MultipleLocator(width)
ax.yaxis.set_major_locator(ytics)
if norm == 1.0:
ax.yaxis.set_major_formatter(FormatStrFormatter("%1.2f"))
elif norm == 100.0:
ax.yaxis.set_major_formatter(FormatStrFormatter("%3.1f"))
else:
ax.yaxis.set_major_formatter(FormatStrFormatter(""))
if yl:
ax.set_ylabel(n_label)
plt.ylim(nmin, nmax)
if xt:
width = (xmax - xmin) / xinc
if width > 0.0:
xtics = MultipleLocator(width)
ax.xaxis.set_major_locator(xtics)
else:
ax.xaxis.set_major_formatter(FormatStrFormatter(""))
if xl:
ax.set_xlabel(r'%s ($%s$)' % (x_name, x_units))
plt.xlim(xmin, xmax)
# Set the title
if title:
rot = 'horizontal'
yloc = 1.02
xloc = 0.5
if tloc == "b":
yloc = -.1
elif tloc == "t":
yloc = .99
else:
rot = 'vertical'
yloc = 0.5
xloc = -.2
if tloc == "r":
xloc = 1.1
title = ax.set_title(title, x=xloc, y=yloc, size='medium', rotation=rot)
# Add the statistics, if desired
s, st = add_stat_box(ax, x_data, x_units, moments=moments,
quartiles=quartiles, modes=modes, loc=sloc)
return(s, st)
root_path = os.path.dirname(os.path.abspath('__file__'))
# root_path = os.path.abspath(os.path.join(root_path,os.path.pardir)) # For run in CMD
graphs_path = root_path + '/results_analysis/graphs/'
huxian_vmd = pd.read_csv(root_path + '/Huaxian_vmd/data/VMD_TRAIN_K9.csv')
xianyang_vmd = pd.read_csv(root_path + '/Xianyang_vmd/data/VMD_TRAIN_K9.csv')
zhangjiashan_vmd = pd.read_csv(root_path +
'/Zhangjiashan_vmd/data/VMD_TRAIN_K8.csv')
T = huxian_vmd.shape[0]
t = np.arange(start=1, stop=T + 1, step=1, dtype=np.float) / T
freqs = t - 0.5 - 1 / T
plt.figure(figsize=(3.54, 2.0))
ax1 = plt.subplot(2, 2, 1)
ax1.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
# plt.xlabel('Time(month)')
plt.ylabel(r'$S_8$')
plt.plot(huxian_vmd['IMF8'], color='b', label='', linewidth=0.8)
plt.subplot(2, 2, 2)
# plt.title('IMF8',loc='left')
plt.plot(freqs, abs(fft(huxian_vmd['IMF8'])), c='b', lw=0.8)
plt.ylabel('Amplitude')
plt.subplot(2, 2, 3)
plt.xlabel('Time(month)')
plt.ylabel(r'$S_9$')
plt.plot(huxian_vmd['IMF9'], color='b', label='', linewidth=0.8)
plt.subplot(2, 2, 4)
def PlotOutlier(data, unit_period_length, img_save_path, boundary):
num_period = int(len(data) / unit_period_length)
print(num_period)
#actually not every period has meaningful data which makes a need to filter out some undesired data periods in calculating mean and std
valid_start_idx, valid_end_idx = int(num_period * 0.1), int(num_period *
0.4)
######
skew_list = []
kurtosis_list = []
std_list = []
for period_idx in range(num_period):
skew_list.append(
skew(data[period_idx * unit_period_length:(period_idx + 1) *
unit_period_length]))
kurtosis_list.append(
kurtosis(data[period_idx * unit_period_length:(period_idx + 1) *
unit_period_length]))
std_list.append(data[period_idx * unit_period_length:(period_idx + 1) *
unit_period_length].max())
sk_uppder, sk_lower = np.array(
skew_list
)[valid_start_idx:valid_end_idx].mean(
) + boundary * np.array(skew_list)[valid_start_idx:valid_end_idx].std(
), np.array(skew_list)[valid_start_idx:valid_end_idx].mean(
) - boundary * np.array(skew_list)[valid_start_idx:valid_end_idx].std()
kur_uppder, kur_lower = np.array(kurtosis_list)[
valid_start_idx:valid_end_idx].mean() + boundary * np.array(
kurtosis_list)[valid_start_idx:valid_end_idx].std(), np.array(
kurtosis_list)[valid_start_idx:valid_end_idx].mean(
) - boundary * np.array(
kurtosis_list)[valid_start_idx:valid_end_idx].std()
std_uppder, std_lower = np.array(
std_list)[valid_start_idx:valid_end_idx].mean(
) + boundary * np.array(std_list)[valid_start_idx:valid_end_idx].std(
), np.array(std_list)[valid_start_idx:valid_end_idx].mean(
) - boundary * np.array(std_list)[valid_start_idx:valid_end_idx].std()
fig, ax = plt.subplots()
#plot the patterns in a given data sequence
ax.plot(data)
#mark the std of each data period in scatter plot
#boundary: 96% trust region
ax.scatter(range(50, 50 + unit_period_length * num_period,
unit_period_length),
std_list,
color='g',
label='STD')
ax.hlines(np.array(std_list)[valid_start_idx:valid_end_idx].mean(),
xmin=0,
xmax=len(data),
colors='g')
ax.hlines(std_lower,
xmin=0,
xmax=len(data),
colors='g',
linestyles='dashed')
ax.hlines(std_uppder,
xmin=0,
xmax=len(data),
colors='g',
linestyles='dashed')
ax.set_yticks([data.min(), data.max()])
#ax.set_xlim([0, 3000])
#kurtosis
ax2 = ax.twinx()
ax2.scatter(range(50, 50 + unit_period_length * num_period,
unit_period_length),
kurtosis_list,
color='r')
ax.scatter(50, kurtosis_list[0], color='r', label='Kurtosis')
ax2.hlines(np.array(kurtosis_list)[valid_start_idx:valid_end_idx].mean(),
xmin=0,
xmax=len(data),
colors='r')
ax2.hlines(kur_uppder,
xmin=0,
xmax=len(data),
colors='r',
linestyles='dashed')
ax2.hlines(kur_lower,
xmin=0,
xmax=len(data),
colors='r',
linestyles='dashed')
#skewness
ax2.scatter(range(50, 50 + unit_period_length * num_period,
unit_period_length),
skew_list,
color='c')
ax.scatter(50, skew_list[0], color='c', label='Skewness')
ax2.hlines(np.array(skew_list)[valid_start_idx:valid_end_idx].mean(),
xmin=0,
xmax=len(data),
colors='c')
ax2.hlines(sk_uppder,
xmin=0,
xmax=len(data),
colors='c',
linestyles='dashed')
ax2.hlines(sk_lower,
xmin=0,
xmax=len(data),
colors='c',
linestyles='dashed')
ax.legend()
valid_img_save_path = os.path.join(img_save_path, 'valid_cycle')
if not os.path.exists(valid_img_save_path):
os.makedirs(valid_img_save_path)
plt.savefig(os.path.join(valid_img_save_path, str(user_idx) + '.png'))
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(skew_list, kurtosis_list, std_list)
sk_range = [sk_lower, sk_uppder]
kur_range = [kur_lower, kur_uppder]
std_range = [std_lower, std_uppder]
def x_y_edge(x_range, y_range, z_range):
xx, yy = np.meshgrid(x_range, y_range)
for value in [0, 1]:
output = np.array([z_range[value]] * 4).reshape(2, 2)
ax.plot_wireframe(xx, yy, output, color="r")
def y_z_edge(x_range, y_range, z_range):
yy, zz = np.meshgrid(y_range, z_range)
for value in [0, 1]:
output = np.array([x_range[value]] * 4).reshape(2, 2)
ax.plot_wireframe(output, yy, zz, color="r")
def x_z_edge(x_range, y_range, z_range):
xx, zz = np.meshgrid(x_range, z_range)
for value in [0, 1]:
output = np.array([y_range[value]] * 4).reshape(2, 2)
ax.plot_wireframe(xx, output, zz, color="r")
x_y_edge(sk_range, kur_range, std_range)
y_z_edge(sk_range, kur_range, std_range)
x_z_edge(sk_range, kur_range, std_range)
ax.set_xticks(np.linspace(min(skew_list), max(skew_list), 4))
ax.set_yticks(np.linspace(min(kurtosis_list), max(kurtosis_list), 4))
ax.set_zticks(np.linspace(min(std_list), max(std_list), 4))
ax.xaxis.set_major_formatter(FormatStrFormatter('%.2f'))
ax.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.2f'))
ax.set_xlabel('Skew', fontsize=15)
ax.set_ylabel('Kurtosis', fontsize=15)
ax.set_zlabel('STD', fontsize=15)
ax.xaxis.set_tick_params(labelsize=12)
ax.yaxis.set_tick_params(labelsize=12)
ax.zaxis.set_tick_params(labelsize=12)
plt.tight_layout()
plt.savefig(os.path.join(valid_img_save_path, str(user_idx) + '_3D.png'))
plt.close()
def plot_posterior_single(miso_f,
axvar,
posterior_bins,
showXaxis=True,
showYaxis=True,
show_ylabel=True,
font_size=6,
bar_posterior=False):
"""
Plot a posterior probability distribution for a MISO event.
"""
posterior_bins = int(posterior_bins)
psis = []
for line in open(miso_f):
if not line.startswith("#") and not line.startswith("sampled"):
psi, logodds = line.strip().split("\t")
psis.append(float(psi.split(",")[0]))
ci = .95
alpha = 1 - ci
lidx = int(round((alpha / 2) * len(psis)) - 1)
# the upper bound is the (1-alpha/2)*n nth smallest sample, where n is
# the number of samples
hidx = int(round((1 - alpha / 2) * len(psis)) - 1)
psis.sort()
clow, chigh = [psis[lidx], psis[hidx]]
nyticks = 4
if not bar_posterior:
y, x, p = hist(psis, linspace(0, 1, posterior_bins),\
normed=True, facecolor='k', edgecolor='w', lw=.2)
axvline(clow,
ymin=.33,
linestyle='--',
dashes=(1, 1),
color='#CCCCCC',
lw=.5)
axvline(chigh,
ymin=.33,
linestyle='--',
dashes=(1, 1),
color='#CCCCCC',
lw=.5)
axvline(mean(psis), ymin=.33, color='r')
ymax = max(y) * 1.5
ymin = -.5 * ymax
# "$\Psi$ = %.2f\n$\Psi_{0.05}$ = %.2f\n$\Psi_{0.95}$ = %.2f" %\
text(1, ymax,
"$\Psi$ = %.2f\n[%.2f, %.2f]" % \
(mean(psis), clow, chigh),
fontsize=font_size,
va='top',
ha='left')
ylim(ymin, ymax)
axvar.spines['left'].set_bounds(0, ymax)
axvar.spines['right'].set_color('none')
axvar.spines['top'].set_color('none')
axvar.spines['bottom'].set_position(('data', 0))
axvar.xaxis.set_ticks_position('bottom')
axvar.yaxis.set_ticks_position('left')
if showYaxis:
yticks(linspace(0, ymax, nyticks),\
["%d"%(y) for y in linspace(0, ymax, nyticks)],\
fontsize=font_size)
else:
yticks([])
if show_ylabel:
ylabel("Frequency", fontsize=font_size, ha='right', va='center')
else:
##
## Plot a horizontal bar version of the posterior distribution,
## showing only the mean and the confidence bounds.
##
mean_psi_val = mean(psis)
clow_err = mean_psi_val - clow
chigh_err = chigh - mean_psi_val
errorbar([mean_psi_val], [1],
xerr=[[clow_err], [chigh_err]],
fmt='o',
ms=4,
ecolor='k',
markerfacecolor="#ffffff",
markeredgecolor="k")
text(1, 1,
"$\Psi$ = %.2f\n[%.2f, %.2f]" % \
(mean(psis), clow, chigh),
fontsize=font_size,
va='top',
ha='left')
yticks([])
# Use same x-axis for all subplots
# but only show x-axis labels for the bottom plot
xlim([0, 1])
psi_axis_fontsize = font_size - (font_size * 0.3)
xticks([0, .2, .4, .6, .8, 1], fontsize=psi_axis_fontsize)
if (not bar_posterior) and showYaxis:
axes_to_show = ['bottom', 'left']
else:
axes_to_show = ['bottom']
# Adjust x-axis to be lighter
axis_size = 0.2
tick_size = 1.2
axis_color = "k"
for shown_axis in axes_to_show:
if shown_axis in axvar.spines:
print "Setting color on %s axis" % (shown_axis)
axvar.spines[shown_axis].set_linewidth(axis_size)
axvar.xaxis.set_tick_params(size=tick_size, color=axis_color)
if showXaxis:
from matplotlib.ticker import FormatStrFormatter
majorFormatter = FormatStrFormatter('%g')
axvar.xaxis.set_major_formatter(majorFormatter)
[label.set_visible(True) for label in axvar.get_xticklabels()]
xlabel("MISO $\Psi$", fontsize=font_size)
show_spines(axvar, axes_to_show)
else:
show_spines(axvar, axes_to_show)
[label.set_visible(False) for label in axvar.get_xticklabels()]
R = np.matrix([[140.6324, 130.6976], [130.4807, 140.7038]])
Q = np.matrix([[2.1668, -0.0846, 0.4526, 1.3870, 0.6935],
[-0.0846, 2.0430, 0.8917, -0.7040, -0.3520],
[0.4526, 0.8917, 1.0000, 0.0000, 0.0000],
[1.3870, -0.7040, 0.0000, 2.0000, 1.0000],
[0.6935, -0.3520, 0.0000, 1.0000, 1.0000]]) * 1e-4
# kalman_filter = KalmanFilter(Q=Q, R=R)
kalman_filter = ExtendedKalmanFilter(Q=Q, R=R)
measured_positions, filtered_positions, errors, true_positions = run_filter(
kalman_filter, test_target, starting_point=None)
# Plot trajectories on top graph
ax1.scatter(*zip(*measured_positions), s=2, label='Измеренное положение')
ax1.plot(*zip(*filtered_positions),
linewidth=.6,
label='Отфильтрованное положение')
ax1.plot(*zip(*true_positions), linewidth=2, label='Истиное положение')
ax1.legend()
# Plot errors on bottom
ax2.plot(errors)
# Format output
ax2.set_yscale('log')
ax2.yaxis.set_major_formatter(FormatStrFormatter('%g'))
ax2.yaxis.set_minor_formatter(FormatStrFormatter('%g'))
ax2.tick_params(which='minor', labelsize=8)
ax2.grid(which='both')
# ax2.legend()
plt.show()
def plot_all_tr_val_nL_surface_XXXXXXXXX (nHs,nLs, aves_OMN, aves_OMN_tr):
# Plots the training and Validation score of a realization
N_neurons = len(aves_OMN)
X = np.array(nHs)
Y = np.array(nLs)
X, Y = np.meshgrid(X, Y)
# print X
# print Y
Z = mu.convert_to_matrix(aves_OMN).T
# Z2 = mu.convert_to_matrix(aves_OMN_tr).T
# Z = Z.flatten()
# print X.shape, Y.shape
# print Z.shape
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.gca(projection='3d')
""" VAL """
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
ax.set_zlim(np.min(Z.flatten()), np.max(Z.flatten()))
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
plt.xlabel('Hidden neurons')
plt.ylabel('Number of Layers')
fig.colorbar(surf, shrink=0.5, aspect=5)
""" TR """
# surf = ax.plot_surface(X, Y, Z2, rstride=1, cstride=1, cmap=cm.coolwarm,
# linewidth=0, antialiased=False)
#
# ax.set_zlim(np.min(Z2.flatten()), np.max(Z2.flatten()))
# ax.zaxis.set_major_locator(LinearLocator(10))
# ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
#
# plt.xlabel('Hidden neurons')
# plt.ylabel('Number of Layers')
# fig.colorbar(surf, shrink=0.5, aspect=5)
#
# plt.show()
#==============================================================================
# X = np.array(nHs)
# Y = np.array(nLs)
# # X, Y = np.meshgrid(nHs, nLs)
#
# print X
# print Y
# Z = convert_to_matrix(aves_OMN)
# # Z = Z.flatten()
#
# print X.shape, Y.shape
# print Z.shape
#
# from mpl_toolkits.mplot3d import Axes3D
# import matplotlib.pyplot as plt
#
#
# fig = plt.figure()
# ax = fig.add_subplot(111, projection='3d')
#
# for x in range(X.size):
# for y in range(Y.size):
# ax.scatter(X[x], Y[y], Z[x,y])
#
# ax.set_xlabel('X Label')
# ax.set_ylabel('Y Label')
#==============================================================================
ax.set_zlabel('Z Label')
plt.show()
def plot_franke(x,
y,
franke_=False,
noise=False,
scalor=0.05,
method='ols',
seed1=8172,
lambda_=0.005,
absolute_error=False):
"""
Plots the franke function.Franke's function has two Gaussian peaks of different heights,
and a smaller dip. It is used as a test function in interpolation problems.
The function is evaluated on the square xi ∈ [0, 1], for all i = 1, 2.
Reference: Franke, R. (1979). A critical comparison of some methods for interpolation of
scattered data (No. NPS53-79-003). NAVAL POSTGRADUATE SCHOOL MONTEREY CA.
Arguments:
x: 1-dimensional numpy array (1D np.array)
y: 1-dimensional numpy array (1D np.array)
franke_: binary argument with inputs True/False. If 'True', plots the franke function
noise: binary argument with inputs True/False. If 'True', plots the franke function with added noise.
Activated only when franke_ == True.
scalor: float type, controls the amount of noise to be added to the franke function. Activated only when
noise == True.
method: character input accepting 'ols', 'ridge', 'lasso'. Plots the corresponding model fit.
seed1: float type. used for reproducable output
lambda_: float type. Activated only when method = 'ridge' or 'lasso'. Controls the amount of shrinkage of the
parameters. Higher number indicates higher shrinkage.
absolute_error: Binary type with inputs True/False. If 'True', outputs a plot of absolute deviation of the true
franke values and the fit of the corresponding model. Activated only when method is either 'ols',
'ridge' or 'lasso
"""
x, y = np.meshgrid(x, y)
f = franke(x, y) ##true franke values
if (noise): ##noisy franke values
f = franke(x, y) + scalor * np.random.normal(0, 1, franke(x, y).shape)
if method == 'ols': ##fit and predict ols
np.random.seed(seed1)
x_new = np.random.rand(500)
y_new = np.random.rand(500)
xn = x_new.ravel()
yn = y_new.ravel()
fn = franke(xn, yn)
X = designMatrix(xn, yn)
scaler = StandardScaler()
scaler.fit(X)
X = scaler.transform(X)
X[:, 0] = 1
linreg = linregOwn(method='ols')
beta = linreg.fit(X, fn)
xnew = np.linspace(0, 1, np.size(x_new))
ynew = np.linspace(0, 1, np.size(x_new))
Xnew, Ynew = np.meshgrid(xnew, ynew)
F_true = franke(Xnew, Ynew)
xn = Xnew.ravel()
yn = Ynew.ravel()
xb_new = designMatrix(xn, yn)
scaler = StandardScaler()
scaler.fit(xb_new)
xb_new = scaler.transform(xb_new)
xb_new[:, 0] = 1
f_predict = np.dot(xb_new, beta)
F_predict = f_predict.reshape(F_true.shape)
if method == 'ridge': ##fit and predict ridge
np.random.seed(seed1)
x_new = np.random.rand(500)
y_new = np.random.rand(500)
xn = x_new.ravel()
yn = y_new.ravel()
fn = franke(xn, yn)
X = designMatrix(xn, yn)
scaler = StandardScaler()
scaler.fit(X)
X = scaler.transform(X)
X[:, 0] = 1
linreg = linregOwn(method='ridge')
beta = linreg.fit(X, fn, lambda_=0.1)
xnew = np.linspace(0, 1, np.size(x_new))
ynew = np.linspace(0, 1, np.size(x_new))
Xnew, Ynew = np.meshgrid(xnew, ynew)
F_true = franke(Xnew, Ynew)
xn = Xnew.ravel()
yn = Ynew.ravel()
xb_new = designMatrix(xn, yn)
scaler = StandardScaler()
scaler.fit(xb_new)
xb_new = scaler.transform(xb_new)
xb_new[:, 0] = 1
f_predict = np.dot(xb_new, beta)
F_predict = f_predict.reshape(F_true.shape)
if method == 'lasso': ##fit and predict lasso
np.random.seed(seed1)
x_new = np.random.rand(500)
y_new = np.random.rand(500)
xn = x_new.ravel()
yn = y_new.ravel()
fn = franke(xn, yn)
X = designMatrix(xn, yn)
scaler = StandardScaler()
scaler.fit(X)
X = scaler.transform(X)
X[:, 0] = 1
linreg = linregOwn(method='lasso')
beta = linreg.fit(X, fn, lambda_=0.1)
xnew = np.linspace(0, 1, np.size(x_new))
ynew = np.linspace(0, 1, np.size(x_new))
Xnew, Ynew = np.meshgrid(xnew, ynew)
F_true = franke(Xnew, Ynew)
xn = Xnew.ravel()
yn = Ynew.ravel()
xb_new = designMatrix(xn, yn)
scaler = StandardScaler()
scaler.fit(xb_new)
xb_new = scaler.transform(xb_new)
xb_new[:, 0] = 1
f_predict = np.dot(xb_new, beta)
F_predict = f_predict.reshape(F_true.shape)
#Plot the Franke Function
fig = plt.figure()
ax = fig.gca(projection='3d') ##get current axis
## antialiased controls the transparency of the surface
if method == 'ols':
if absolute_error == True:
surf = ax.plot_surface(Xnew,
Ynew,
abs(F_predict - F_true),
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
else:
surf = ax.plot_surface(Xnew,
Ynew,
F_predict,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
if method == 'ridge':
if absolute_error == True:
surf = ax.plot_surface(Xnew,
Ynew,
abs(F_predict - F_true),
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
else:
surf = ax.plot_surface(Xnew,
Ynew,
F_predict,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
if method == 'lasso':
if absolute_error == True:
surf = ax.plot_surface(Xnew,
Ynew,
abs(F_predict - F_true),
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
else:
surf = ax.plot_surface(Xnew,
Ynew,
F_predict,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
#Customize z axis
if franke_ == True:
surf = ax.plot_surface(x,
y,
f,
cmap='coolwarm',
linewidth=0,
antialiased=False) ## colormap is coolwarm,
ax.set_title('Franke function without noise')
if (noise):
ax.set_title('Franke function with noise')
ax.set_zlim(-0.10, 1.4)
ax.zaxis.set_major_locator(LinearLocator(5))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
ax.view_init(30, 45)
#Labeling axes and title
if method == 'ols':
ax.set_title('OLS Fit')
if method == 'ridge':
ax.set_title('Ridge Fit')
if method == 'lasso':
ax.set_title('Lasso Fit')
ax.set_xlabel('X')
ax.set_ylabel('Y')
#Add colour bar
fig.colorbar(surf, shrink=0.5, aspect=0.5)
#plt.savefig(os.path.join(os.path.dirname(__file__), 'Plots', 'franke_abs_lasso.png'), transparent=True, bbox_inches='tight')
return plt.show()
grid_ax.spines["top"].set_visible(False)
grid_ax.spines["right"].set_visible(False)
grid_ax.spines["left"].set_visible(False)
grid_ax.spines["bottom"].set_visible(False)
sca(grid_ax)
ylabel('Grid')
xlim(x_min, x_max)
## Classification graph formatting:
sca(class_ax)
xlim(x_min, x_max)
ylabel("$p_i$")
ylim(0.1, 0.7)
xticks(grid_radii)
class_ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
yticks([0.2, 0.3, 0.4, 0.5, 0.6])
class_ax.tick_params(axis='x', which='minor', bottom='off', top="off")
class_ax.xaxis.set_ticklabels([])
sca(temp_ax)
xlim(x_min, x_max)
temp_ax.invert_yaxis()
ylabel("$\\beta$")
ylim(0.8, -0.8)
locator_params(axis='y', nbins=4)
temp_ax.tick_params(axis='x', which='minor', bottom='off', top="off")
axhline(y=0, c='k', ls='--', zorder=-1)
xticks(grid_radii)
temp_ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
temp_ax.xaxis.set_ticklabels([])
def main():
print(sys.version_info[0])
# METHODS being benchmarked -- Add new METHOD[S] here
if sys.version_info[0] >= 3:
#methods = ["lapjv_lapjv", "lap_lapjv", "scipy", "lapsolver", "hungarian", "munkres", "laptools_clap"]
methods = [
"lapjv_lapjv", "lap_lapjv", "scipy", "lapsolver", "laptools_clap",
"munkres"
]
else:
methods = ["lap_lapjv", "scipy", "hungarian", "munkres"]
minimum = int(np.floor(np.log2(args.min))) # 2^min = 8x8 cost matrix
maximum = int(np.ceil(np.log2(args.max))) # 2^max
ncyc = int(args.ncyc) # number of cycle
# LIMITS - add limit for new METHOD[S] here
# The size of the matrix to be solved is limited to 2^{limit['method']}
# for each method to ensure quick termination of the benchmarking
# exercise. Munkres and Scipy are considerably slower, making it
# necessary to limit them to smaller
# matrices
limit = {}
limit['munkres'] = min(7, maximum)
#limit['hungarian'] = min(12,maximum)
limit['scipy'] = maximum
limit['lap_lapjv'] = maximum
limit['lapjv_lapjv'] = maximum
limit['lapsolver'] = maximum
limit['laptools_clap'] = maximum
print("Solving matrices of sizes up to 2^{n} where n is " + str(limit))
# arrays to store data
t_methods = ["t_" + i for i in methods]
for i in range(len(methods)):
t_methods[i] = np.empty((0, 2), float)
label_methods = ["label_" + i for i in methods]
run_methods = ["run_" + i for i in methods]
base = 2 # will build matrices of size base^n and solve them
# for matrices of size 2^{min} - 2^{max}
for i in range(minimum, maximum):
matrix_size = pow(base, i)
print(("\n\n" + str(matrix_size) + " x " + str(matrix_size) + " ... "))
methods_data = np.zeros(len(methods), float)
# Generate n_cyc random matrices and solve them using different methods
for j in range(ncyc):
cost_matrix = matrix_size * \
np.random.random((matrix_size, matrix_size))
#cost_matrix=mat.astype(str(datatype))
#cost_matrix=recast_mat(mat, str(datatype))
#print((str(j) + " "), end=" ")
print("\nCycle ", (str(j) + " "), end=' ')
# print("\n")
# print(cost_matrix)
for method in range(len(methods)):
# print '%20s\t' %(methods[method])
if methods[method] == 'munkres' and i <= limit[
methods[method]]:
methods_data[method] += run_munkres(
cost_matrix, args.printcost)
elif methods[method] == 'scipy' and i <= limit[
methods[method]]:
real_time = run_scipy(cost_matrix, args.printcost)
methods_data[method] += real_time
elif methods[method] == 'hungarian' and i <= limit[
methods[method]]:
methods_data[method] += run_hungarian(
cost_matrix, args.printcost)
elif methods[method] == 'lap_lapjv' and i <= limit[
methods[method]]:
methods_data[method] += run_lap_lapjv(
cost_matrix, args.printcost)
elif methods[method] == 'lapjv_lapjv' and i <= limit[
methods[method]]:
methods_data[method] += run_lapjv_lapjv(
cost_matrix, args.printcost)
elif methods[method] == 'lapsolver' and i <= limit[
methods[method]]:
methods_data[method] += run_lapsolver(
cost_matrix, args.printcost)
elif methods[method] == 'laptools_clap' and i <= limit[
methods[method]]:
methods_data[method] += run_laptools_clap(
cost_matrix, args.printcost)
# If you want to benchmark a new METHOD, add another ELIF statement here
else:
pass
# average the timing information from n_cyc cycles
for method in range(len(methods)):
if methods_data[
method] != 0: # to make sure there is timing information
t_methods[method] = np.append(
t_methods[method],
np.array([[matrix_size, methods_data[method] / ncyc]]),
axis=0)
#Print version information
print("\n\nPackage Versions for the current run")
print("Python - ", sys.version)
for method in methods:
tmp = method.split("_")
# hungarian and lapjv don't print version numbers
if tmp[0] != 'hungarian':
if tmp[0] != 'lapjv':
ptmp = __import__(tmp[0])
method_version = ptmp.__version__
print(tmp[0], " - ", ptmp.__version__)
# print timing information to screen
dimensions = t_methods[0][:, [0]]
dimensions = dimensions.flatten()
print("\n")
print(" %12s " % ("Matrix_size"), end=" ")
np.set_printoptions(suppress=True, precision=5, linewidth=100)
for i in range(len(dimensions)):
print('%6d ' % (dimensions[i]), end=" ")
print(" ")
np.set_printoptions(suppress=True, precision=5, linewidth=100)
for method in range(len(methods)):
print('%12s ' % (methods[method]), end=" ")
timings = t_methods[method][:, [1]]
timings = timings.flatten()
print(timings)
# generate a plot (by default), unless 'no plot' option is selection
if args.noplot:
pass
else:
markers = []
markers = ['o', 'v', 's', 'D', 'P', '+', '*', '0', '1', '2']
marker_size = [50]
fig, ax = plt.subplots()
for method in range(len(methods)):
plt.scatter(t_methods[method][:, [0]],
t_methods[method][:, [1]],
s=marker_size,
label=methods[method],
marker=markers[method])
plt.loglog(t_methods[method][:, [0]],
t_methods[method][:, [1]],
basex=2,
basey=10)
plt.grid(True, which="both")
ax.xaxis.set_major_formatter(FormatStrFormatter('%d'))
plt.xlabel('Matrix dimension (2^n)', fontsize=18)
plt.ylabel('Real time to solution (seconds)', fontsize=18)
plt.title('Time to solve LAPs using different modules', fontsize=20)
plt.legend(fontsize=14)
fig_filename = "timing-LAPs-py3-" + \
str(pow(2, minimum)) + "-" + str(pow(2, maximum)) + ".png"
print("Figure saved to file %18s" % (fig_filename))
fig.set_size_inches(11, 8.5)
plt.savefig(fig_filename, bbox_inches='tight', dpi=150)
if args.showplot:
plt.show()
#tics inside
axarr[y].tick_params(direction='in', which='both', top=1, right=1)
#minor tics
axarr[y].xaxis.set_minor_locator(AutoMinorLocator())
axarr[y].yaxis.set_minor_locator(AutoMinorLocator())
#labels and tics font size
for item in ([axarr[y].xaxis.label, axarr[y].yaxis.label] + axarr[y].get_xticklabels() + axarr[y].get_yticklabels()):
item.set_fontsize(8)
# subplot numbering
# if y < nploty - nemptyplots or x < (nplotx - 1):
# axarr[y].text(0.8, 0.9, labeldict[y + x*nploty], fontsize=8, transform=axarr[y].transAxes)
axarr[y].text(0.05, 0.85, labeldict[y], fontsize=8, transform=axarr[y].transAxes)
axarr[1].set_ylabel('')
axarr[2].set_ylabel('')
axarr[0].yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
#axarr[1].yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
#axarr[2].yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
axarr[1].yaxis.set_major_formatter(NullFormatter())
axarr[2].yaxis.set_major_formatter(NullFormatter())
axarr[0].xaxis.set_major_locator(MaxNLocator(integer=True))
## show legends
#for x in np.arange(nplotx):
# for y in np.arange(nploty):
# axarr[x,y].legend(loc="upper center")
#single legend for the whole figure
handles, labels = axarr[1].get_legend_handles_labels()
lgd = fig.legend(handles, labels, handlelength=4, loc='lower center', bbox_to_anchor=(0.45,0))
zorder=8,
label=r"Box")
#mark_inset(ax2, ax3, loc1=3, loc2=1, fc="none", ec='0.5') # Mark the region corresponding to the inset
# add this for consistent representation of images in ax1 to ax3
# ax1.set_aspect('equal')
# ax2.set_aspect('equal')
# ax3.set_aspect('equal')
# hack: aspect=equal is default for imshow, but destroys my gridspec
ax1.set_aspect('auto')
ax2.set_aspect('auto')
ax3.set_aspect('auto')
# plot common colour bar
axc = plt.axes([0.76, 0.515, 0.035, 0.355])
fmt = FormatStrFormatter('%4.1f')
cb1 = plt.colorbar(im1, cax=axc, format=fmt, orientation="vertical")
cb1.ax.set_ylabel(r"$C_{u^{\prime}_{z}\Pi_{<0}}$")
cb1.set_ticks([-amcc, 0.0, +amcc])
axc.axhline(y=-clm,
color=Vermillion) # mark negative contour level in colourbar
axc.axhline(y=+clm, color=Blue) # mark positive contour level in colourbar
# plot mode interactive or pdf
if plot != 2:
#plt.tight_layout()
plt.show()
else:
#fig.tight_layout()
fnam = str.replace(fnam, '.dat', '.pdf')
fnam = str.replace(fnam, 'piCorrThZStreaksBox2d',
s_arr["lon"],
s_arr["lat"] + 0.004,
s_arr["station"][2:],
horizontalalignment="center",
verticalalignment="baseline",
fontdict={"size": fs},
)
im = plt.imread(image_fn)
ax.imshow(im,
aspect="equal",
origin="upper",
extent=(-119.11, -118.75, 37.8, 37.95)) #
ax.set_xlabel("Longitude (deg)", fontdict={"size": fs + 2, "weight": "bold"})
ax.set_ylabel("Latitude (deg)", fontdict={"size": fs + 2, "weight": "bold"})
ax.xaxis.set_major_formatter(FormatStrFormatter("%.2f"))
ax.yaxis.set_major_formatter(FormatStrFormatter("%.2f"))
ax.xaxis.set_major_locator(MultipleLocator(0.05))
ax.yaxis.set_major_locator(MultipleLocator(0.05))
# ax.grid(which='major', color=(.75, .75, .75), linewidth=.75)
ax.set_xlim(-119.11, -118.75)
ax.set_ylim(37.8, 37.95)
# for line in ax.lines:
# line.set_zorder(10)
plt.show()
fig.savefig(r"c:\Users\jpeacock-pr\Google Drive\JVG\mb_station_map.pdf",
dpi=300)
def plot_sat_gitm_comp(sat_datetime,
sat_data,
gtrack,
gkey,
skey,
tkey,
bkey,
title,
tmin=None,
tmax=None,
ymin=None,
ymax=None,
dmin=None,
dmax=None,
pmin=None,
pmax=None,
figname=None,
draw=True,
fsize=14,
sc='#0039A6',
gc='#ffcc00',
*args,
**kwargs):
'''
A routine to plot satellite and GITM data to show how a single physical
quantity varies over the orbit. Four panels are included; the top panel
shows the raw satellite data and the GITM data along the track. The second
panel shows the matched GITM/satellite data. The third panel shows the
difference between the satellite and GITM data. The fourth panel shows the
percent difference 100*(sat-GITM)/sat.
Input:
sat_datetime = Satellite datetime numpy array: dim(nsat,)
sat_data = Satelite data numpy array: dim(nsat,)
gtrack = GitmTime structure with GITM data along satellite
track and the matching satellite measurements
gkey = GITM data key
skey = Matched satellite data key
tkey = Matched satellite top errorbar key (or None)
bkey = Matched satellite bottom errorbar key (or None)
title = Plot title
tmin = UT Minimum (default None)
tmax = UT Maximum (default None)
ymin = Dependent variable minimum (default None)
ymax = Dependent variable maximum (default None)
dmin = Difference minimum (default None)
dmax = Difference maximum (default None)
pmin = Percent difference minimum (default None)
pmax = Percent difference maximum (default None)
figname = Output file name (must be .png, default None)
draw = Draw to screen? (default is True)
fsize = Font size (defualt=14)
sc = satellite color (default Michigan Blue)
gc = GITM color (default Michigan Maize)
'''
# Change fontsize, marker size, and line width
mpl.rc('xtick', labelsize=fsize)
mpl.rc('ytick', labelsize=fsize)
mpl.rc('font', size=fsize)
ms = 8
lw = 3
# Initialize the figure
f = plt.figure(figsize=(12, 12))
if not tmin:
tmin = gtrack['time'][0]
if not tmax:
tmax = gtrack['time'][-1]
# Create the first subplot, showing the raw satellite data and model data
ax1 = f.add_subplot(411)
con1 = ax1.plot_date(sat_datetime, sat_data, color=sc, fmt="-")
con1 = ax1.plot_date(gtrack['time'],
gtrack[gkey][:, 0, 0, 0],
fmt="o",
color=gc,
markersize=ms)
plt.xlim(tmin, tmax)
if type(ymin) is float and type(ymax) is float:
plt.ylim(ymin, ymax)
# Create the second subplot, showing the matched satellite and model data
ax2 = f.add_subplot(412)
con2 = ax2.plot_date(gtrack['time'],
gtrack[gkey][:, 0, 0, 0],
color=gc,
fmt="o",
markersize=ms)
if gtrack.has_key(tkey) and gtrack.has_key(bkey):
con2 = ax2.errorbar(
gtrack['time'],
gtrack[skey][:, 0, 0, 0],
yerr=[gtrack[bkey][:, 0, 0, 0], gtrack[tkey][:, 0, 0, 0]],
color=sc,
fmt="+",
markersize=ms,
linewidth=lw)
else:
con2 = ax2.plot_date(gtrack['time'],
gtrack[skey][:, 0, 0, 0],
color=sc,
marker="+",
markersize=ms,
linewidth=lw)
plt.xlim(tmin, tmax)
if type(ymin) is float and type(ymax) is float:
plt.ylim(ymin, ymax)
# Create the third subplot, showing the difference between the satellite
# and model data
ax3 = f.add_subplot(413)
sdiff = gtrack[skey][:, 0, 0, 0] - gtrack[gkey][:, 0, 0, 0]
szero = np.zeros(shape=gtrack['time'].shape)
if gtrack.has_key(tkey) and gtrack.has_key(bkey):
con3 = ax3.errorbar(
gtrack['time'],
sdiff,
yerr=[gtrack[bkey][:, 0, 0, 0], gtrack[tkey][:, 0, 0, 0]],
color=sc,
fmt="o",
markersize=ms,
linewidth=lw)
else:
con3 = ax3.plot_date(gtrack['time'],
sdiff,
color=sc,
fmt="o",
markersize=ms,
linewidth=lw)
con3 = ax3.plot_date(gtrack['time'], szero, "k-")
plt.xlim(tmin, tmax)
if type(dmin) is float and type(dmax) is float:
plt.ylim(dmin, dmax)
# Create the fourth subplot, showing the difference between the satellite
# and model data
ax4 = f.add_subplot(414)
sperc = 100.0 * sdiff / gtrack[skey][:, 0, 0, 0]
if gtrack.has_key(tkey) and gtrack.has_key(bkey):
bperc = 100.0 * gtrack[bkey][:, 0, 0, 0] / gtrack[skey][:, 0, 0, 0]
tperc = 100.0 * gtrack[tkey][:, 0, 0, 0] / gtrack[skey][:, 0, 0, 0]
con4 = ax4.errorbar(gtrack['time'],
sperc,
yerr=[bperc, tperc],
color=sc,
fmt="o",
markersize=ms,
linewidth=lw)
else:
con4 = ax4.plot_date(gtrack['time'],
sperc,
color=sc,
fmt="o",
markersize=ms,
linewidth=lw)
con4 = ax4.plot_date(gtrack['time'], szero, "k-")
plt.xlim(tmin, tmax)
if type(pmin) is float and type(pmax) is float:
plt.ylim(pmin, pmax)
# Set the labels, title, and tick intervals
f.suptitle(title)
ylabel1 = "{:s} (${:s}$)".format(gtrack[gkey].attrs['name'],
gtrack[gkey].attrs['units'])
ax1.set_ylabel(ylabel1)
ax2.set_ylabel(ylabel1)
ax3.set_ylabel("Obs$-$GITM {:s}".format(ylabel1))
ax4.set_ylabel(r"% Diff {:s}".format(ylabel1))
dtics, dmtics, dfmt = pybats.smart_timeticks(
[gtrack['time'][0], gtrack['time'][-1]])
ax1.xaxis.set_major_locator(dtics)
ax2.xaxis.set_major_locator(dtics)
ax3.xaxis.set_major_locator(dtics)
ax4.xaxis.set_major_locator(dtics)
ax1.xaxis.set_minor_locator(dmtics)
ax2.xaxis.set_minor_locator(dmtics)
ax3.xaxis.set_minor_locator(dmtics)
ax4.xaxis.set_minor_locator(dmtics)
xfmt1 = FormatStrFormatter("")
xfmt2 = FuncFormatter(gtrack.sat_dateloc_ticks)
ax1.xaxis.set_major_formatter(xfmt1)
ax2.xaxis.set_major_formatter(xfmt1)
ax3.xaxis.set_major_formatter(xfmt1)
ax4.xaxis.set_major_formatter(xfmt2)
gitm_time.set_sat_dateloc_label(ax4, gtrack.has_key("Magnetic Latitude"))
plt.subplots_adjust(hspace=0.1, top=.94, bottom=.2, right=.9)
# Output the plots to the screen and/or file as desired
if draw:
# Draw to screen.
if plt.isinteractive():
plt.draw() #In interactive mode, you just "draw".
else:
# W/o interactive mode, "show" stops the user from typing more
# at the terminal until plots are drawn.
plt.show()
# Save output file
if figname is not None:
plt.savefig(figname)
return f
s.shape[0] // 2 * spatial_sampling, s.shape[0])
return freq[s.shape[0] // 2:], s[s.shape[0] // 2:]
if __name__ == '__main__':
from matplotlib import pyplot as plt
from felpy.model.src.coherent import construct_SA1_pulse
from felpy.utils.vis_utils import Grids
from matplotlib.ticker import FormatStrFormatter
wfr = construct_SA1_pulse(512, 512, 2, 5, 1)
ef = wfr.as_complex_array().sum(-1)
ef *= np.random.rand(512, 512)
freq, s = power_spectral_density(ef,
spatial_sampling=wfr.dx,
pulse_duration=wfr.pulse_duration)
grid = Grids()
grid.create_grid(1, 1)
ax = grid.axes
ax.semilogy(freq, s)
ax.xaxis.set_major_formatter(FormatStrFormatter('%.e'))
ax.set_ylabel("Power Spectral Density (W$m^{-3}s^{-1}$)")
grid.set_fontsize(22)
for i, sf in enumerate(a):
rho = [500 / ccl.omega_x(c, sf, "matter") for c in cosmo]
mf = [ccl.massfunc(c, M, sf, overdensity=r) for c, r in zip(cosmo, rho)]
mfr[i] = mf[0] / mf[1]
mfr = np.array(mfr)
cmap = truncate_colormap(cm.Reds, 0.2, 1.0)
col = [cmap(i) for i in np.linspace(0, 1, len(a))]
fig, ax = plt.subplots()
ax.set_xlim(M.min(), M.max())
ax.axhline(y=1, ls="--", color="k")
[ax.loglog(M, R, c=c, label="%s" % red) for R, c, red in zip(mfr, col, z)]
ax.yaxis.set_major_formatter(FormatStrFormatter("$%.1f$"))
ax.yaxis.set_minor_formatter(FormatStrFormatter("$%.1f$"))
sm = plt.cm.ScalarMappable(cmap=cmap,
norm=plt.Normalize(vmin=z.min(), vmax=z.max()))
sm._A = []
cbar = fig.colorbar(sm)
ticks = cbar.get_ticks()
cbar.ax.invert_yaxis()
cbar.set_ticks(ticks[::-1])
ax.set_xlabel(r"$M_{500c} \mathrm{/ M_{\odot}}$", fontsize=17)
ax.set_ylabel(r"$n_{\mathrm{T}08}(M) / n_{\mathrm{T}10}(M)$", fontsize=17)
ax.tick_params(which="both", labelsize="large")
cbar.set_label("$z$", rotation=0, labelpad=15, fontsize=17)
text += "$MAE_{4}$ = {5:0.2f} $\pm$ {6:0.3f}"
text = text.format('{train}', MAE_train, MAE_train_std, '\n', '{test}',
MAE_test, MAE_test_std)
plt.text(0.62,
0.15,
text,
ha='center',
va='center',
fontsize=10,
bbox=dict(facecolor='w',
edgecolor='black',
boxstyle='round',
pad=1),
transform=ax.transAxes)
if i == 4:
ax.xaxis.set_major_formatter(FormatStrFormatter('%g'))
ax.xaxis.set_ticks(np.arange(-2.5, 2, 1))
ax.yaxis.set_major_formatter(FormatStrFormatter('%g'))
ax.yaxis.set_ticks(np.arange(-2.5, 2, 1))
'''
if i == 2:
ax.xaxis.set_major_formatter(FormatStrFormatter('%g'))
ax.xaxis.set_ticks(np.arange(-4, 4, 1))
ax.yaxis.set_major_formatter(FormatStrFormatter('%g'))
ax.yaxis.set_ticks(np.arange(-4, 4, 1))
'''
plt.subplots_adjust(left=0.1,
bottom=0.1,
right=0.9,
top=0.9,
wspace=0.3,
def plot_uc_histogram(self,
info_list,
legend_list,
extra_title=None,
xsize=10,
ysize=10,
high_vis=False,
iqr_ratio=1.5,
ranges=None,
title=None):
"""
Plot a 3x3 grid of plots showing unit cell dimensions.
@param info list of lists of dictionaries. The outer list groups seperate lists
of cells to be plotted in the same graph, where each dictionary describes one cell.
@param extra_title will be added to the title of the plot
@param xsize if class initialized with not interacive, this is the x size of the
plot to save in inches
@param ysize as xsize
@param iqr_ratio Inter-quartile range multiplier for rejecting outliers
@param ranges Limits for the a, b and c axes. Tuple of 6 doubles, low then high in pairs for each.
@return if not interactive, returns the path of the saved image, otherwise None
"""
if ranges is not None:
assert len(ranges) == 6
alim = ranges[0:2]
blim = ranges[2:4]
clim = ranges[4:6]
else:
alim = blim = clim = None
plot_ratio = max(min(xsize, ysize) / 2.5, 3)
if high_vis:
text_ratio = plot_ratio * 4
separator = "\n"
else:
text_ratio = plot_ratio * 3
separator = "\n"
# Initialize figure
fig = plt.figure(figsize=(xsize, ysize))
gsp = GridSpec(3, 4)
legend_sub_a = fig.add_subplot(gsp[3])
legend_sub_b = fig.add_subplot(gsp[7])
legend_sub_c = fig.add_subplot(gsp[11])
sub_ba = fig.add_subplot(gsp[0])
sub_cb = fig.add_subplot(gsp[1])
sub_ac = fig.add_subplot(gsp[2])
sub_a = fig.add_subplot(gsp[4])
sub_b = fig.add_subplot(gsp[5], sharey=sub_a)
sub_c = fig.add_subplot(gsp[6], sharey=sub_a)
sub_alpha = fig.add_subplot(gsp[8])
sub_beta = fig.add_subplot(gsp[9], sharey=sub_alpha)
sub_gamma = fig.add_subplot(gsp[10], sharey=sub_alpha)
total = 0
abc_hist_ylim = 0
legend_sub_a.axis('off')
legend_sub_b.axis('off')
legend_sub_c.axis('off')
for legend, info in zip(legend_list, info_list):
if len(info) == 0:
continue
# Extract uc dimensions from info list
a = flex.double([i['a'] for i in info])
b = flex.double([i['b'] for i in info])
c = flex.double([i['c'] for i in info])
alpha = flex.double([i['alpha'] for i in info])
beta = flex.double([i['beta'] for i in info])
gamma = flex.double([i['gamma'] for i in info])
if ranges is not None:
sel = (a >= alim[0]) & (a <= alim[1]) & (b >= blim[0]) & (
b <= blim[1]) & (c >= clim[0]) & (c <= clim[1])
a = a.select(sel)
b = b.select(sel)
c = c.select(sel)
alpha = alpha.select(sel)
beta = beta.select(sel)
gamma = gamma.select(sel)
accepted = flex.bool(len(a), True)
for d in [a, b, c, alpha, beta, gamma]:
outliers = self.reject_outliers(d, iqr_ratio)
accepted &= ~outliers
a = a.select(accepted)
b = b.select(accepted)
c = c.select(accepted)
alpha = alpha.select(accepted)
beta = beta.select(accepted)
gamma = gamma.select(accepted)
total += len(a)
nbins = int(np.sqrt(len(a))) * 2
n_str = "N: %d " % len(a)
from matplotlib.ticker import FormatStrFormatter
hists = []
for name, dimension, sub, lim in \
[('a', a, sub_a, alim), ('b', b, sub_b, blim), ('c', c, sub_c, clim)]:
stats = flex.mean_and_variance(dimension)
mean = stats.mean()
try:
stddev = stats.unweighted_sample_standard_deviation()
except RuntimeError:
raise Exception("Not enough data to produce a histogram")
varstr = "%.2f +/- %.2f" % (mean, stddev)
if len(legend) > 0:
dim_legend = legend + separator + varstr
else:
dim_legend = varstr
if len(info_list) > 1 and name == "a":
dim_legend = n_str + dim_legend
hist = sub.hist(dimension,
nbins,
alpha=0.75,
histtype='stepfilled',
label=dim_legend,
range=lim)
sub.set_xlabel("%s-edge (%s $\AA$)" %
(name, varstr)).set_fontsize(text_ratio)
xloc = plt.MaxNLocator(5)
if not high_vis:
sub.xaxis.set_major_locator(xloc)
sub.xaxis.set_major_formatter(FormatStrFormatter("%5.1f"))
if name == 'a':
sub.set_ylabel('Number of images').set_fontsize(text_ratio)
else:
self.plt.setp(sub.get_yticklabels(), visible=False)
hists.append(hist)
abc_hist_ylim = max(1.2 * max([max(h[0]) for h in hists]),
abc_hist_ylim)
sub_a.set_ylim([0, abc_hist_ylim])
for (n1, n2, d1, d2, lim1, lim2, sub) in \
[('a', 'b', a, b, alim, blim, sub_ba),
('b', 'c', b, c, blim, clim, sub_cb),
('c', 'a', c, a, clim, alim, sub_ac)]:
if len(info_list) == 1:
sub.hist2d(
d1,
d2,
bins=100,
range=[lim1, lim2] if ranges is not None else None)
else:
sub.plot(d1.as_numpy_array(),
d2.as_numpy_array(),
'.',
alpha=0.1,
markeredgewidth=0,
markersize=2)
if ranges is not None:
sub.set_xlim(lim1)
sub.set_ylim(lim2)
sub.set_xlabel("%s axis" % n1).set_fontsize(text_ratio)
sub.set_ylabel("%s axis" % n2).set_fontsize(text_ratio)
# plt.setp(sub.get_yticklabels(), visible=False)
for ax in (sub_a, sub_b, sub_c, sub_alpha, sub_beta, sub_gamma):
ax.tick_params(axis='both',
which='both',
left='off',
right='off')
ax.set_yticklabels([])
for ax in (sub_ba, sub_cb, sub_ac):
ax.tick_params(axis='both',
which='both',
bottom='off',
top='off',
left='off',
right='off')
ax.set_xticklabels([])
ax.set_yticklabels([])
for (name, angle, sub) in \
[(r'$\alpha$', alpha, sub_alpha),
(r'$\beta$', beta, sub_beta),
(r'$\gamma$', gamma, sub_gamma)]:
sub.hist(angle, nbins, alpha=0.75, histtype='stepfilled')
stats = flex.mean_and_variance(angle)
mean = stats.mean()
stddev = stats.unweighted_sample_standard_deviation()
sub.set_xlabel(r'%s (%.2f +/- %.2f$^\circ$)' %
(name, mean, stddev)).set_fontsize(text_ratio)
xloc = plt.MaxNLocator(5)
if not high_vis:
sub.xaxis.set_major_locator(xloc)
sub.xaxis.set_major_formatter(FormatStrFormatter("%5.1f"))
if name == '\alpha':
sub.set_ylabel('Number of images').set_fontsize(text_ratio)
else:
self.plt.setp(sub.get_yticklabels(), visible=False)
sub_b.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_b.xaxis.get_major_ticks()[-1].label1.set_visible(False)
sub_c.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_c.xaxis.get_major_ticks()[-1].label1.set_visible(False)
sub_ba.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_ba.xaxis.get_major_ticks()[-1].label1.set_visible(False)
sub_cb.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_cb.xaxis.get_major_ticks()[-1].label1.set_visible(False)
sub_ac.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_ac.xaxis.get_major_ticks()[-1].label1.set_visible(False)
sub_beta.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_beta.xaxis.get_major_ticks()[-1].label1.set_visible(False)
sub_gamma.xaxis.get_major_ticks()[0].label1.set_visible(False)
sub_gamma.xaxis.get_major_ticks()[-1].label1.set_visible(False)
h, l = sub_a.get_legend_handles_labels()
legend_sub_a.legend(h, l, fontsize=text_ratio)
h, l = sub_b.get_legend_handles_labels()
legend_sub_b.legend(h, l, fontsize=text_ratio)
h, l = sub_c.get_legend_handles_labels()
legend_sub_c.legend(h, l, fontsize=text_ratio)
# if len(legend_list) > 0:
# import matplotlib.patches as mpatches
# rgb_alphas = [a_hist[2][i] for i in range(len(a_hist[2]))]
# assert len(legend_list) == len(rgb_alphas)
# patches = [mpatches.Patch(
# color=rgb_alphas[i].get_facecolor(),
# label=legend_list[i])
# for i in range(len(rgb_alphas))]
# fig.legend(patches, 'upper right')
gsp.update(wspace=0)
if title is None: title = "Unit cell distribution"
fig.suptitle(title + " (%d xtals)" % total)
if not self.interactive:
fig.set_size_inches(xsize * 1.05 + .5, ysize * .95)
fig.savefig("ucell_tmp.png", bbox_inches='tight', dpi=100)
plt.close(fig)
return "ucell_tmp.png"
def plot_stability(xData=None,
xData_err=None,
data_datasets=None,
mc_datasets=None,
data_errorsets=None,
mc_errorsets=None,
label='',
category='',
path="",
evenX=False,
xVar='',
iovs=None,
showMC=False,
names=None,
style='ggplot',
oldStyle=False,
colours=None):
plt.style.use(style)
left, width = 0.1, 1.0
bottom, height = 0.1, 0.5
rect_hist = [left + width + 0.01, bottom, 0.2, height]
rect_plot = [left, bottom, width, height]
nullfmt = NullFormatter()
fig = plt.figure()
ax_plot = plt.axes(rect_plot)
ax_hist = plt.axes(rect_hist)
for k, spine in ax_plot.spines.items():
spine.set_zorder(10)
for k, spine in ax_hist.spines.items():
spine.set_zorder(10)
ax_hist.yaxis.set_major_formatter(nullfmt)
xPlaceholder = range(1, 1 + len(xData), 1)
for data_dataset, data_errorset, colour in zip(data_datasets,
data_errorsets, colours):
if evenX:
if oldStyle:
ax_plot.errorbar(xPlaceholder,
data_dataset,
yerr=data_errorset,
capthick=0,
marker='o',
ms=4,
c=colour,
ls='none')
else:
ax_plot.errorbar(xPlaceholder,
data_dataset,
yerr=data_errorset,
capthick=0,
marker='.',
ms=4,
ls='solid',
c=colour)
else:
if oldStyle:
ax_plot.errorbar(xData,
data_dataset,
yerr=data_errorset,
capthick=0,
marker='o',
ms=4,
c=colour,
ls='none')
else:
ax_plot.errorbar(xData,
data_dataset,
yerr=data_errorset,
capthick=0,
marker='.',
ms=4,
ls='solid',
c=colour)
# customise the axes
xDataVar = xData.name
if xDataVar == 'time':
ax_plot.xaxis.set_minor_locator(dates.DayLocator(interval=10))
ax_plot.xaxis.set_minor_formatter(dates.DateFormatter('%d\n%a'))
ax_plot.xaxis.set_major_locator(dates.MonthLocator())
ax_plot.xaxis.set_major_formatter(dates.DateFormatter('\n\n\n%b\n%Y'))
elif (xDataVar == 'run_max' or xDataVar == 'run_min') and not evenX:
majorLocator = MultipleLocator(125)
minorLocator = MultipleLocator(62.5)
ax_plot.xaxis.set_major_locator(majorLocator)
ax_plot.xaxis.set_minor_locator(minorLocator)
majorFormatter = FormatStrFormatter('%d')
ax_plot.xaxis.set_major_formatter(majorFormatter)
xlabels = ax_plot.get_xticklabels()
plt.setp(xlabels, rotation=90, fontsize=10)
elif (xDataVar == 'run_max' or xDataVar == 'run_min') and evenX:
majorLocator = MultipleLocator(2)
minorLocator = MultipleLocator(1)
ax_plot.xaxis.set_major_locator(majorLocator)
ax_plot.xaxis.set_minor_locator(minorLocator)
xlabels = ax_plot.get_xticks().tolist()
for i in range(2, len(xData), 2):
xlabels[i / 2 + 1] = xData.tolist()[i - 1]
for i in range(len(xlabels)):
if xlabels[i] < 200000: xlabels[i] = ''
for index, row in iovs.iterrows():
for j in range(0, len(xData) - 1):
if row['run'] >= xData[j] and row['run'] < xData[j + 1]:
if 'Run' in row['info']:
ax_plot.axvline(x=j + 1,
color='#EBAF3C',
ls='--',
zorder=5)
else:
ax_plot.axvline(x=j + 1,
color='#1072C3',
ls='--',
zorder=5)
ax_plot.set_xticklabels(xlabels)
xlabels = ax_plot.get_xticklabels()
plt.setp(xlabels, rotation=90, fontsize=10)
ax_plot.xaxis.grid(True, which="minor")
ax_plot.yaxis.grid()
ax_hist.xaxis.grid(True, which="minor")
ax_hist.yaxis.grid()
ax_hist.xaxis.set_ticks([])
#Get and set the limits for the histogram
ymin = 9999
ymax = -9999
for data_dataset, mc_dataset in zip(data_datasets, mc_datasets):
if (len(mc_dataset) > 0):
ymintemp = round(min(data_dataset.min(), mc_dataset.min())) - 1
ymaxtemp = round(max(data_dataset.max(), mc_dataset.max())) + 1
if ymintemp < ymin: ymin = ymintemp
if ymaxtemp > ymax: ymax = ymaxtemp
else:
ymintemp = round(data_dataset.min()) - 1
ymaxtemp = round(data_dataset.max()) + 1
if ymintemp < ymin: ymin = ymintemp
if ymaxtemp > ymax: ymax = ymaxtemp
ax_plot.set_ylim((ymin, ymax))
ax_hist.set_ylim((ymin, ymax))
ax_plot.set_ylabel(label)
nbin = 30
hmaxes = []
for data_dataset, colour in zip(data_datasets, colours):
y, _, _ = ax_hist.hist(data_dataset,
bins=nbin,
orientation='horizontal',
histtype='stepfilled',
alpha=0.5,
color=colour)
hmaxes.append(y.max())
hmax = max(hmaxes)
ax_hist.set_xlim((0, hmax * 1.1))
ax_plot.set_title(region_labels[category] + " " + label)
#Annotate with mean and std dev
step = 0.05
for data_dataset, name, colour in zip(data_datasets, names, colours):
npVals = np.asarray(data_dataset)
name_gap = ' ' * len(name)
ax_hist.annotate('{:s}:\n$\mu$ = {:3.3f}, $\sigma$ = {:3.3f}'.format(
name, np.mean(npVals), np.std(npVals)),
(hmax * 1.15, ymax - (ymax - ymin) * (0.1 + step)),
fontsize=11,
annotation_clip=False,
xycoords='data',
color=colour)
step += 0.14
#Add line for the MC
mc_dataset = mc_datasets[0]
mc_errorset = mc_errorsets[0]
if (len(mc_dataset) > 0):
if evenX:
if oldStyle:
ax_plot.errorbar(xPlaceholder,
mc_dataset,
yerr=mc_errorset,
capthick=0,
marker='o',
ms=4,
ls='solid',
c='Black')
else:
ax_plot.errorbar(xPlaceholder,
mc_dataset,
yerr=mc_errorset,
capthick=0,
marker='',
ms=4,
ls='dotted',
c='Black')
else:
if oldStyle:
ax_plot.errorbar(xData,
mc_dataset,
yerr=mc_errorset,
capthick=0,
marker='o',
ms=4,
ls='solid',
c='Black')
else:
ax_plot.errorbar(xData,
mc_dataset,
yerr=mc_errorset,
capthick=0,
marker='',
ms=4,
ls='dotted',
c='Black')
if evenX:
xNP = np.asarray(xPlaceholder)
else:
xNP = np.asarray(xData.tolist())
mcNP = np.asarray(mc_dataset.tolist())
mcErrNP = np.asarray(mc_errorset.tolist())
ax_plot.fill_between(xNP, mcNP - mcErrNP, mcNP + mcErrNP, alpha=0.5)
if xVar == '':
ax_hist.annotate(
'MC = {:3.3f} $\pm$ {:3.3f}'.format(mc_dataset[1],
mc_errorset[1]),
(hmax * 1.15, ymax - (ymax - ymin) * (0.05 + step)),
fontsize=11,
annotation_clip=False,
xycoords='data')
#Legend
legend = ax_plot.legend(loc='lower left', numpoints=1, prop={'size': 9})
if (len(mc_datasets[0]) > 0):
for i, name in enumerate(names):
legend.get_texts()[i].set_text(name)
legend.get_texts()[len(names)].set_text('MC')
else:
for i, name in enumerate(names):
legend.get_texts()[i].set_text(name)
legend.get_frame().set_alpha(0.5)
legend.get_frame().set_linewidth(0.0)
ax_hist.grid(which='major',
color='0.7',
linestyle='--',
dashes=(5, 1),
zorder=0)
ax_plot.grid(which='major',
color='0.7',
linestyle='--',
dashes=(5, 1),
zorder=0)
ax_plot.grid(which='minor',
color='0.85',
linestyle='--',
dashes=(5, 1),
zorder=0)
#Save
if evenX:
xDataVar = xDataVar + '_even'
if not os.path.exists(path + '/' + xDataVar):
os.makedirs(path + '/' + xDataVar)
fileName = category + '_' + re.sub(r'[\\@#$/{}^]', '', label)
fileName = re.sub(r'[ ]', '_', fileName)
for fType in format_fig_output:
print 'Saving plot: ' + path + xDataVar + '/' + fileName + '.' + fType
plt.savefig(path + xDataVar + '/' + fileName + '.' + fType,
format=fType,
orientation='landscape',
dpi=200,
papertype='a4',
pad_inches=0.1,
bbox_inches='tight')
plt.close(fig)
def main():
bar_colors = [
colors.cnames['hotpink'], colors.cnames['deepskyblue'],
colors.cnames['cornflowerblue']
]
bar_labels = ['optimized', 'fixed1', 'fixed2']
fig = plt.figure(figsize=(30, 10), dpi=220)
plt.subplots_adjust(wspace=0.4)
plt.rcParams['font.family'] = 'arial'
rc('font', weight='bold')
# 左のグラフの描画
plt.subplot(1, 3, 1)
method_num = 3
user_num = 2
raw_data = [[[] for i in range(user_num)] for j in range(method_num)]
data = [[] for i in range(method_num)]
yerr = [[] for i in range(method_num)]
with open('experiment_data.csv', 'r') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
for i in range(method_num):
for j in range(user_num):
raw_data[i][j].append(row[8 + i + j * method_num])
for i in range(method_num):
for q in raw_data[i]:
q_data = [int(x) for x in q]
data[i].append(statistics.mean(q_data))
yerr[i].append(
statistics.pstdev(q_data) / math.sqrt(len(q_data)))
x = np.arange(user_num)
bar_width = 0.2
plt.grid(which='major', axis='y', color='black', linestyle='--', alpha=0.3)
plt.tick_params(bottom=False)
for i in range(method_num):
plt.bar(x + i * bar_width,
data[i],
color=bar_colors[i],
width=bar_width,
yerr=yerr[i],
capsize=6,
label=bar_labels[i],
align='center')
plt.ylim([50, 90])
plt.gca().yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
plt.ylabel('Mean accuracy rate [%]', fontsize=44, weight='bold')
plt.yticks([50.00, 60.00, 70.00, 80.00, 90.00], fontsize=44)
plt.xlabel('(a)', fontsize=44, weight='bold')
plt.xticks(x + bar_width, ['main user', 'bystander'], fontsize=44)
plt.legend(bbox_to_anchor=(0.6, 1.2),
loc='upper left',
borderaxespad=0,
fontsize=44,
ncol=3)
# 中央のグラフの描画
plt.subplot(1, 3, 2)
raw_data = [[] for i in range(method_num)]
with open('experiment_data.csv', 'r') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
for i in range(method_num):
raw_data[i].append(int(row[14 + i]) / 1000)
data = []
yerr = []
for i in range(method_num):
data.append(statistics.mean(raw_data[i]))
yerr.append(
statistics.pstdev(raw_data[i]) / math.sqrt(len(raw_data[i])))
x = np.arange(method_num)
bar_width = 1.0
plt.grid(which='major', axis='y', color='black', linestyle='--', alpha=0.3)
plt.tick_params(bottom=False)
plt.bar(x,
data,
color=bar_colors,
width=bar_width,
yerr=yerr,
capsize=6,
align='center')
plt.ylim([130, 180])
plt.gca().yaxis.set_major_formatter(FormatStrFormatter('%d'))
plt.ylabel('Mean time [s]', fontsize=44, weight='bold')
plt.yticks([130, 140, 150, 160, 170, 180], fontsize=44)
dummy = ['a'] * method_num
plt.xlim([-3, 5])
plt.xlabel('(b)', fontsize=44, weight='bold')
plt.xticks(x, dummy, fontsize=44, color=colors.cnames['white'])
# 右のグラフの描画
plt.subplot(1, 3, 3)
raw_data = [[] for i in range(method_num)]
with open('experiment_data.csv', 'r') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
for i in range(method_num):
raw_data[i].append(int(row[17 + i]))
data = []
yerr = []
for i in range(method_num):
data.append(statistics.mean(raw_data[i]))
yerr.append(
statistics.pstdev(raw_data[i]) / math.sqrt(len(raw_data[i])))
plt.grid(which='major', axis='y', color='black', linestyle='--', alpha=0.3)
plt.tick_params(bottom=False)
plt.bar(x,
data,
color=bar_colors,
width=bar_width,
yerr=yerr,
capsize=6,
align='center')
plt.ylim([10, 50])
plt.gca().yaxis.set_major_formatter(FormatStrFormatter('%d'))
plt.ylabel('Mean # of item selections', fontsize=44, weight='bold')
plt.yticks([10, 20, 30, 40, 50], fontsize=44)
plt.xlim([-3, 5])
plt.xlabel('(c)', fontsize=44, weight='bold')
plt.xticks(x, dummy, fontsize=44, color=colors.cnames['white'])
add_asterisk(0, 2, x, bar_width, data, yerr)
add_asterisk(1, 2, x, bar_width, data, yerr)
output_file_name = 'task_variables_result.eps'
plt.savefig(output_file_name, bbox_inches='tight', pad_inches=0.2)
# latexでのずれを防ぐため，一度pdfにしてepsに戻すスクリプトを実行
subprocess.run(['./epsbound.sh', output_file_name])
def plot_data(self):
fig = 0
# plot data in two and one-d
if np.shape(self.x)[1] < 2:
# construct figure
fig, axs = plt.subplots(2, 1, figsize=(4, 4))
gs = gridspec.GridSpec(2, 1, height_ratios=[6, 1])
ax1 = plt.subplot(gs[0], aspect='equal')
ax2 = plt.subplot(gs[1], sharex=ax1)
# set plotting limits
xmax = copy.deepcopy(max(self.x))
xmin = copy.deepcopy(min(self.x))
xgap = (xmax - xmin) * 0.2
xmin -= xgap
xmax += xgap
ymax = max(self.y)
ymin = min(self.y)
ygap = (ymax - ymin) * 0.5
ymin -= ygap
ymax += ygap
### plot in 2-d
ax1.scatter(self.x,
self.y,
color='k',
edgecolor='w',
linewidth=0.9,
s=40)
# clean up panel
ax1.set_xlim([xmin, xmax])
ax1.set_ylim([ymin, ymax])
ax1.axhline(linewidth=0.5, color='k', zorder=1)
### plot in 1-d
ind0 = np.argwhere(self.y == +1)
ax2.scatter(self.x[ind0],
np.zeros((len(self.x[ind0]))),
s=55,
color=self.colors[0],
edgecolor='k',
zorder=3)
ind1 = np.argwhere(self.y == -1)
ax2.scatter(self.x[ind1],
np.zeros((len(self.x[ind1]))),
s=55,
color=self.colors[1],
edgecolor='k',
zorder=3)
ax2.set_yticks([0])
ax2.axhline(linewidth=0.5, color='k', zorder=1)
ax2.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax2.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
if np.shape(self.x)[1] == 2:
# construct figure
fig, axs = plt.subplots(1, 2, figsize=(9, 4))
# create subplot with 2 panels
gs = gridspec.GridSpec(1, 2)
ax2 = plt.subplot(gs[1], aspect='equal')
ax1 = plt.subplot(gs[0], projection='3d')
# scatter points
self.scatter_pts(ax1, self.x)
### from above
ax2.set_xlabel(r'$x_1$', fontsize=15)
ax2.set_ylabel(r'$x_2$', fontsize=15, rotation=0, labelpad=20)
ax2.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax2.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
# plot points in 2d and 3d
C = len(np.unique(self.y))
if C == 2:
ind0 = np.argwhere(self.y == +1)
ax2.scatter(self.x[ind0, 0],
self.x[ind0, 1],
s=55,
color=self.colors[0],
edgecolor='k')
ind1 = np.argwhere(self.y == -1)
ax2.scatter(self.x[ind1, 0],
self.x[ind1, 1],
s=55,
color=self.colors[1],
edgecolor='k')
else:
for c in range(C):
ind0 = np.argwhere(self.y == c)
ax2.scatter(self.x[ind0, 0],
self.x[ind0, 1],
s=55,
color=self.colors[c],
edgecolor='k')
self.move_axis_left(ax1)
ax1.set_xlabel(r'$x_1$', fontsize=12, labelpad=5)
ax1.set_ylabel(r'$x_2$', rotation=0, fontsize=12, labelpad=5)
ax1.set_zlabel(r'$y$', rotation=0, fontsize=12, labelpad=-3)
Vtt = (Vt * (rho * ik)) / (2 * np.pi * l)
print("Número de elementos por eje:", np.count_nonzero(Xa))
aa = np.where(np.amax(Vtt) == Vtt)
print("Valor máximo de tensión:", round(Vtt[::].max(),
3), "[V], en posición: (",
round(Xa[aa[0][0]], 2), ",", round(Ya[aa[1][0]], 2), ")")
bb = np.where(np.amin(Vtt) == Vtt)
print("Valor mínimo de tensión:", round(Vtt[::].min(),
3), "[V], en posición: (",
round(Xa[bb[0][0]], 2), ",", round(Ya[bb[1][0]], 2), ")")
print("Número de elemmentos de Vt:", np.count_nonzero(Vtt))
print("Elementos de Xa al cuadrado:", np.count_nonzero(Xa)**2)
X, Y = np.meshgrid(Xa, Ya)
print("Nuevo número de elementos de X y Y:", np.count_nonzero(X))
surf = axx.plot_surface(X,
Y,
Vtt,
cmap=cm.get_cmap("Spectral"),
linewidth=0,
antialiased=False)
# Customize the z axis.
axx.set_zlim(300, 1800)
axx.zaxis.set_major_locator(LinearLocator(10))
axx.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
# Add a color bar which maps values to colors.
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
def con_con_comparison(args):
"""
cross conservation comparison
:param args:
:return:
"""
rp = args.concon_reference # reference ligand name
prot = args.ligands[rp] # reference ligand
seq = prot.get_ref_seq() # reference ligand sequence
msta = args.msta # multiple structure alignment
msa = args.msa # multiple sequence alignment
contest = args.conservation_test # conservation test type
algtest = args.alignment_test # conservation for ligand alignment type
# data preparation
cs = pd.DataFrame()
# add separating variable when it is 7 lumps of data
sepvar = 0
if algtest == "id":
sepvar = 0.04
cs["MSA"] = [round(x, 2) + sepvar for x in msa.get_cons_scores(algtest)]
cs["MSTA"] = [round(x, 2) - sepvar for x in msta.get_cons_scores(algtest)]
cs[prot.name] = prot.get_cons_scores(contest)
cs.insert(0, 'POS', [str(x) + seq[x - 1] for x in range(1, 1 + len(cs))])
# plotting
fig, ax = plt.subplots()
fig.set_size_inches(11.7, 8.27) # A4 size
def plotter(fig, ax, alg_label, colour, pname):
#scatter plot
sb.regplot(alg_label,
pname,
cs,
scatter=True,
fit_reg=False,
ax=ax,
label=alg_label)
# labels
dpos = set()
def label_point(x, y, val, ax, dpos):
a = pd.concat({'x': x, 'y': y, 'val': val}, axis=1)
for i, point in a.iterrows():
point['x'] += 0.01
i = 0
while (point['x'], point['y']) in dpos:
if i == 1:
point['x'] -= 0.04
point['y'] -= 0.01
i = -1
if i == 1 and round(point['x'], 2) == 1:
point['x'] -= 0.04
point['y'] -= 0.01
i = -1
i += 1
point['x'] += 0.02
dpos.add((point['x'], point['y']))
ax.text(point['x'],
point['y'],
str(point['val']),
fontsize=5,
color=colour)
label_point(cs[alg_label], cs[prot.name], cs.POS, plt.gca(), dpos)
plotter(fig, ax, "MSA", "black", prot.name)
plotter(fig, ax, "MSTA", "red", prot.name)
# plot diagonal line
lims = [
np.min([ax.get_xlim(), ax.get_ylim()]),
np.max([ax.get_xlim(), ax.get_ylim()]),
]
ax.plot(lims, lims, ls="--", c=".3")
# in case it is 7 lumps of X axis
if algtest == "id": # it is 7 blocks
ax.xaxis.set_major_formatter(
FormatStrFormatter('%.2f')) # float representation to 2 decimals
ax.bar(np.arange(0, 1.01, 1 / 6), [ax.get_ylim()[1]] * 7,
width=[0.15] * 7,
color="grey",
alpha=0.3) # backgroun bars
plt.xticks(np.arange(0, 1.01, 1 / 6)) # ligands xticks
# labels
plt.ylabel("Evolutionary Conservation")
plt.xlabel("Ligands Alignments Conservation")
plt.legend(loc=4)
# saving
plt.savefig("{}/{}concon.svg".format(args.output_path, prot.name),
format='svg',
dpi=1200)
# save text output also
with open("{}/{}concon.csv".format(args.output_path, prot.name),
"w") as outfile:
cs.to_csv(outfile, sep="\t")
grid of the minor ticks for a given axis, use for example
ax.xaxis.grid(True, which='minor')
Note, you should not use the same locator between different Axis
because the locator stores references to the Axis data and view limits
"""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,
AutoMinorLocator)
majorLocator = MultipleLocator(20)
majorFormatter = FormatStrFormatter('%d')
minorLocator = MultipleLocator(5)
t = np.arange(0.0, 100.0, 0.1)
s = np.sin(0.1 * np.pi * t) * np.exp(-t * 0.01)
fig, ax = plt.subplots()
plt.plot(t, s)
ax.xaxis.set_major_locator(majorLocator)
ax.xaxis.set_major_formatter(majorFormatter)
# for the minor ticks, use no labels; default NullFormatter
ax.xaxis.set_minor_locator(minorLocator)
plt.show()
def __init__(self, factor):
FormatStrFormatter.__init__(self, '%g')
self._factor = factor
def plot_InducedCurrent_cos(self, ax1, ax2, Ire, Iim, Is, phi, f, t):
FS = 20
# Numerical Values
w = 2 * np.pi * f
I0 = self.I * np.cos(w * t)
Ipmax = self.I
Ismax = np.max(Is)
Iremax = np.max(Ire)
Iimmax = np.max(Iim)
T = 1 / f
tL_phase = np.array([2 * T, 2 * T])
IL_phase = np.array([Ipmax, 1.25 * Ipmax])
tR_phase = np.array([2 * T - phi / w, 2 * T - phi / w])
IR_phase = np.array([Ismax, 4.1 * Ismax])
zero_line = 0 * t
xTicks = (np.max(t) / 8) * np.linspace(0, 8, 9)
xLabels = ["0", "T/2", "T", "3T/2", "2T", "5T/2", "3T", "7T/2", "4T"]
ax1.grid("both", linestyle="-", linewidth=0.8, color=[0.8, 0.8, 0.8])
ax1.plot(t, zero_line, color="k", linewidth=2)
ax1.plot(t, I0, color="k", linewidth=4)
ax1.plot(tL_phase, IL_phase, color="k", ls=":", linewidth=8)
ax1.set_xbound(0, np.max(t))
ax1.set_ybound(1.55 * np.min(I0), 1.55 * np.max(I0))
ax1.set_xlabel("Time", fontsize=FS + 2)
ax1.set_ylabel("Primary Current [A]", fontsize=FS + 2)
ax1.tick_params(labelsize=FS - 2)
ax1b = ax1.twinx()
ax1b.plot(t, Is, color="g", linewidth=4)
ax1b.plot(tR_phase, IR_phase, color="k", ls=":", linewidth=8)
ax1b.set_xbound(0, np.max(t))
ax1b.set_ybound(5.01 * np.min(Is), 5.01 * np.max(Is))
ax1b.set_ylabel("Secondary Current [A]", fontsize=FS + 2, color="g")
ax1b.tick_params(labelsize=FS - 2)
ax1b.tick_params(axis="y", colors="g")
ax1b.xaxis.set_ticks(xTicks)
ax1b.xaxis.set_ticklabels(xLabels)
ax1b.yaxis.set_major_formatter(FormatStrFormatter("%.2e"))
T_str = "{:.3e}".format(T)
Ip_str = "{:.3e}".format(self.I)
Is_str = "{:.3e}".format(np.max(Is))
phi_str = "{:.1f}".format(-180 * phi / np.pi)
ax1.text(0.05 * T,
1.3 * Ipmax,
"Period = " + T_str + " s",
fontsize=FS - 2)
ax1.text(
0.05 * T,
-1.24 * Ipmax,
"$I_p$ Amplitude = " + Ip_str + " A",
fontsize=FS - 2,
)
ax1.text(
0.05 * T,
-1.45 * Ipmax,
"$I_s$ Amplitude = " + Is_str + " A",
fontsize=FS - 2,
color="g",
)
ax1.text(
1.7 * T,
1.3 * Ipmax,
"Phase Lag ($\phi$) = " + phi_str + "$^o$",
fontsize=FS,
color="k",
)
ax2.grid("both", linestyle="-", linewidth=0.8, color=[0.8, 0.8, 0.8])
ax2.plot(t, zero_line, color="k", linewidth=2)
ax2.plot(t, Ire, color="b", linewidth=4)
ax2.plot(t, Iim, color="r", linewidth=4)
ax2.set_xbound(0, np.max(t))
ax2.set_ybound(1.61 * np.min(Is), 1.61 * np.max(Is))
ax2.set_xlabel("Time", fontsize=FS + 2)
ax2.set_ylabel("Secondary Current [A]", fontsize=FS + 2)
ax2.tick_params(labelsize=FS - 2)
ax2.xaxis.set_ticks(xTicks)
ax2.xaxis.set_ticklabels(xLabels)
ax2.yaxis.set_major_formatter(FormatStrFormatter("%.2e"))
Ire_str = "{:.3e}".format(Iremax)
Iim_str = "{:.3e}".format(Iimmax)
ax2.text(
0.05 * T,
-1.25 * Ismax,
"$I_{phase}$ Amplitude = " + Ire_str + " A",
fontsize=FS - 2,
color="b",
)
ax2.text(
0.05 * T,
-1.52 * Ismax,
"$I_{quad}$ Amplitude = " + Iim_str + " A",
fontsize=FS - 2,
color="r",
)
return ax1, ax1b, ax2
# Trimming trailing xticks zeros with matplotlib
from matplotlib.ticker import FormatStrFormatter
plt.gca().xaxis.set_major_formatter(FormatStrFormatter('%g'))
def static_N2_simple(self, w_best, runner, **kwargs):
cost = runner.cost
predict = runner.model
full_predict = runner.full_model
feat = runner.feature_transforms
normalizer = runner.normalizer
inverse_nornalizer = runner.inverse_normalizer
x_train = inverse_nornalizer(runner.x_train).T
y_train = runner.y_train
x_test = inverse_nornalizer(runner.x_test).T
y_test = runner.y_test
# or just take last weights
self.w = w_best
# construct figure
fig, axs = plt.subplots(1, 1, figsize=(9, 4))
# create subplot with 2 panels
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax2 = plt.subplot(gs[0], aspect='equal')
ax3 = plt.subplot(gs[1])
ax3.axis('off')
### create boundary data ###
xmin1 = np.min(self.x[:, 0])
xmax1 = np.max(self.x[:, 0])
xgap1 = (xmax1 - xmin1) * 0.05
xmin1 -= xgap1
xmax1 += xgap1
xmin2 = np.min(self.x[:, 1])
xmax2 = np.max(self.x[:, 1])
xgap2 = (xmax2 - xmin2) * 0.05
xmin2 -= xgap2
xmax2 += xgap2
# plot boundary for 2d plot
r1 = np.linspace(xmin1, xmax1, 300)
r2 = np.linspace(xmin2, xmax2, 300)
s, t = np.meshgrid(r1, r2)
s = np.reshape(s, (np.size(s), 1))
t = np.reshape(t, (np.size(t), 1))
h = np.concatenate((s, t), axis=1)
# compute model on train data
z1 = predict(normalizer(h.T), self.w)
z1 = np.sign(z1)
# reshape it
s.shape = (np.size(r1), np.size(r2))
t.shape = (np.size(r1), np.size(r2))
z1.shape = (np.size(r1), np.size(r2))
### loop over two panels plotting each ###
for ax in [ax2]:
# plot training points
ind0 = np.argwhere(y_train == +1)
ind0 = [v[1] for v in ind0]
ax.scatter(x_train[ind0, 0],
x_train[ind0, 1],
s=55,
color=self.colors[0],
edgecolor='k',
linewidth=2.5,
zorder=3)
ind1 = np.argwhere(y_train == -1)
ind1 = [v[1] for v in ind1]
ax.scatter(x_train[ind1, 0],
x_train[ind1, 1],
s=55,
color=self.colors[1],
edgecolor='k',
linewidth=2.5,
zorder=3)
# plot testing points
ind0 = np.argwhere(y_test == +1)
ind0 = [v[1] for v in ind0]
ax.scatter(x_test[ind0, 0],
x_test[ind0, 1],
s=55,
color=self.colors[0],
edgecolor=[1, 0.8, 0.5],
linewidth=2.5,
zorder=3)
ind1 = np.argwhere(y_test == -1)
ind1 = [v[1] for v in ind1]
ax.scatter(x_test[ind1, 0],
x_test[ind1, 1],
s=55,
color=self.colors[1],
edgecolor=[1, 0.8, 0.5],
linewidth=2.5,
zorder=3)
#### plot contour, color regions ####
ax.contour(s,
t,
z1,
colors='k',
linewidths=2.5,
levels=[0],
zorder=2)
ax.contourf(s,
t,
z1,
colors=[self.colors[1], self.colors[0]],
alpha=0.15,
levels=range(-1, 2))
# cleanup panel
ax.set_xlabel(r'$x_1$', fontsize=15)
ax.set_ylabel(r'$x_2$', fontsize=15, rotation=0, labelpad=20)
ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
def acsPlots(self):
for plot_number in range(1, self.numberFrequencyGroups() + 1):
matplotlib.rcParams['xtick.direction'] = 'out'
matplotlib.rcParams['ytick.direction'] = 'out'
figure = matplotlib.pyplot.figure(1, figsize=(10, 6))
acs = figure.add_subplot(111)
for i in range(0, self.numberModes()):
if self.frequencyGroups()[i][1] == plot_number:
acs.plot(numpy.arange(0, 1 + self.stepSize(),
self.stepSize()),
numpy.transpose(self.data())[i],
linewidth=1.,
color=self.normalModeSymmetryColors()[i])
acs.set_xlabel("Scaling Factor \(\lambda\)")
acs.set_ylabel(
"Local Mode Frequenices \(\omega_{a}\)[cm\(^{-1}\)]")
acs.text(
1.01,
((matplotlib.pyplot.ylim()[1] - matplotlib.pyplot.ylim()[0]) /
2) + matplotlib.pyplot.ylim()[0],
"Normal Mode Frequencies \(\omega_{\mu}\)[cm\(^{-1}\)]",
rotation='vertical',
verticalalignment='center')
figure.suptitle(str(self.__file_name_root).replace('_', '\_'))
# Generate local mode labels
deltaValue = 0.06
i = 0
while i < self.numberModes():
delta = 0.
average = 0.
text = ""
j = 0
while delta <= deltaValue:
if j >= 1:
text = text + ","
text = text + "\(\omega_{a}\)(" + str(
self.__data_arrangement[i + j][1] + 1) + ")"
average += self.localModeFrequencies()[i + j]
j += 1
if j + i >= self.numberModes():
break
else:
delta = ((self.localModeFrequencies()[i + j] -
self.localModeFrequencies()[i]) /
(matplotlib.pyplot.ylim()[1] -
matplotlib.pyplot.ylim()[0]))
average = average / j
if self.frequencyGroups()[i][1] == plot_number:
# if (i + 1) == (i + j):
# text = text = "\(\omega_{a}\)(" + str(i + 1) + ")"
# else:
# text = "\(\omega_{a}\)(" + str(i + 1) + "-" + str(i + j) + ")"
acs.text(-0.14,
average,
text,
verticalalignment='center',
horizontalalignment='right')
i = i + j
# Generate normal mode labels
i = 0
while i < self.numberModes():
delta = 0.
average = 0.
text = ""
j = 0
while delta <= deltaValue:
if j >= 1:
text = text + ","
text = text + "\(\omega_{" + str(
i + j + 1) + "}\)(" + latexSymmetry(
self.normalModeSymmetries()[i + j]) + ")"
average += self.normalModeFrequencies()[i + j]
j += 1
if j + i >= self.numberModes():
break
else:
delta = ((self.normalModeFrequencies()[i + j] -
self.normalModeFrequencies()[i]) /
(matplotlib.pyplot.ylim()[1] -
matplotlib.pyplot.ylim()[0]))
average = average / j
if self.frequencyGroups()[i][1] == plot_number:
acs.text(1.06,
average,
text,
verticalalignment='center',
horizontalalignment='left')
i = i + j
matplotlib.pyplot.xlim([0, 1])
acs.xaxis.set_major_locator(MaxNLocator(10))
acs.xaxis.set_minor_locator(MaxNLocator(100))
acs.yaxis.set_major_locator(MaxNLocator(10))
acs.yaxis.set_minor_locator(MaxNLocator(100))
acs.yaxis.set_major_formatter(FormatStrFormatter('%0.0f'))
sizeOfFont = 18
fontProperties = {
'family': 'sans-serif',
'sans-serif': ['Helvetica'],
'weight': 'normal',
'size': sizeOfFont
}
matplotlib.rc('font', **fontProperties)
matplotlib.rc('text', usetex=True)
a = matplotlib.pyplot.gca()
a.set_xticklabels(a.get_xticks(), fontProperties)
#a.set_yticklabels(a.get_yticks(), fontProperties)
figure.savefig(str(self.__file_name_root) + "-" +
str(plot_number) + ".pdf",
bbox_inches='tight')
matplotlib.pyplot.close()
def graphsviewbar(request, tester_name, param_name, model, side):
import django
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
import matplotlib.pyplot as plt
from matplotlib.figure import Figure
from matplotlib import pyplot as plt
import numpy as np
fig = plt.Figure()
ax = fig.add_subplot(211) #211 ,111
ay = fig.add_subplot(212)
#fig.tight_layout()
fig.tight_layout(pad=2, w_pad=0.5, h_pad=4.0)
#get limit
from spc.models import ParamSetting
ps = ParamSetting.objects.get(tester_name=tester_name,
param_name=param_name,
model=model,
control_side=side)
titletxt = 'IR chart : %s - %s (%s)' % (tester_name, param_name, side)
pd = PerformingDetail.objects.filter(
param_name=param_name,
perform_id__tester_name=tester_name).order_by('-datetime')[:50]
minvalue_list = pd.values_list('min_value', flat=True)[::-1]
maxvalue_list = pd.values_list('max_value', flat=True)[::-1]
date_list = pd.values_list('datetime', flat=True)[::-1]
n = pd.count()
cl = np.empty(n)
ucl = np.empty(n)
ucl1s = np.empty(n)
ucl2s = np.empty(n)
lcl = np.empty(n)
lcl1s = np.empty(n)
lcl2s = np.empty(n)
cl.fill(ps.cl)
ucl.fill(ps.ucl)
lcl.fill(ps.lcl)
ucl1s.fill(ps.ucl1s)
lcl1s.fill(ps.lcl1s)
ucl2s.fill(ps.ucl2s)
lcl2s.fill(ps.lcl2s)
#x=np.arange(1,n+1)
#ax.set_xlim(1, 50)
dim = np.arange(0, n + 1)
x = np.arange(1, n + 1)
#x=date_list
#y = np.full(n, 1)
#y = np.full(n, ps.lcl*0.6)
y = minvalue_list if side == 'MIN' else maxvalue_list
box_plot(ay, y, '')
#Center Line (CL)
ax.plot(x, cl, linestyle='-', color='black', linewidth=2)
ax.text(1,
ps.cl,
ps.cl.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'gray',
'alpha': 0.5,
'pad': 1
})
#1Sigma Upper line (1ucl)
ax.plot(x, ucl1s, linestyle='--', color='green', linewidth=1)
ax.text(1,
ps.ucl1s,
ps.ucl1s.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'green',
'alpha': 0.5,
'pad': 1
})
#1Sigma Lower line (1lcl)
ax.plot(x, lcl1s, linestyle='--', color='green', linewidth=1)
ax.text(1,
ps.lcl1s,
ps.lcl1s.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'green',
'alpha': 0.5,
'pad': 1
})
#2Sigma Upper line (2ucl)
ax.plot(x, ucl2s, linestyle='--', color='orange', linewidth=1)
ax.text(1,
ps.ucl2s,
ps.ucl2s.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'orange',
'alpha': 0.5,
'pad': 1
})
#2Sigma Upper line (2lcl)
ax.plot(x, lcl2s, linestyle='--', color='orange', linewidth=1)
ax.text(1,
ps.lcl2s,
ps.lcl2s.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'orange',
'alpha': 0.5,
'pad': 1
})
#3Sigma Upper line (3ucl)
ax.plot(x, ucl, linestyle='-', color='red', linewidth=2)
ax.text(1,
ps.ucl,
ps.ucl.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'red',
'alpha': 0.5,
'pad': 1
})
#3Sigma lower line (3lcl)
ax.plot(x, lcl, linestyle='-', color='red', linewidth=2)
ax.text(1,
ps.lcl,
ps.lcl.__format__('0.3'),
ha='left',
verticalalignment='bottom',
color='black',
wrap=True,
bbox={
'facecolor': 'red',
'alpha': 0.5,
'pad': 1
})
#xlabels = [newdate.strftime('%b-%d %I:%M %p') if True else newdate for newdate in date_list]#'%b-%d'
from django.utils import timezone
xlabels = [
timezone.localtime(newdate,
timezone.get_default_timezone()).strftime('%b-%d')
if True else newdate for newdate in date_list
] #'%b-%d'
from matplotlib.ticker import MultipleLocator, FormatStrFormatter
majorLocator = MultipleLocator(1)
majorFormatter = FormatStrFormatter('%d')
minorLocator = MultipleLocator(1)
minorFormatter = FormatStrFormatter('%d')
ax.xaxis.set_major_locator(majorLocator)
ax.xaxis.set_major_formatter(majorFormatter)
ax.xaxis.set_minor_locator(minorLocator)
ax.xaxis.set_major_formatter(minorFormatter)
ax.plot(x, y, 'o-')
#fig.xticks(dim)
#fig.grid()
#ax.set_xticks(date_list)
labels = [
'0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a1',
'b2', 'c3', 'd4', 'e5', 'f6', 'g7', 'h8', 'i9', 'j10', 'k11', 'l12',
'm13', 'n14', 'o15', 'p16', 'q17', 'r18', 's19', 't20', 'u21', 'v22',
'w23', 'x24'
]
labels = ['0'] + xlabels
ax.set_xticklabels(labels, rotation=70, ha='right')
#for label in ax.get_xticklabels():
# label.set_rotation('vertical')
#ax.plot(r.date, r.close)
# rotate and align the tick labels so they look better
#fig.autofmt_xdate()
# use a more precise date string for the x axis locations in the
# toolbar
#plt.title('fig.autofmt_xdate fixes the labels')
ax.set_title(titletxt)
#ax.set_xticks(date_list)
#ax.set_xticks(date_list)
#ax.set_xticklabels(xlable , rotation=45) #Working but need to fix format
#ax.set_xticklabels(date_list)
#ax.set_minor_formatter(FormatStrFormatter("%b"))
ax.set_ylim([(ps.lcl + (ps.lcl1s - ps.cl)), (ps.ucl + (ps.ucl1s - ps.cl))])
ax.xaxis.grid(True, 'major', linewidth=1)
ax.tick_params(axis='x', pad=8)
#ax.xaxis.grid(True,'minor')
#fig.tight_layout()
#fig.autofmt_xdate()
# rotate and align the tick labels so they look better
#fig.autofmt_xdate()
# use a more precise date string for the x axis locations in the
# toolbar
#plt.title('fig.autofmt_xdate fixes the labels')
#ax.imshow(X, cmap=cm.jet)
fig.set_size_inches(13, 8, forward=True)
#plt.savefig("image.png",bbox_inches='tight',dpi=100)
canvas = FigureCanvas(fig)
response = django.http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
(bkg_eff / np.interp(sig_eff, xref, yref))**(-1),
color="#AE3135",
marker="o",
markersize=5)
k = k + 1
# Styling the plot
ax1.set_ylabel(r'Background efficiency [%]')
ax2.set_xlabel(r'Signal efficiency [%]')
ax2.set_ylabel(r'Ratio')
ax1.set_ylim(0.101, 100)
ax2.set_ylim(0.201, 1.09)
ax1.legend(loc="upper left", ncol=1)
ax1.yaxis.set_major_formatter(FormatStrFormatter("%.0f"))
plt.savefig(join(plot_dir,
"ROC/2017_{0}_{1}.pdf".format(location, ptrange)),
bbox_inches='tight')
# plt.savefig(join(plot_dir, "ROC/2017_{0}_{1}.eps".format(location, ptrange)), bbox_inches='tight')
plt.savefig(join(plot_dir,
"ROC/2017_{0}_{1}.png".format(location, ptrange)),
bbox_inches='tight')
# os.system("convert -density 150 -quality 100 " + join(plot_dir, "roc/2017_{0}_{1}.eps".format(location, ptrange)) + " "
# + join(plot_dir, "roc/2017_{0}_{1}.png".format(location, ptrange)))
plt.close()
def __call__(self, v, i=0):
return FormatStrFormatter.__call__(self, v*self._factor, i)
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import MultipleLocator, FormatStrFormatter
plt.rcParams['font.sans-serif'] = ['SimHei']
x1 = range(1, 21)
y1 = [15] * 20
x2 = range(1, 21)
y2 = [74.96] * 20
xmajorLocator = MultipleLocator(1)
xmajorFormatter = FormatStrFormatter('%2d')
xminorLocator = MultipleLocator(0.5)
ymajorLocator = MultipleLocator(10)
ymajorFormatter = FormatStrFormatter('%3d')
yminorLocator = MultipleLocator(5)
ax = plt.subplot(111)
ax.xaxis.set_major_formatter(xmajorFormatter)
ax.xaxis.set_major_locator(xmajorLocator)
ax.yaxis.set_major_locator(ymajorLocator)
ax.yaxis.set_major_formatter(ymajorFormatter)
ax.xaxis.set_minor_locator(xminorLocator)
ax.yaxis.set_minor_locator(yminorLocator)
ax.xaxis.grid(True, which='major')
