def _save(self, name='wiki1'):
'''
Parameters
----------
name : TYPE, optional
DESCRIPTION. The default is 'wiki1'.
Returns
-------
None.
'''
fraction = 1
width = 212
fig, ax = plt.subplots(figsize=set_size(width, fraction),
sharex='all',
gridspec_kw={'hspace': 0.5})
#plt.plot(self.y10, color='green', alpha=0.9)
plt.plot(self.y50, color='red', alpha=0.8, label='OFAT')
plt.plot(self.y_test, color='olive', alpha=0.8, label='ground truth')
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax.xaxis.set_major_locator(plt.LinearLocator(6))
ax.yaxis.set_major_locator(plt.LinearLocator(6))
plt.legend(loc='upper right', bbox_to_anchor=(1.0, 1.05), ncol=2)
plt.xlabel('Time (days)')
#print('{} smae: {} std: {}'.format(name, self.smae, self.std_s))
plt.ylabel('Weekly prices')
plt.tight_layout()
plt.savefig('../../ofat/figures/' + name + '.pdf',
format='pdf',
bbox_inches='tight')
def fluxCor(s2d, arm, fluxf, countf):
print '\tConverting counts to flux'
fluxspec = np.array(pyfits.getdata(fluxf, 0)[0].transpose())
countspec = np.array(pyfits.getdata(countf, 0)[0].transpose())
wlkey, wlstart = 'NAXIS%i' % s2d.dAxis[arm], 'CRVAL%i' % s2d.dAxis[arm]
wlinc, wlpixst = 'CDELT%i' % s2d.dAxis[arm], 'CRPIX%i' % s2d.dAxis[arm]
head = pyfits.getheader(fluxf, 0)
pix = np.arange(head[wlkey]) + 1
wave = (head[wlstart] + (pix - head[wlpixst]) * head[wlinc]) * s2d.wlmult
count = np.where(countspec == 0, 1E-5, countspec)
resp = fluxspec / count
tck = interpolate.InterpolatedUnivariateSpline(wave, resp)
respm = tck(s2d.wave[arm])
fig = plt.figure(figsize=(9, 9))
ax = fig.add_subplot(1, 1, 1)
ax.yaxis.set_major_formatter(plt.FormatStrFormatter(r'$%s$'))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter(r'$%i$'))
ax.set_yscale('log', subsx=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
ax.plot(s2d.wave[arm], respm, 'o')
ax.set_xlabel(r'$\rm{Observed\,wavelength\,(\AA)}$')
ax.set_ylabel(r'$\rm{Response\,function}$')
fig.savefig('%s_resp_%s.pdf' % (s2d.object, arm))
s2d.data[arm] = (respm * s2d.data[arm].transpose()).transpose()
s2d.erro[arm] = (respm * s2d.erro[arm].transpose()).transpose()
def setticks(ax,
xlog=False,
ylog=False,
xmajor=5,
xminor=1,
ymajor=2,
yminor=0.5):
if not xlog:
xmajorLocator = pylab.MultipleLocator(xmajor)
xmajorFormatter = pylab.FormatStrFormatter('%d')
xminorLocator = pylab.MultipleLocator(xminor)
ax.xaxis.set_major_locator(xmajorLocator)
#ax.xaxis.set_major_formatter(xmajorFormatter)
ax.xaxis.set_minor_locator(xminorLocator)
if not ylog:
ymajorLocator = pylab.MultipleLocator(ymajor)
ymajorFormatter = pylab.FormatStrFormatter('%d')
yminorLocator = pylab.MultipleLocator(yminor)
ax.yaxis.set_major_locator(ymajorLocator)
#ax.yaxis.set_major_formatter(ymajorFormatter)
ax.yaxis.set_minor_locator(yminorLocator)
ax.get_yaxis().set_tick_params(which='both', direction='out')
ax.get_xaxis().set_tick_params(which='both', direction='out')
for tick in ax.xaxis.get_ticklines():
tick.set_markersize(4.5)
for tick in ax.yaxis.get_ticklines():
tick.set_markersize(4.5)
for tick in ax.xaxis.get_ticklines(minor=True):
tick.set_markersize(2.5)
for tick in ax.yaxis.get_ticklines(minor=True):
tick.set_markersize(2.5)
def plotAllShots(self, C_Selector=0):
idx = self.cluster_list[C_Selector]
Deltas = self.delta_shot
Psis = self.psi_shot
WL = self.WLarray
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
fig.tight_layout(pad=4)
ax1.clear
ax1.scatter(self.WLarray, Deltas[C_Selector], color='red')
ax1.set_title('Delta', fontsize='xx-large')
ax1.set_xticklabels(self.WLarray, fontsize='xx-large')
ax1.set_yticklabels(Deltas[C_Selector], fontsize='xx-large')
ax1.set_xlabel('Wavelength (nm)', fontsize='xx-large')
ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax1.yaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
fig.suptitle('Cluster index: {}'.format(C_Selector),
y=1.05,
fontsize='xx-large')
ax2.clear
ax2.scatter(self.WLarray, Psis[C_Selector], color='blue')
ax2.set_title('Psi', fontsize='xx-large')
ax2.set_xticklabels(self.WLarray, fontsize='xx-large')
ax2.set_yticklabels(Psis[C_Selector], fontsize='xx-large')
ax2.set_xlabel('Wavelength (nm)', fontsize='xx-large')
ax2.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax2.yaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
for C_Selector in self.cluster_list:
ax1.plot(self.WLarray, Deltas[C_Selector], alpha=0.7)
ax2.plot(self.WLarray, Psis[C_Selector], alpha=0.7)
return fig
def main():
df = pd.read_csv('./log_files/2020-05-10-09:19:25_HAC_log.csv')
print(df.cumulated_reward)
fig, ax = plt.subplots()
ax.plot(np.arange(len(df.cumulated_reward)), df.cumulated_reward)
#ax.xaxis.set_major_locator(plt.MultipleLocator(20))
#ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%d'))
ax.yaxis.set_major_locator(plt.MultipleLocator(20))
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%d'))
# For the minor ticks, use no labels; default NullFormatter.
#ax.xaxis.set_minor_locator(plt.MultipleLocator(5))
plt.show()
df = pd.read_csv('./log_files/2020-05-10-09:19:25_other_HAC_log.csv')
print(df.cumulated_reward)
fig, ax = plt.subplots()
ax.plot(np.cumsum(df.steps), df.cumulated_reward)
# ax.xaxis.set_major_locator(plt.MultipleLocator(20))
# ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%d'))
ax.yaxis.set_major_locator(plt.MultipleLocator(20))
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%d'))
# For the minor ticks, use no labels; default NullFormatter.
# ax.xaxis.set_minor_locator(plt.MultipleLocator(5))
plt.show()
'''plt.plot(np.cumsum(r.monitor.l), pu.smooth(r.monitor.r, radius=10))
def set_appearance(self):
# ----------------------------------------------------
figsize_hor = 3.14 # Length[inch]
figsize_ver = 2.355 # Width[inch]
x_min = 0.0
x_max = 2.0001
y_min = -2.0
y_max = 2.0001
x_step = 0.5
y_step = 0.5
# ----------------------------------------------------
plt.figure(self.number, figsize=(figsize_hor, figsize_ver))
plt.rcParams['font.family'] = 'Times New Roman'
plt.rcParams['mathtext.fontset'] = 'stix'
plt.rcParams['font.size'] = 8
plt.rcParams['xtick.direction'] = 'in'
plt.rcParams['ytick.direction'] = 'in'
plt.rcParams['axes.linewidth'] = 0.5
plt.rcParams['axes.grid'] = True
plt.rcParams['grid.linestyle'] = '--'
plt.rcParams['grid.linewidth'] = 0.3
plt.rcParams["legend.edgecolor"] = 'black'
plt.rcParams["legend.fancybox"] = False
plt.xlabel(r"$x$")
plt.ylabel(r"$y$")
plt.axis([x_min, x_max, y_min, y_max])
plt.xticks(np.arange(x_min, x_max, x_step))
plt.yticks(np.arange(y_min, y_max, y_step))
plt.tick_params(width=0.5)
plt.gca().xaxis.set_major_formatter(
plt.FormatStrFormatter('%.1f')) # Display format of x axis
plt.gca().yaxis.set_major_formatter(
plt.FormatStrFormatter('%.1f')) # Display format of y axis
return
def plot(self, name='wikipgs'):
fraction = 1
width = 512
fig, ax = plt.subplots(figsize=set_size(width, fraction),
sharex='all',
gridspec_kw={'hspace': 0.5})
#plt.plot(self.uncertainty, color='green', alpha=0.9)
#plt.plot(self.y50,alpha=0.8, label='ofat')
plt.plot(self.y_test, alpha=0.8, label='gt')
plt.plot(self.yqcnn, alpha=0.8, label='qcnn')
plt.plot(self.ycnn, alpha=0.8, label='cnn')
plt.plot(self.yqclnn, alpha=0.8, label='qconvl')
plt.plot(self.yqlstm[1], alpha=0.8, label='qlstm')
plt.plot(self.ylstm, alpha=0.6, label='lstm')
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax.xaxis.set_major_locator(plt.LinearLocator(6))
ax.yaxis.set_major_locator(plt.LinearLocator(6))
plt.legend(loc='upper right',
bbox_to_anchor=(1.01, 1.05),
ncol=3,
columnspacing=0.5)
plt.xlabel('Time (days)')
#print('{} smae: {} std: {}'.format(name, self.smae, self.std_s))
plt.ylabel('Daily page visits')
plt.tight_layout()
def plotClusterRawValues(self, C_Selector=0, idxSelector=0):
C_ys, C_xs = self.cluster_coordinates[C_Selector]
Dmap = self.AllShuffledStack[C_ys, C_xs,
self.DeltaIndices[idxSelector]]
Pmap = self.AllShuffledStack[C_ys, C_xs, self.PsiIndices[idxSelector]]
bins = int(len(Dmap) / 10)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
fig.tight_layout(pad=4)
ax1.clear
ax1.hist(Dmap, bins=bins, color='red')
ax1.set_title(
'Not segmented Delta values on cluster {}'.format(C_Selector),
fontsize='xx-large')
ax1.set_xticklabels(Dmap, fontsize='xx-large')
ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
ax1.set_yticklabels(np.histogram(Dmap)[0], fontsize='xx-large')
ax1.yaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
fig.suptitle('Map index: {} -- Wavelength: {} nm'.format(
idxSelector, self.WLdict[idxSelector]),
y=1.05,
fontsize='xx-large')
ax2.clear
ax2.hist(Pmap, bins=bins, color='blue')
ax2.set_title(
'Not segmented Psi values on cluster {}'.format(C_Selector),
fontsize='xx-large')
ax2.set_xticklabels(Pmap, fontsize='xx-large')
ax2.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax2.set_yticklabels(np.histogram(Pmap)[0], fontsize='xx-large')
ax2.yaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
return fig
def plot_figs(fig_num, elev, azim, a):
fig = plt.figure(fig_num, figsize=(4, 3))
plt.clf()
ax = Axes3D(fig, elev=elev, azim=azim)
ax.scatter(body_mass, work_level, heat_output, c='k', marker='+')
X = np.arange(55, 85, 0.5)
Y = np.arange(90, 180, 0.5)
X, Y = np.meshgrid(X, Y)
Z = a[0] + a[1]*X + +(Y/(a[2]+a[3]*X))
ax.plot_surface(X, Y, Z,alpha=.5, antialiased=True,rstride=200, cstride=100, cmap=plt.cm.coolwarm)
ax.set_xlabel('BODY_MASS', color='b')
ax.set_ylabel('WORK_LEVEL', color='b')
ax.set_zlabel('HEAT_OUTPUT', color='b')
ax.w_xaxis.set_ticklabels([])
ax.w_yaxis.set_ticklabels([])
ax.w_zaxis.set_ticklabels([])
ax.zaxis.set_major_locator(plt.LinearLocator(10))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.f'))
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.f'))
ax.zaxis.set_major_formatter(plt.FormatStrFormatter('%.f'))
def plotBarSegmentedMap(self, C_Selector=0, idxSelector=0):
Dmap = self.segmentedShuffledStack[:, :,
self.DeltaIndices[idxSelector]]
Pmap = self.segmentedShuffledStack[:, :, self.PsiIndices[idxSelector]]
D_Cvalues, D_Ccounts = np.unique(Dmap, return_counts=True)
P_Cvalues, P_Ccounts = np.unique(Pmap, return_counts=True)
D_varwidth = (D_Cvalues.max() - D_Cvalues.min()) / 20
P_varwidth = (P_Cvalues.max() - P_Cvalues.min()) / 20
SelectedDval = self.delta_shot[C_Selector][self.WLIndices[idxSelector]]
SelectedPVal = self.psi_shot[C_Selector][self.WLIndices[idxSelector]]
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
fig.tight_layout(pad=4)
ax1.clear
ax1.bar(D_Cvalues,
D_Ccounts,
edgecolor='green',
linewidth=2.5,
width=D_varwidth,
color='red')
ax1.axvline(x=SelectedDval,
color='black',
label='cluster {} at {}'.format(C_Selector, SelectedDval))
ax1.legend(fontsize='xx-large')
ax1.set_title('Delta clusters values and their pixel counts',
fontsize='xx-large')
ax1.set_xticklabels(D_Cvalues, fontsize='xx-large')
ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
ax1.set_yticklabels(D_Ccounts, fontsize='xx-large')
ax1.yaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
fig.suptitle('Map index: {} -- Wavelength: {} nm'.format(
idxSelector, self.WLdict[idxSelector]),
y=1.05,
fontsize='xx-large')
ax2.clear
ax2.bar(P_Cvalues,
P_Ccounts,
edgecolor='green',
linewidth=2.5,
width=P_varwidth,
color='blue')
ax2.axvline(x=SelectedPVal,
color='black',
label='cluster {} at {}'.format(C_Selector, SelectedPVal))
ax2.legend(fontsize='xx-large')
ax2.set_title('Psi clusters values and their pixel counts',
fontsize='xx-large')
ax2.set_xticklabels(P_Cvalues, fontsize='xx-large')
ax2.xaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
ax2.set_yticklabels(P_Ccounts, fontsize='xx-large')
ax2.yaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
return fig
def plot(actual_data,
predicted_data,
end_of_training_point,
x_axis,
title='',
errors=None):
fig, axs = plt.subplots(2, sharex=False, sharey=False)
actual_prices_plot = axs[0].plot_date(x_axis, actual_data, 'b*-')
predicted_prices_plot = axs[0].plot_date(x_axis,
predicted_data,
'r*--',
label='predicted_prices')
axs[0].set_ylabel("Adjusted Closing Price")
axs[0].yaxis.set_major_formatter(plt.FormatStrFormatter('$%.2f'))
axs[0].axvline(x=end_of_training_point, color='orange')
errors_as_percentage = \
((numpy.asarray(actual_data) - numpy.asarray(predicted_data)) / numpy.asarray(actual_data)) * 100
positive_values, negative_values = errors_as_percentage >= 0, errors_as_percentage < 0
axs[1].bar(numpy.asarray(x_axis)[positive_values],
errors_as_percentage[positive_values],
color='g')
axs[1].bar(numpy.asarray(x_axis)[negative_values],
errors_as_percentage[negative_values],
color='r')
axs[1].axvline(x=end_of_training_point, color='orange')
axs[1].yaxis.set_major_formatter(plt.FormatStrFormatter('%3.3f%%'))
axs[1].set_ylabel("difference as percentage")
axs[0].set_xlabel("Trading Day")
fig.autofmt_xdate()
plt.title(title)
####################################################################################
fig, ax = plt.subplots(1)
actual_prices_plot = plt.plot(x_axis, actual_data, 'b*-')
predicted_prices_plot = plt.plot(x_axis,
predicted_data,
'r*--',
label='predicted_prices')
plt.axvline(x=end_of_training_point, color='orange')
fig.autofmt_xdate()
if errors:
plt.figure()
_ = plt.plot(xrange(len(errors)), errors, 'r--')
plt.xlabel('Epoch')
plt.ylabel('Relative Error')
plt.title('Neural Network Relative Error History')
plt.ioff()
plt.show()
def plot_peak_hold(axis,
stft_data,
frequency_array,
title=False,
xlabel=False,
ylabel=False,
plot_freq_limits=False,
plot_amp_limits=False,
limit_array=False,
trace_label=False):
"""Plot the peak hold for a 2D STFT array
Args:
axis: matplotlip axis that this plot should be added to
stft_data: A 2D numpy ndarray of shape (time, freq) containing the
amplitude over both freq and time.
frequency_array: A 1D numpy ndarray containing hte frequencies in
Hz of the stft_data.
title: An optional title to be added to the plot
xlabel: An optional x-axis label to be added to the plot
ylabel: An optional y-axis label to be added to the plot
plot_freq_limits: An optional tuple containing the starting and ending
frequencies to be used in the plot
limit_array: An optional 1D numpy ndarray containing the limits for the
plotted data of dtype = [('frequency', 'f8'), ('amplitude', 'f8')]
Returns:
matplolib handle to the axis
Raises:
"""
peak_hold = calculate_peak_hold(stft_data, frequency_array)
if trace_label is not False:
axis.loglog(peak_hold['frequency'],
peak_hold['amplitude'],
label=trace_label)
else:
axis.loglog(peak_hold['frequency'], peak_hold['amplitude'])
if limit_array is not False:
axis.loglog(limit_array['frequency'], limit_array['amplitude'])
if plot_freq_limits is not False:
axis.set_xlim(plot_freq_limits)
if plot_amp_limits is not False:
axis.set_ylim(plot_amp_limits)
if title is not False:
axis.set_title(title)
if xlabel is not False:
axis.set_xlabel(xlabel)
if ylabel is not False:
axis.set_ylabel(ylabel)
axis.xaxis.set_major_formatter(plt.FormatStrFormatter('%g'))
axis.yaxis.set_major_formatter(plt.FormatStrFormatter('%g'))
axis.grid(b=True, which='major', color='0.25', linestyle='-')
axis.grid(b=True, which='minor', color='0.75', linestyle='-')
axis.set_axisbelow(True)
def weisskoff_figure(fluctuations,
theoretical_fluctuations,
rdc,
max_fluctuation,
max_roi_size,
title=None):
""" Return a matplotlib figure containing the Weisskoff analysis.
Parameters
----------
fluctuation: 2-uplet
the roi sizes array and the fluctuation array.
theoretical_fluctuation: 2-uplet
the roi sizes array and the theoretical fluctuation array.
"""
figure = plt.figure()
plot = figure.add_subplot(111)
plot.grid(True, which="both", ls="-")
plot.axes.loglog()
if title:
plt.title("{0}\nWeisskoff analysis".format(title))
else:
plt.title("Weisskoff analysis")
plot.plot(fluctuations[0, :],
100 * fluctuations[1, :],
"ko-",
fillstyle="full")
plot.plot(theoretical_fluctuations[0, :],
100 * theoretical_fluctuations[1, :],
"ko-",
markerfacecolor="w")
ymin, ymax = plt.ylim()
plot.plot([rdc, rdc], [ymin, 100 * max_fluctuation], "r-")
plot.plot([rdc, max_roi_size],
[100 * max_fluctuation, 100 * max_fluctuation], "r-")
plt.ylim((ymin, ymax))
plt.xlim((1, max_roi_size + 10))
plot.text(rdc,
ymin,
'rdc = {0}'.format(round(rdc, 2)),
verticalalignment='bottom',
horizontalalignment='right',
color='red',
fontsize=10)
# plt.xticks(list(plt.xticks()[0]) + [rdc])
plot.axes.set_xlabel("ROI width (pixels)")
plot.axes.set_ylabel("Fluctuation (%)")
plot.xaxis.set_major_formatter(plt.FormatStrFormatter("%.2f"))
plot.yaxis.set_major_formatter(plt.FormatStrFormatter("%.2f"))
plot.legend(("Measured", "Theoretical"), "upper right")
return figure
def graph_format(ax):
ax.set_xlim(graph.MinPeriod, graph.MaxPeriod)
ax.set_ylim(graph.MinVel, graph.MaxVel)
ax.set_xscale('log')
ax.set_yscale('log')
ax.grid(which="both")
ax.legend()
ax.get_xaxis().set_major_formatter(plt.FormatStrFormatter('%.2f'))
ax.get_yaxis().set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax.set_xlabel(graph.XLabel)
ax.set_ylabel(graph.YLabel)
def plot_bounds(sn_bounds):
production_years = sorted(sn_bounds.keys())
plt.figure(num=f"Ihagee serial numbers - bounds",
figsize=(10, 6),
tight_layout=True)
for yr in production_years:
plt.plot((yr, yr), sn_bounds[yr], "k.-")
plt.xlabel("Production year")
plt.ylabel("Serial number")
axes = plt.gca()
axes.xaxis.set_major_formatter(plt.FormatStrFormatter("%d"))
axes.yaxis.set_major_formatter(plt.FormatStrFormatter("%d"))
def plot_intervals(models_data):
plt.figure(num=f"Ihagee serial numbers - intervals",
figsize=(10, 6),
tight_layout=True)
for start, end, model, type_id, size, low, high in models_data:
if len(start) > 0 and len(end) > 0 and len(low) > 0 and len(high) > 0:
plt.plot((int(start), int(end)), (int(low), int(high)), "k.-")
plt.xlabel("Production year")
plt.ylabel("Serial number")
axes = plt.gca()
axes.xaxis.set_major_formatter(plt.FormatStrFormatter("%d"))
axes.yaxis.set_major_formatter(plt.FormatStrFormatter("%d"))
def id_spec(spec, model):
fig = plt.figure()
ax = fig.add_subplot(111)
ax.fmt_xdata = plt.FormatStrFormatter('%4.2f')
ax.fmt_ydata = plt.FormatStrFormatter('%4.2f')
from scipy import ndimage, interpolate
skymodel = model['model']
data = spec.copy()
blue, red, scale = model['blue'], model['red'], model['scale']
while (red - blue) / scale < data.size:
red += scale
blue -= scale
wave = scipy.arange(blue, red, scale)
blue, red = model['blue'], model['red']
sky = interpolate.splev(wave, skymodel)
sky /= sky.mean() / data.mean()
plt.plot(wave, sky, c='gray')
from scipy import optimize, signal
corr = signal.correlate(sky, data, mode='valid')
w0 = wave[corr.argmax()]
p = [w0, scale, 0., 0., 1.]
xvals = numpy.arange(data.size).astype(numpy.float32)
def opt(p):
p = numpy.array(p)
n = p[-1]
coeff = numpy.atleast_2d(p[:-1]).T
m = {'coeff': coeff, 'type': 'polynomial'}
w = sf.genfunc(xvals, 0., m)
mod = n * interpolate.splev(w, skymodel)
return (data - mod) / abs(data)**0.5
#coeff,ier = optimize.leastsq(opt,p,maxfev=10000,epsfcn=1e-5)
#fit = {'coeff':numpy.atleast_2d(coeff[:-1]).T,'type':'polynomial'}
#dwave = sf.genfunc(xvals,0.,fit)
dwave = numpy.linspace(blue, red, data.size)
dr = IDSpectrum(data, sky, dwave, wave, skymodel)
print "dr.keyid:", dr.keyid
print "dr.soln:", dr.soln
x = numpy.arange(sky.size)
w = sf.genfunc(x, 0., dr.soln)
if dr.soln is None:
dr.do_fit()
xdata = dr.data.get_xdata()
ydata = dr.data.get_ydata()
return dr.soln
def plot3d(self, figsize=(8, 6)):
# the fourth dimention is color
color_dimension = (self.stds * 100) # the fourth dimension
minn, maxx = color_dimension.min(), color_dimension.max()
norm = _mpl.colors.Normalize(minn, maxx)
m = _plt.cm.ScalarMappable(norm=norm, cmap='jet')
m.set_array([])
fcolors = m.to_rgba(color_dimension)
fig = _plt.figure(figsize=figsize)
ax = fig.gca(projection='3d')
_plt.title("Optiimzation 4D Plot (color = 4th dimention)\n",
fontsize=14, fontweight="bold", color="black")
surface = ax.plot_surface(self.sharpes, self.drawdowns*100, self.cagrs*100,
linewidth=0., antialiased=True,
facecolors=fcolors, vmin=minn, vmax=maxx,
rstride=1, cstride=1)
cbar = _plt.colorbar(m, shrink=0.7)
cbar.ax.yaxis.set_major_formatter(_plt.FormatStrFormatter(' %.2f '))
cbar.set_label("Volatility", fontweight="bold", color="black")
ax.grid(True)
ax.xaxis.pane.set_edgecolor('silver')
ax.yaxis.pane.set_edgecolor('silver')
# ax.zaxis.pane.set_edgecolor('silver')
# ax.xaxis.pane.fill = False
# ax.yaxis.pane.fill = False
# ax.zaxis.pane.fill = False
ax.xaxis.set_major_formatter(_plt.FormatStrFormatter(' %.2f '))
ax.set_xlabel('\nSharpe', fontweight="bold", color="black")
ax.yaxis.set_major_formatter(_plt.FormatStrFormatter(' %.f%% '))
ax.set_ylabel('\n\nDrawdown', fontweight="bold", color="black")
ax.zaxis.set_major_formatter(_plt.FormatStrFormatter(' %.f%% '))
ax.set_zlabel('\nCAGR', fontweight="bold", color="black")
try:
_plt.subplots_adjust(hspace=0)
except Exception:
pass
try:
fig.tight_layout()
except Exception:
pass
_plt.show()
def plotuncertanty(self, name='preduncer'):
fraction = 0.5
width = 510
timex = 2000
y = np.concatenate((self.y_train[-timex:], self.yqcnn), axis=0)
#self.y_test[91]=9.06
fig, ax = plt.subplots(figsize=set_size(width, fraction), sharey='all')
#plt.plot(self.y_train[-timex:],'grey', label='fitted model')
plt.plot(y + 0.1, 'red', label='ground truth', alpha=0.9)
ax.fill_between(range(timex,
len(self.y_test) + timex),
self.yqcnnl,
self.yqcnnu - 0.5,
color='royalblue',
alpha=0.5,
label='predictive uncertainty')
plt.plot(range(timex,
len(self.y_test) + timex),
self.y_test + 0.1,
'orange',
label='fitted model',
alpha=0.8)
ax.axvline(x=timex,
ymin=0,
ymax=5,
color='grey',
ls='--',
lw=2,
alpha=0.7)
#plt.scatter(timex+91, self.y_test[91], marker='*', s=70, color='red', label='predicted extreme event')#extreme event
#ax.grid(True, zorder=5)
#plt.plot(self.y_test, color='olive', alpha=0.8, label ='ground truth')
#plt.plot(range(timex,len(self.y_test)+timex), self.yqlstm[0],color='grey',alpha=0.3)
#plt.plot(range(timex,len(self.y_test)+timex), self.yqlstm[2],color='grey',alpha=0.3)
plt.ylim([8.8, 10.2])
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0f'))
ax.xaxis.set_major_locator(plt.LinearLocator(6))
ax.yaxis.set_major_locator(plt.LinearLocator(6))
plt.legend(loc='upper right',
bbox_to_anchor=(0.75, 1.03),
ncol=1,
columnspacing=0.05)
ax.set_xlabel('Time ')
ax.set_ylabel(r'EDF stock price (\pounds)')
plt.tight_layout()
plt.savefig('../_8th/myphd/thesis_1/figures/' + name + '.pdf',
format='pdf',
bbox_inches='tight')
def plot(self):
fig, ax = plt.subplots(1, 1)
ax.set_ylabel("Loss")
ax.set_xlabel("Learning Rate (log scale)")
ax.set_xscale("log")
ax.xaxis.set_major_formatter(plt.FormatStrFormatter("%.0e"))
ax.plot(self.lrs, self.losses)
def plot_learning_rate(
self, file_name: Union[str, Path], skip_first: int = 10, skip_last: int = 5
):
if type(file_name) is str:
file_name = Path(file_name)
lrs, losses = self._extract_learning_rate(file_name)
lrs = lrs[skip_first:-skip_last] if skip_last > 0 else lrs[skip_first:]
losses = losses[skip_first:-skip_last] if skip_last > 0 else losses[skip_first:]
fig, ax = plt.subplots(1, 1)
ax.plot(lrs, losses)
ax.set_ylabel("Loss")
ax.set_xlabel("Learning Rate")
ax.set_xscale("log")
ax.xaxis.set_major_formatter(plt.FormatStrFormatter("%.0e"))
# plt.show()
# save plot
plt.tight_layout(pad=1.0)
path = file_name.parent / "learning_rate.png"
plt.savefig(path, dpi=300)
print(
f"Learning_rate plots are saved in {path}"
) # to let user know the path of the save plots
plt.show(block=True) # to have the plots displayed when user run this module
plt.close(fig)
def plot_learning_rate(self,
file_name: Union[str, Path],
skip_first: int = 10,
skip_last: int = 5):
if type(file_name) is str:
file_name = Path(file_name)
lrs, losses = self._extract_learning_rate(file_name)
lrs = lrs[skip_first:-skip_last] if skip_last > 0 else lrs[skip_first:]
losses = losses[skip_first:-skip_last] if skip_last > 0 else losses[
skip_first:]
fig, ax = plt.subplots(1, 1)
ax.plot(lrs, losses)
ax.set_ylabel("Loss")
ax.set_xlabel("Learning Rate")
ax.set_xscale("log")
ax.xaxis.set_major_formatter(plt.FormatStrFormatter("%.0e"))
# save plot
plt.tight_layout(pad=1.0)
path = file_name.parent / "learning_rate.png"
plt.savefig(path, dpi=300)
plt.close(fig)
def plot_cost_function(cost_function, x_range, y_range, resolution, point1, point2):
x = np.arange(x_range[0], x_range[1], resolution)
y = np.arange(y_range[0], y_range[1], resolution)
X, Y = np.meshgrid(x, y)
Z = np.vectorize(cost_function)(X, Y)
fig = plt.figure()
fig.suptitle(r'Cost function with $\theta = 0$')
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=plt.cm.RdBu, linewidth=0, antialiased=False)
ax.zaxis.set_major_locator(plt.LinearLocator(10))
ax.zaxis.set_major_formatter(plt.FormatStrFormatter('%.02f'))
ax.set_xlabel('x-position')
ax.set_ylabel('y-position')
ax.set_zlabel('cost function')
ax.view_init(elev=25, azim=-120)
fig.colorbar(surf, shrink=0.5, aspect=5)
# Plot 2D
fig = plt.figure()
im = plt.imshow(Z, cmap=plt.cm.RdBu)
cset = plt.contour(Z, [cost_function(point1[0], point1[1]), cost_function(point2[0], point2[1])],
linewidths=2, cmap=plt.cm.Set2)
plt.clabel(cset, inline=True, fmt='%1.1f', fontsize=10)
plt.colorbar(im)
def plot(self):
fig, ax = plt.subplots(1, 1)
ax.set_ylabel('Loss')
ax.set_xlabel('Learning Rate (log scale)')
ax.set_xscale('log')
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0e'))
ax.plot(self.lrs, self.losses)
def __init__(self, weather_data, day_number, parent=None):
super(Hourly_Plot_Widget, self).__init__(parent)
self.weather_data = weather_data
self.day_number = day_number
figure = Figure()
canvas = FigureCanvasQTAgg(figure)
axis_rain = figure.add_subplot(111)
axis_rain.set(ylabel='opady[mm]', title='Pogoda godzinowa')
axis_rain.xaxis.set_major_locator(plt.MaxNLocator(10))
axis_rain.xaxis.set_major_formatter(plt.FormatStrFormatter('%d:00'))
axis_rain.set_ylim(0, 20)
axis_temp = axis_rain.twinx()
axis_temp.set(ylabel='temperatura [C]')
axis_temp.yaxis.set_major_locator(plt.MultipleLocator(5))
x = self.create_x_dataset()
y_temp = self.create_temp_dataset()
y_rain = self.create_rain_dataset()
axis_rain.bar(x, y_rain, color='#B3FFFF')
axis_temp.plot(x, y_temp, 'ro-')
axis_temp.set_ylim(axis_temp.get_ylim()[0] - 2,
axis_temp.get_ylim()[1] + 2)
for i in range(0, len(x)):
axis_temp.annotate(y_temp[i], (x[i], y_temp[i] + 1))
self.layoutVertical = QVBoxLayout(self)
self.layoutVertical.addWidget(canvas)
def _show_lr_plot(self,
index,
losses_skipped=losses_skipped,
trailing_losses_skipped=trailing_losses_skipped):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1)
losses = self.learn.recorder.losses
lrs = self.learn.recorder.lrs
final_losses_skipped = 0
if len(self.learn.recorder.
losses[losses_skipped:-trailing_losses_skipped]) >= 5:
losses = self.learn.recorder.losses[
losses_skipped:-trailing_losses_skipped]
lrs = self.learn.recorder.lrs[
losses_skipped:-trailing_losses_skipped]
final_losses_skipped = losses_skipped
ax.plot(lrs, losses)
ax.set_ylabel("Loss")
ax.set_xlabel("Learning Rate")
ax.set_xscale('log')
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%.0e'))
ax.plot(self.learn.recorder.lrs[index],
self.learn.recorder.losses[index],
markersize=10,
marker='o',
color='red')
plt.show()
def test_isotropy(self):
fig, ax = plt.subplots(nrows=1, ncols=1)
#ax.set_aspect('equal')
ax.scatter(self.cond_angle[:] / np.pi,
self.cond_e_min,
label='C min eigv',
s=0.5,
c='blue')
ax.scatter(self.cond_angle[:] / np.pi,
self.cond_e_max,
label='C max eigv',
s=0.5,
c='orange')
angle = np.linspace(0, np.pi, 200)
vec = np.stack([np.cos(angle), np.sin(angle)], axis=0)
mean_flux = self.mean_c_tn @ vec
ax.plot(angle / np.pi,
np.linalg.norm(mean_flux, axis=0),
label='|C_mean * vec(angle)|',
color='orange',
linewidth=2)
Y = np.full_like(angle, 1e-10)
ax.plot(angle / np.pi, Y, label='C bulk', color='red', linewidth=2)
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%g $\pi$'))
import matplotlib
ax.xaxis.set_major_locator(
matplotlib.ticker.MultipleLocator(base=0.25))
ax.set_ylim(np.min(self.cond_e_min), np.max(self.cond_e_max))
ax.set_yscale('log')
ax.legend()
fig.suptitle("Isotropy of the conductivity field")
fig.savefig("isotropy.pdf")
plt.close(fig)
def plot(bench, filename):
def function(x1, x2):
vec = bench.function()
return vec(2, [x1, x2])
plotN = 100
x1 = np.linspace(bench.Lower, bench.Upper, plotN)
x2 = np.linspace(bench.Lower, bench.Upper, plotN)
x1, x2 = np.meshgrid(x1, x2)
vecFunction = np.vectorize(function)
z = vecFunction(x1, x2)
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(x1,
x2,
z,
rstride=1,
cstride=1,
cmap=plt.cm.rainbow,
linewidth=0,
antialiased=False)
fig.colorbar(surf, shrink=0.5, aspect=7, cmap=plt.cm.coolwarm)
ax.zaxis.set_major_locator(plt.LinearLocator(10))
ax.zaxis.set_major_formatter(plt.FormatStrFormatter('%.01f'))
plt.savefig(filename)
def numberDaysPlot(code, daysNumbers, volume=500):
"""
静态方法，获取连续n天的大单数量，并统计分析画图
:param code:股票代码
:param daysNumbers:天数，以当前日期往前推
:param volume:大单
:return:
"""
#获取起始日期
startDay = tls.getday(-daysNumbers)
dayIndex = pd.date_range(startDay, periods=daysNumbers + 1)
buylist = []
selllist = []
daylist = []
stockname = " "
for day in dayIndex:
bd = Bigdeal(code, day, volume)
if bd.isOpen == True:
stockname = bd.stockname
#换算为万元
buySum = bd.getTotalBuy() / 10000
sellSum = bd.getTotalSell() / 10000
buylist.append(buySum)
selllist.append(sellSum)
d = day.__str__().split(' ')[0]
daylist.append(d)
ax = plt.subplot(111)
x = np.arange(0, len(daylist))
x1 = x * 2.5
x2 = x1 + 1
plt.bar(left=x1, height=buylist, width=1, color='red')
plt.hold
plt.bar(left=x2, height=selllist, width=1, color='green')
plt.xticks(x2, daylist)
plt.legend(['buy', 'sell'],
loc='upper center',
fancybox=True,
shadow=True)
ax.get_yaxis().set_major_formatter(plt.FormatStrFormatter('%i'))
# plt.setp(ax.get_xaxis().get_majorticklabels(), rotation=-45)
myfont = matplotlib.font_manager.FontProperties(fname="msyhbd.ttf")
yl = u'单位(万元）'
plt.ylabel(yl, fontproperties=myfont)
title = u"%s在%d日内超过%d手的大单交易量" % (stockname, daysNumbers, volume)
plt.title(title, fontproperties=myfont)
money = round(sum(buylist) - sum(selllist))
strMoney = u"%s在%s日超过%d手的大单净流入人民币%d万元" % (stockname, daysNumbers,
volume, money)
if money < 0:
strMoney = u"%s在%s日超过%d手的大单净流出人民币%d万元" % (stockname, daysNumbers,
volume, money)
textx = x2[0]
texty = max([max(buylist), max(selllist)]) * 6 / 8
plt.text(textx, texty, strMoney, fontproperties=myfont)
plt.show()
def plot_distr(binned_data_list,binning_increment):
norm_concs = []
bin_mids = []
for row in binned_data_list:
bin_mid = row[0]
bin_conc = row[1]
bin_conc_norm = bin_conc/(math.log(bin_mid+binning_increment/2.,10)-math.log(bin_mid-binning_increment/2.,10))
norm_concs.append(bin_conc_norm)
bin_mids.append(bin_mid)
popt,perr = SP2_utilities.fitFunction(SP2_utilities.lognorm,bin_mids,norm_concs,p0=(100,180,0.5))
fit_bin_mids = np.arange(10,1000,5)
fit_concs = []
for fit_bin_mid in fit_bin_mids:
fit_conc_norm = SP2_utilities.lognorm(fit_bin_mid, popt[0], popt[1], popt[2])
fit_concs.append(fit_conc_norm)
ticks = [10,20,30,40,50,60,80,120,200,300,400,600,1000]
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.plot(fit_bin_mids,fit_concs)
ax1.scatter(bin_mids,norm_concs)
ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%d'))
ax1.xaxis.set_major_locator(plt.FixedLocator(ticks))
ax1.set_xscale('log')
ax1.set_xlim(10,1000)
ax1.set_ylabel('dM/dlogD (ng/m3)')
ax1.set_xlabel('rBC VED (nm)')
plt.show()