def run(nogui):
reader = NML2Reader(verbose=True)
filename = 'test_files/NML2_SingleCompHHCell.nml'
print('Loading: %s'%filename)
reader.read(filename, symmetric=True)
msoma = reader.getComp(reader.doc.networks[0].populations[0].id,0,0)
print(msoma)
data = moose.Neutral('/data')
pg = reader.getInput('pulseGen1')
inj = moose.Table('%s/pulse' % (data.path))
moose.connect(inj, 'requestOut', pg, 'getOutputValue')
vm = moose.Table('%s/Vm' % (data.path))
moose.connect(vm, 'requestOut', msoma, 'getVm')
simdt = 1e-6
plotdt = 1e-4
simtime = 300e-3
#moose.showmsg( '/clock' )
for i in range(8):
moose.setClock( i, simdt )
moose.setClock( 8, plotdt )
moose.reinit()
moose.start(simtime)
print("Finished simulation!")
t = np.linspace(0, simtime, len(vm.vector))
if not nogui:
import matplotlib.pyplot as plt
vfile = open('moose_v_hh.dat','w')
for i in range(len(t)):
vfile.write('%s\t%s\n'%(t[i],vm.vector[i]))
vfile.close()
plt.subplot(211)
plt.plot(t, vm.vector * 1e3, label='Vm (mV)')
plt.legend()
plt.title('Vm')
plt.subplot(212)
plt.title('Input')
plt.plot(t, inj.vector * 1e9, label='injected (nA)')
#plt.plot(t, gK.vector * 1e6, label='K')
#plt.plot(t, gNa.vector * 1e6, label='Na')
plt.legend()
plt.figure()
test_channel_gates()
plt.show()
plt.close()
def main():
gw = gridworld()
a = agent(gw)
for epoch in range(20):
a.initEpoch()
while True:
rwd, stat, act = a.takeAction()
a.updateQ(rwd, stat, act)
if gw.status() == 'Goal':
break
if mod(a.counter, 10)==0:
print(gw.state())
print(gw.field())
print('Finished')
print(a.counter)
print(gw.state())
print(gw.field())
Q = transpose(a.Q(), (2,0,1))
for i in range(4):
plt.subplot(2,2,i)
plt.imshow(Q[i], interpolation='nearest')
plt.title(a.actions()[i])
plt.colorbar()
plt.show()
def render(self, interval=50, **kwargs):
import matplotlib.cm as cm
import matplotlib.animation as animation
import matplotlib.pyplot as plt
p = self.plot_layout
_axs = []
for i in range(self.image_list[0].shape[2]):
plt.subplot(p[0], p[1], 1 + i)
# Hide the x and y labels
plt.axis('off')
_ax = plt.imshow(self.image_list[0][:, :, i], cmap=cm.Greys_r,
**kwargs)
_axs.append(_ax)
def init():
return _axs
def animate(j):
for k, _ax in enumerate(_axs):
_ax.set_data(self.image_list[j][:, :, k])
return _axs
self._ani = animation.FuncAnimation(self.figure, animate,
init_func=init,
frames=len(self.image_list),
interval=interval, blit=True)
return self
def test_tripcolor():
x = np.asarray([0, 0.5, 1, 0, 0.5, 1, 0, 0.5, 1, 0.75])
y = np.asarray([0, 0, 0, 0.5, 0.5, 0.5, 1, 1, 1, 0.75])
triangles = np.asarray([
[0, 1, 3], [1, 4, 3],
[1, 2, 4], [2, 5, 4],
[3, 4, 6], [4, 7, 6],
[4, 5, 9], [7, 4, 9], [8, 7, 9], [5, 8, 9]])
# Triangulation with same number of points and triangles.
triang = mtri.Triangulation(x, y, triangles)
Cpoints = x + 0.5*y
xmid = x[triang.triangles].mean(axis=1)
ymid = y[triang.triangles].mean(axis=1)
Cfaces = 0.5*xmid + ymid
plt.subplot(121)
plt.tripcolor(triang, Cpoints, edgecolors='k')
plt.title('point colors')
plt.subplot(122)
plt.tripcolor(triang, facecolors=Cfaces, edgecolors='k')
plt.title('facecolors')
def plot_data(kx,omega,F,F_R,F_L,K,O):
#plt.figure(4)
#plt.imshow(K,extent=[omega[0],omega[-1],kx[0],kx[-1]],\
# interpolation = "nearest", aspect = "auto")
#plt.xlabel('KX')
#plt.colorbar()
#plt.figure(5)
#plt.imshow(O,extent =[omega[0],omega[-1],kx[0],kx[-1]],interpolation="nearest", aspect="auto")
#plt.xlabel('omega')
#plt.colorbar()
plt.figure(6)
pylab.subplot(1,2,1)
plt.imshow(abs(F_R), extent= [omega[0],omega[-1],kx[0],kx[-1]], interpolation= "nearest", aspect = "auto")
plt.xlabel('abs FFT_R')
plt.colorbar()
plt.subplot(1,2,2)
plt.imshow(abs(F_L), extent= [omega[0],omega[-1],kx[0],kx[-1]], interpolation= "nearest", aspect = "auto")
plt.xlabel('abs FFT_L')
plt.colorbar()
plt.figure(7)
plt.subplot(2,1,1)
plt.imshow(abs(F_L+F_R),extent=[omega[0],omega[-1],kx[0],kx[-1]],interpolation= "nearest", aspect = "auto")
plt.xlabel('abs(F_L+F_R) reconstructed')
plt.colorbar()
pylab.subplot(2,1,2)
plt.imshow(abs(F),extent=[omega[0],omega[-1],kx[0],kx[-1]],interpolation ="nearest",aspect = "auto")
plt.xlabel('FFT of the original data')
plt.colorbar()
#plt.show()
return
def plot_wav_fft(wav_filename, desc=None):
plt.clf()
plt.figure(num=None, figsize=(6, 4))
sample_rate, X = scipy.io.wavfile.read(wav_filename)
spectrum = np.fft.fft(X)
freq = np.fft.fftfreq(len(X), 1.0 / sample_rate)
plt.subplot(211)
num_samples = 200.0
plt.xlim(0, num_samples / sample_rate)
plt.xlabel("time [s]")
plt.title(desc or wav_filename)
plt.plot(np.arange(num_samples) / sample_rate, X[:num_samples])
plt.grid(True)
plt.subplot(212)
plt.xlim(0, 5000)
plt.xlabel("frequency [Hz]")
plt.xticks(np.arange(5) * 1000)
if desc:
desc = desc.strip()
fft_desc = desc[0].lower() + desc[1:]
else:
fft_desc = wav_filename
plt.title("FFT of %s" % fft_desc)
plt.plot(freq, abs(spectrum), linewidth=5)
plt.grid(True)
plt.tight_layout()
rel_filename = os.path.split(wav_filename)[1]
plt.savefig("%s_wav_fft.png" % os.path.splitext(rel_filename)[0],
bbox_inches='tight')
def plot_feature_comparison(title, trajectory, features):
plotCount = features.shape[1]
pointCount = features.shape[0]
fig = plt.figure()
plt.title(title)
#plt.ion()
#plt.show()
max = np.amax(features)
min = np.amin(features)
print "min=" + str(min) + ", max=" + str(max)
for i in range(plotCount):
plt.subplot(plotCount/2, 2, 1+i)
f = features[:,i]
for k in range(pointCount):
color = ''
if(f[k] > max * 0.6):
color = 'r'
elif(f[k] > max * 0.3):
color = 'y'
elif(f[k] < min * 0.3):
color = 'b'
elif(f[k] < min * 0.6):
color = 'g'
if (color != ''):
plt.plot(trajectory[k,0], trajectory[k,1], color+'.', markersize=20)
#plt.draw()
plt.plot(trajectory[:,0], trajectory[:,1], 'k')
plt.show()
#raw_input()
return
def simulate():
# Plotting the PDF of Unif(0, 1)
pyplot.subplot(211)
x = np.linspace(stats.uniform.ppf(0), stats.uniform.ppf(1), 100)
pyplot.title('PDF of Unif(0, 1)')
pyplot.plot(x, stats.uniform.pdf(x))
print("Xn is for n=1000: ", get_xn(1000))
E_Xn = 0.5 # As we know, E(Xn) is equal to mu which is 0.5
print("E(Xn) is : ", E_Xn)
n = np.linspace(1, 1000, 1000)
X_ns = []
for i in range(1, 1001):
X_ns.append(get_xn(i))
pyplot.subplot(212)
pyplot.title('f(n,Xn)')
pyplot.plot(n, X_ns, '-g')
print("Xn for n=1", get_xn(1))
print("Xn for n=5", get_xn(5))
print("Xn for n=25", get_xn(25))
print("Xn for n=100", get_xn(100))
pyplot.show()
def test_clipping():
exterior = mpath.Path.unit_rectangle().deepcopy()
exterior.vertices *= 4
exterior.vertices -= 2
interior = mpath.Path.unit_circle().deepcopy()
interior.vertices = interior.vertices[::-1]
clip_path = mpath.Path(vertices=np.concatenate([exterior.vertices,
interior.vertices]),
codes=np.concatenate([exterior.codes,
interior.codes]))
star = mpath.Path.unit_regular_star(6).deepcopy()
star.vertices *= 2.6
ax1 = plt.subplot(121)
col = mcollections.PathCollection([star], lw=5, edgecolor='blue',
facecolor='red', alpha=0.7, hatch='*')
col.set_clip_path(clip_path, ax1.transData)
ax1.add_collection(col)
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
patch = mpatches.PathPatch(star, lw=5, edgecolor='blue', facecolor='red',
alpha=0.7, hatch='*')
patch.set_clip_path(clip_path, ax2.transData)
ax2.add_patch(patch)
ax1.set_xlim([-3, 3])
ax1.set_ylim([-3, 3])
def view_punch(params, fmt):
dates, UdtConnSucRate, UdpBroConnSucRate, PunchHoleSucRate, TotalPunchHoleSucRate = get_punch(['Time', 'UdtConnSucRate', 'UdpBroConnSucRate', 'PunchHoleSucRate', 'TotalPunchHoleSucRate'], params)
dates = [parser.parse(d) for d in dates]
UdtConnSucRate = [float(v)*100 for v in UdtConnSucRate]
UdpBroConnSucRate = [float(v)*100 for v in UdpBroConnSucRate]
PunchHoleSucRate = [float(v)*100 for v in PunchHoleSucRate]
TotalPunchHoleSucRate = [float(v)*100 for v in TotalPunchHoleSucRate]
ax = plt.subplot(411)
ax.set_ylim([0, 100])
plt.ylabel("UDT反连(%)")
plt.plot_date(dates, UdpBroConnSucRate, fmt, label=params['isp'])
plt.legend(loc='upper left', ncol=2)
ax = plt.subplot(412)
ax.set_ylim([0, 100])
plt.ylabel("UDT直连(%)")
plt.plot_date(dates, UdtConnSucRate, fmt, label=params['isp'])
ax = plt.subplot(414)
ax.set_ylim([0, 100])
plt.ylabel("内网穿透(%)")
plt.plot_date(dates, PunchHoleSucRate, fmt, label=params['isp'])
'''
def plot_images(data_list, data_shape="auto", fig_shape="auto"):
"""
plotting data on current plt object.
In default,data_shape and fig_shape are auto.
It means considered the data as a sqare structure.
"""
n_data = len(data_list)
if data_shape == "auto":
sqr = int(n_data ** 0.5)
if sqr * sqr != n_data:
data_shape = (sqr + 1, sqr + 1)
else:
data_shape = (sqr, sqr)
plt.figure(figsize=data_shape)
for i, data in enumerate(data_list):
plt.subplot(data_shape[0], data_shape[1], i + 1)
plt.gray()
if fig_shape == "auto":
fig_size = int(len(data) ** 0.5)
if fig_size ** 2 != len(data):
fig_shape = (fig_size + 1, fig_size + 1)
else:
fig_shape = (fig_size, fig_size)
Z = data.reshape(fig_shape[0], fig_shape[1])
plt.imshow(Z, interpolation="nearest")
plt.tick_params(labelleft="off", labelbottom="off")
plt.tick_params(axis="both", which="both", left="off", bottom="off", right="off", top="off")
plt.subplots_adjust(hspace=0.05)
plt.subplots_adjust(wspace=0.05)
def plot_profiles(temp, salt, pres, filename, savedir):
"""
Escrever docstring
INPUT:
cond: blaa blaa
OUTPUT:
graphs are genarated and seved at "savedir"
"""
plt.figure(figsize=(10,5))
plt.subplot(121)
plt.plot(temp, -pres, color='#ef6548', linewidth=2)
plt.title('Temperature')
plt.subplot(122)
plt.plot(salt, -pres, color='#238b45', linewidth=2)
plt.title('Salinity')
if sys.platform == 'win32' or sys.platform == 'win64':
figname = filename.split('\\')[-1].split('.')[0] + '.png'
else:
figname = filename.split('/')[-1].split('.')[0] + '.png'
figname = os.path.join(savedir, figname)
print " --> saving png"
plt.savefig(figname)
def template_matching():
img = cv2.imread('messi.jpg',0)
img2 = img.copy()
template = cv2.imread('face.png',0)
w, h = template.shape[::-1]
# All the 6 methods for comparison in a list
methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']
for meth in methods:
img = img2.copy()
method = eval(meth)
# Apply template Matching
res = cv2.matchTemplate(img,template,method)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
top_left = min_loc
else:
top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv2.rectangle(img,top_left, bottom_right, 255, 2)
plt.subplot(121),plt.imshow(res,cmap = 'gray')
plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img,cmap = 'gray')
plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
plt.suptitle(meth)
plt.show()
def makeFftFig():
plt.figure(3)
plt.subplot(211)
plt.plot(W,f_signal,'bo')
plt.subplot(212)
plt.plot(W,cut_f_signal,'bo')
plt.show()
def plot_logpdf_Gaussian():
y2 = -6
logvar = np.arange(-4,4,0.05)
logprior = np.array([lp_gaussian(lv, 0, 1) for lv in logvar])
def plot_logvar(mu):
lp = np.array([lp_gaussian(y2, mu, np.exp(lv)) for lv in logvar])
plt.plot(logvar, lp+logprior, label='mu = {}'.format(mu))
plt.ylim(-20,3)
plt.clf()
plt.subplot(2,1,1)
plt.plot(logvar, logprior, label='prior', lw=5)
plot_logvar(0)
plot_logvar(-6)
plt.xlabel('logvar')
plt.legend()
mu = np.arange(-8,8,0.05)
logprior = np.array([lp_gaussian(m,0,1) for m in mu])
def plot_mu(var):
lp = np.array([lp_gaussian(y2, m, var) for m in mu])
lp = lp + logprior
plt.plot(mu, lp, label='var = {}'.format(var))
plt.ylim(-30,0)
plt.subplot(2,1,2)
plt.plot(mu, logprior, label='prior', lw=5)
plot_mu(0.1)
plot_mu(1.0)
plot_mu(10)
plt.xlabel('mu')
plt.legend()
def draw(ord_l, gaps):
axScatter = plt.subplot(3, 1, 1)
number_samples=0
# axScatter.scatter([i['seq'] for i in ord_l[-number_samples:]], [i['a'] for i in ord_l[-number_samples:]], s=2, color='r', label='ch1')
axScatter.scatter([i['seq'] % 24 for i in ord_l[-number_samples:]], [i['d'] for i in ord_l[-number_samples:]], s=2, color='r', label='ch1')
# axScatter.scatter(time_l[-number_samples:], b_l[-number_samples:], s=2, color='c', label='ch2')
# axScatter.scatter(time_l[-number_samples:], c_l[-number_samples:], s=2, color='y', label='ch3')
# axScatter.scatter(time_l[-number_samples:], d_l[-number_samples:], s=2, color='g', label='ch4')
plt.ylim(-9000000, 9000000)
plt.legend()
axScatter.set_xlabel("Sequence Packet")
axScatter.set_ylabel("Voltage")
plt.title("Channels Values")
# time_plot = plt.subplot(3, 1, 2)
# time_plot.scatter([i['seq'] for i in ord_l[-number_samples:]], [i['delta'] for i in ord_l[-number_samples:]], s=1, color='r', label='delta')
# time_plot.set_xlabel("Sequence Packet")
# time_plot.set_ylabel("Delta to referencial")
# ax2 = time_plot.twinx()
# ax2.scatter([i['seq'] for i in ord_l[-number_samples:]], [i['ts'] for i in ord_l[-number_samples:]], s=2, color='g', label='Timestamp')
# ax2.set_ylabel("Kernel time")
# plt.title("Timestamp deltas")
gaps_draw = plt.subplot(3, 1, 3)
gaps_draw.plot([i[0] for i in gaps[-number_samples:]], [i[1] for i in gaps[-number_samples:]], color='b', marker='.', label='gaps')
gaps_draw.set_ylim(-0.5, 1.5)
plt.draw()
# plt.savefig("res.png")
plt.show()
def calc_snr(plot = False):
tx = fromfile(open('tx_sym.32fc'), dtype=complex64)
rx = fromfile(open('rx_sym.32fc'), dtype=complex64)
if (len(tx) == 0 or len(rx) == 0):
print 'Not valid data'
print '\tPlease run gnuradio simulation first'
exit(-1)
size = min([len(tx), len(rx)]) - 1
rx = rx[0:size]
tx = tx[0:size]
tx_power = sum([abs(tx[i])**2 for i in range(size)])
rx_power = sum([abs(rx[i])**2 for i in range(size)])
noise_power = sum([abs(tx[i] - rx[i])**2 for i in range(size)])
SNR = 1.0*tx_power/noise_power
SNR_dB = 10*log10(SNR)
if plot:
init = 0
end = 100
p.subplot(211)
p.plot(list(real(tx[init:end])), '-o')
p.plot(list(imag(tx[init:end])), '-o')
p.subplot(212)
p.plot(list(real(rx[init:end])), '-o')
p.plot(list(imag(rx[init:end])), '-o')
p.show()
return SNR_dB
def my_predict(model, image, show=False):
image = image + train_mean
images = transform_img(image.transpose(1,2,0))
if show:
plt.figure()
plt.imshow(image.transpose(1,2,0).astype(np.uint8))
plt.show()
plt.figure()
for i in range(9):
plt.subplot(3,3,i+1)
plt.imshow(images[i].astype(np.uint8))
plt.show()
images = images.transpose(0, 3, 1, 2)
masks = model.predict(images - train_mean)
masks = masks.transpose(0,2,3,1)[:,:,:,0]
masks = reverse_gt(masks)
mask = np.mean(masks, axis=0)
if show:
masks = (masks * 255).astype(np.uint8)
mask = np.mean(masks, axis=0)
plt.figure()
for i in range(9):
plt.subplot(3,3,i+1)
plt.imshow(masks[i], cmap='Greys_r')
plt.show()
plt.figure()
plt.imshow(mask, cmap='Greys_r')
plt.show()
return mask
def create_comparison_plot(x, T1_true, P2_true, T2_true, P3_true, T1_ml, P2_ml, T2_ml, P3_ml, value1, value2):
Chi2_values = []
errorbar = []
y = func(x, T1_true, P2_true, T2_true, P3_true, value1, value2)
y1 = model1(x, T1_true, P2_true, T2_true, P3_true, value1, value2)
model = func(x, T1_ml, P2_ml, T2_ml, P3_ml, value1, value2)
for item in model:
value = 0.05*item
errorbar.append(value)
for k in range(0,np.size(y)):
item = ((y[k]-model[k])/(0.05*y[k]))**2
Chi2_values.append(item)
suma1 = np.sum(Chi2_values)
#Plot the data:
f = plt.figure()
gs = gridspec.GridSpec(2,1 ,height_ratios=[10,4])
ax1 = plt.subplot(gs[0])
ax1.plot(x,y,'-',label = 'observations')
ax1.plot(x,y1,'-',label= 'initial guess')
#ax1.errorbar(x,model,yerr=errorbar)
ax1.plot(x,model,'-',label = 'model')
ax1.legend()
plt.title("Error:"+ str(suma1))
plt.ylabel('I/F')
ax2 = plt.subplot(gs[1])
ax2.plot(x,Chi2_values,'-',label = '$\chi^2$')
ax2.legend()
plt.xlabel('Longitude (SIII)')
plt.ylabel('$\chi^2$')
plt.show()
f.savefig('output.png', format='png', dpi=1000)
def smooth_demo():
Smoother = SmoothClass()
xfile = ArrayClass("DatasetX")
#print xfile.array
xn = np.array(xfile.array)
plt.subplot(211)
#plt.plot(np.ones(ws))
windows=['blackman']
#windows=['flat', 'hanning', 'hamming', 'bartlett', 'blackman']
plt.hold(True)
plt.axis([0,30,0,1.1])
plt.legend(windows)
plt.title("The smoothing windows")
plt.subplot(212)
#plt.plot(xn)
plt.plot(xn)
plt.plot(Smoother.smooth(xn,10,'blackman'))
def do_day_hours(day_date_string, hour_numbers, basepath=None, show_plots=False):
n_plots = len(hour_numbers)
n_plotrows = 2 if n_plots > 3 else 1 # for now
if show_plots:
# plt.interactive(True)
plt.figure()
for (i_plot, hr) in enumerate(hour_numbers):
# get 2 filespecs to search for datafiles
spec_strings = pairof_MOGUK_search_filepaths(day_date_string, hr)
# for now, take **alphabetical last** of files matching target time (==latest forecast date)
print "spec_strings", spec_strings
filepair = [sorted(glob.glob(spec))[-1] for spec in spec_strings]
base_outname = "alluk_%6s_%02d_" % (day_date_string, hr)
outdir_path = dayhours_outpath + ("day_%s/" % day_date_string[-4:])
out_filepath = outdir_path + base_outname + "spd_and_dir.csv"
if show_plots:
n_subplot = 100 * n_plotrows + 10 * ((n_plots + n_plotrows - 1) // n_plotrows) + i_plot + 1
print "subplot : ", n_subplot
plt.subplot(n_subplot)
produce_csv_files(
region=[-1000, -1000, 1000, 1000], in_filenames=filepair, out_filepath=out_filepath, show_plot=show_plots
)
if show_plots:
plt.show()
def plot_main_seeds(self, qname, radio=False, checkbox=False,
numerical=False, array=False):
""" Plot the responses separately for each seed group in main_seeds. """
assert sum([radio, checkbox, numerical, array]) == 1
for seed in self.main_seeds:
responses_seed = self.filter_rows_by_seed(seed, self.responses)
responses_seed_question = self.filter_columns_by_name(qname, responses_seed)
plt.subplot(int("22" + str(self.main_seeds.index(seed))))
plt.title("Seed " + seed)
if radio:
self.plot_convergence_radio(qname, responses_seed_question)
elif checkbox:
self.plot_convergence_checkbox(responses_seed_question)
elif numerical:
self.plot_convergence_numerical(responses_seed_question)
elif array:
self.plot_array_boxes(qname, responses_seed_question)
qtext = self.get_qtext_from_qname(qname)
plt.suptitle(qtext)
plt.tight_layout()
plt.show()
def __call__(self,u,w,bx,by,bz,b2,t):
q = 8
map = cm.red_blue()
if self.x == None:
nx = u.shape[2]
nz = u.shape[0]
self.x,self.y = np.meshgrid(range(nx),range(nz))
x,y = self.x,self.y
avgu = np.average(u,1)
avgw = np.average(w,1)
avgbx = np.average(bx,1)
avgby = np.average(by,1)
avgbz = np.average(bz,1)
avgb2 = np.average(b2,1)
avgt = np.average(t,1)
plt.subplot(121)
plt.imshow(avgt,cmap=map,origin='lower')
plt.colorbar()
plt.quiver(x[::q,::q],y[::q,::q],avgu[::q,::q],avgw[::q,::q])
plt.title('Tracer-Vel')
plt.axis("tight")
plt.subplot(122)
plt.imshow(avgby,cmap=map,origin='lower')
plt.colorbar()
plt.quiver(x[::q,::q],y[::q,::q],avgbx[::q,::q],avgbz[::q,::q])
plt.title('By-Twist')
plt.axis("tight")
def test_single_point():
fig = plt.figure()
plt.subplot( 211 )
plt.plot( [0], [0], 'o' )
plt.subplot( 212 )
plt.plot( [1], [1], 'o' )
fig.savefig( 'single_point' )
def ReleaseMemoryPlot2(mincut = 0.9, maxcut = 1, N = 100):
step = (maxcut - mincut)/N
cuts = [mincut + step*i for i in range(0, N+1)]
released_memory = []
good_memory = []
part_of_good_memory = []
all_memory = signal_test2.get_data(['DiskSize']).values[:,0].sum() + bck_test2.get_data(['DiskSize']).values[:,0].sum()
memory_can_be_free = signal_test2.get_data(['DiskSize']).values[:,0].sum()
for i in cuts:
rm, gm, pm = ReleaseMemory2(cut = i)
released_memory.append(rm)
good_memory.append(gm)
part_of_good_memory.append(pm)
print 'all_memory = ', all_memory
print 'memory_can_be_free = ', memory_can_be_free
plt.subplot(1,1,1)
plt.plot(cuts, released_memory, 'b', label = 'released memory')
plt.plot(cuts, good_memory, 'r', label = 'good memory')
plt.legend(loc = 'best')
plt.show()
plt.subplot(1,1,1)
plt.plot(cuts, part_of_good_memory, 'r', label = 'part of good memory')
plt.legend(loc = 'best')
plt.show()
def visualize_singular_values(args):
param_values = load_parameter_values(args.load_path)
for d in range(args.layers):
if args.rnn_type == 'lstm':
ws = param_values["/recurrentstack/lstm_" + str(d) + ".W_state"]
w_rec = ws[:, 3 * args.state_dim:]
elif args.rnn_type == 'simple':
w_rec = param_values["/recurrentstack/simplerecurrent_" + str(d) +
".W_state"]
else:
raise NotImplementedError
U, s, V = np.linalg.svd(w_rec, full_matrices=True)
plt.subplot(2, 1, 1)
plt.plot(np.arange(s.shape[0]), s, label='Layer_' + str(d))
plt.grid(True)
plt.legend(loc='upper right')
plt.title("Singular_values_of_recurrent_weights")
plt.subplot(2, 1, 2)
plt.plot(np.arange(s.shape[0]), np.log(s + 1E-15),
label='Layer_' + str(d))
plt.grid(True)
plt.title("Log_singular_values_of_recurrent_weights")
plt.tight_layout()
plt.savefig(args.save_path + "/visualize_singular_values.png")
logger.info("Figure \"visualize_singular_values"
".png\" saved at directory: " + args.save_path)
def make_intergenerational_figure(data, lowerbound, upperbound, rows, title):
plt.figure(figsize=(10,10))
plt.suptitle(title,fontsize=20)
for index in range(4):
plt.subplot(2,2,index+1)
#simulation distribution
plt.hist(accepted[:,rows[index]], normed=True, bins = range(0,100,5), color = col)
#simulation values
value = np.mean(accepted[:,rows[index]])
std = 2*np.std(accepted[:,rows[index]])
plt.errorbar((value,), (red_marker_location-0.02), xerr=((std,),(std,)),
color=col, fmt='o', linewidth=2, capsize=5, mec = col)
#survey values
value = data[index]
lb = lowerbound[index]
ub = upperbound[index]
plt.errorbar((value,), (red_marker_location,), xerr=((value-lb,),(ub-value,)),
color='r', fmt='o', linewidth=2, capsize=5, mec = 'r')
#labeling
plt.ylim(0,ylimit)
plt.xlim(0,100)
#make subplots pretty
plt.subplot(2,2,1)
plt.title("Males")
plt.ylabel("'05\nFrequency")
plt.subplot(2,2,2)
plt.title("Females")
plt.subplot(2,2,3)
plt.ylabel("'08\nFrequency")
plt.xlabel("Percent Responding Affirmatively")
plt.subplot(2,2,4)
plt.xlabel("Percent Responding Affirmatively")
def subplot(self,names,title=None,style=None):
assert isinstance(names,list)
fig = plt.figure()
if title is None:
if isinstance(names,str):
title = names
else:
assert isinstance(names,list)
if len(names) == 1:
title = names[0]
else:
title = str(names)
fig.canvas.set_window_title(str(title))
plt.clf()
n = len(names)
if style is None:
style = [None]*n
for k,name in enumerate(names):
plt.subplot(n,1,k+1)
if k==0:
self._plot(name,title,style=style[k])
else:
self._plot(name,None,style=style[k])
def plotMultiGameTaskResults(directory, game, numTasks = 2):
filename = directory + game
fullShareResultsFilename = filename + "_fullShare.csv"
layerShareResultsFilename = filename + "_layerShare.csv"
repShareResultsFilename = filename + "_repShare.csv"
games = game.split(",")
if len(games) != numTasks:
print "The number of games is not equal to the number of tasks - not plotting"
return
fullResults = getResultsFromFile(fullShareResultsFilename, numTasks)
layerResults = getResultsFromFile(layerShareResultsFilename, numTasks)
repResults = getResultsFromFile(repShareResultsFilename, numTasks)
# figure = plt.figure()
# subplot = figure.add_subplot(111)
# plots = []
# for i in xrange(numTasks):
# plots.append(subplot.plot(fullResults[0][0:len(fullResults[1][i])], fullResults[1][i], label="FullShare: " + str(i)))
# figure.suptitle(title)
for i in xrange(len(games)):
plt.figure(i + 1)
plt.subplot(111)
plt.plot(fullResults[0][0:len(fullResults[1][i])], fullResults[1][i], label="Full Share")
plt.plot(layerResults[0][0:len(layerResults[1][i])], layerResults[1][i], label="Layer Share")
plt.plot(repResults[0][0:len(repResults[1][i])], repResults[1][i], label="Rep Share")
plt.xlabel('epochs')
plt.ylabel('Average Reward')
plt.title(games[i])
L = plt.legend()
L.draggable(state=True)
def plot_energies(energies,
bulk_window=None, coda_window=None, downsample_to=None,
xlim_lin=None, xlim_log=None,
figsize=None, **kwargs):
gs = gridspec.GridSpec(2 * len(energies), 2)
gs.update(wspace=0.05)
fig = plt.figure(figsize=figsize)
sax1 = sax3 = None
for i, tr in enumerate(energies):
pair = get_pair(tr)
otime = tr.stats.origintime
if downsample_to is None:
d = 1
else:
d = tr.stats.sampling_rate // downsample_to
ts = np.arange(len(tr)) * tr.stats.delta
ts = ts - (otime - tr.stats.starttime)
c = 'k'
ax2 = plt.subplot(gs[2 * i + 1, 0], sharex=sax1, sharey=sax1)
ax1 = plt.subplot(gs[2 * i, 0], sharex=ax2)
ax3 = plt.subplot(gs[2 * i:2 * i + 2, 1], sharex=sax3, sharey=sax3)
ax1.annotate('%s' % pair[1], (1, 0.5), (-10, 0), 'axes fraction',
'offset points', size='small', ha='right', va='center')
ax3.annotate('%s' % pair[0], (0, 1), (10, -5), 'axes fraction',
'offset points', size='small', ha='left', va='top')
ax1.plot(ts[::d], tr.data[::d], color=c)
ax2.semilogy(ts[::d], tr.data[::d], color=c)
ax3.loglog(ts[::d], tr.data[::d], color=c)
for ax in (ax1, ax2, ax3):
plt.setp(ax.get_xticklabels(), visible=False)
ax.set_yticklabels([])
if 'ponset' in tr.stats:
tponset = tr.stats.ponset - otime
ax.axvline(tponset, color='green', alpha=0.5)
if 'sonset' in tr.stats:
tsonset = tr.stats.sonset - otime
ax.axvline(tsonset, color='b', alpha=0.5)
for ax in (ax2, ax3):
if bulk_window and coda_window:
c = ('b', 'k')
wins = (bulk_window[pair], coda_window[pair])
for i, win in enumerate(wins):
ax.axvspan(win[0] - otime, win[1] - otime,
0.05, 0.08, color=c[i], alpha=0.5)
if sax1 is None:
sax1 = ax2
sax3 = ax3
if xlim_lin:
ax1.set_xlim(xlim_lin)
if xlim_log:
ax3.set_xlim(xlim_log)
loglocator = mpl.ticker.LogLocator(base=100)
ax2.yaxis.set_major_locator(loglocator)
ax3.yaxis.set_major_locator(loglocator)
ax2.yaxis.set_minor_locator(mpl.ticker.NullLocator())
ax3.yaxis.set_minor_locator(mpl.ticker.NullLocator())
plt.setp(ax2.get_xticklabels(), visible=True)
plt.setp(ax3.get_xticklabels(), visible=True)
_savefig(fig, **kwargs)
def infraCurve(self):
if not hasattr(self, "current_lin_Ro"):
if self.prefs.debug:
print(
printMessage("warning"),
" Run a search for overpressure or period first before plotting a point!"
)
errorMessage(
"No points to plot!",
1,
detail=
'Please use one of the searches to find Ro for both weak-shock and linear!'
)
return None
if not self.current_lin_Ro is None and not self.current_ws_Ro is None and not self.current_height is None:
self.bam.infra_curve.append(
[self.current_lin_Ro, self.current_ws_Ro, self.current_height])
if len(self.bam.infra_curve) == 0:
errorMessage("No points to plot!",
1,
detail='Please use one of the searches to find Ro!')
return None
ax1 = plt.subplot(2, 1, 1)
E_lin = []
E_ws = []
for point in self.bam.infra_curve:
h = point[2]
E_lin.append(Efunction(point[0], h))
E_ws.append(Efunction(point[1], h))
ax1.scatter(h / 1000, E_lin, label='Linear')
ax1.scatter(h / 1000, E_ws, label="Weak Shock")
ax1.set_xlabel("Height [km]")
ax1.set_ylabel("Energy per Unit Length [J/m]")
ax2 = plt.subplot(2, 1, 2, sharex=ax1)
light_curve = readLightCurve(self.bam.setup.light_curve_file)
light_curve_list = processLightCurve(light_curve)
for L in light_curve_list:
ax2.scatter(L.h, L.M, label=L.station)
# light_curve_curve = pg.ScatterPlotItem(x=L.M, y=L.t)
# self.light_curve_canvas.addItem(light_curve_curve)
ax2.set_xlabel("Height [km]")
ax2.set_ylabel("Absolute Magnitude")
plt.gca().invert_yaxis()
plt.legend()
# ax3 = plt.subplot(3, 1, 3, sharex=ax2)
# v = self.bam.setup.trajectory.v
# ax3.scatter(np.array(h)/1000, np.array(E_lin)/v, label='Linear')
# ax3.scatter(np.array(h)/1000, np.array(E_ws)/v, label="Weak Shock")
# for L in light_curve_list:
# ax3.scatter(L.h, 10**(-0.4*np.array(L.M)), label=L.station)
# ax3.set_xlabel("Height [km]")
# ax3.set_ylabel("?? Max Intensity ??")
# plt.legend()
plt.show()
return_sequences=True,
stateful=True))
model.add(LSTM(50,
return_sequences=False,
stateful=True))
model.add(Dense(1))
model.compile(loss='mse', optimizer='rmsprop')
print('Training')
for i in range(epochs):
print('Epoch', i, '/', epochs)
model.fit(cos,
expected_output,
batch_size=batch_size,
verbose=1,
nb_epoch=1,
shuffle=False)
model.reset_states()
print('Predicting')
predicted_output = model.predict(cos, batch_size=batch_size)
print('Plotting Results')
plt.subplot(2, 1, 1)
plt.plot(expected_output)
plt.title('Expected')
plt.subplot(2, 1, 2)
plt.plot(predicted_output)
plt.title('Predicted')
plt.show()
import cv2 as cv
import matplotlib.pyplot as plt
import numpy as np
# 读取图像
source = cv.imread('demo.png', cv.IMREAD_GRAYSCALE)
# 设置卷积核
kernel = np.ones((5, 5), np.uint8)
# 图像腐蚀
erode_img = cv.erode(source, kernel)
# 图像膨胀
dilate_result = cv.dilate(source, kernel)
# 显示结果
titles = ['Source Img', 'Erode Img', 'Dilate Img']
images = [source, erode_img, dilate_result]
# matplotlib 绘图
for i in range(3):
plt.subplot(1, 3, i + 1), plt.imshow(images[i], 'gray')
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
def plot_spectra(freqs,
fluxes,
errs,
models,
names,
params,
param_errs,
rcs,
BICs,
colours,
labels,
figname,
annotate=True,
model_selection='better'):
"""Plot a figure of the radio spectra of an individual source, according to the input data and models.
Arguments:
----------
freqs : list
A list of frequencies in MHz.
fluxes : list
A list of fluxes in Jy.
errs : list
A list of flux uncertainties in Jy.
models : list
A list of functions corresponding to models of the radio spectrum.
names : 2D list
A list of fitted parameter names corresponding to each model above.
params : 2D list
A list of fitted parameter values corresponding to each model above.
param_errs : 2D list
A list of uncertainties on the fitted parameters corresponding to each model above.
rcs : list
A list of reduced chi squared values corresponding to each model above.
BICs : list
A list of Bayesian Information Criteria (BIC) values corresponding to each model above.
colours : list
A list of colours corresponding to each model above.
labels : list
A list of labels corresponding to each model above.
figname : string
The filename to give the figure when writing to file.
Keyword arguments:
------------------
annotate : bool
Annotate fit info onto figure.
model_selection : string
How to select models for plotting, based on the BIC values. Options are:
'best' - only plot the best model.
'all' - plot all models.
'better' - plot each model better than the previous, chronologically."""
#create SEDs directory if doesn't already exist
if not os.path.exists('SEDs'):
os.mkdir('SEDs')
fig = plt.figure()
ax = plt.subplot()
#plot frequency axis 20% beyond range of values
xlin = np.linspace(min(freqs) * 0.8, max(freqs) * 1.2, num=5000)
plt.ylabel(r'Flux Density $S$ (mJy)')
plt.xlabel(r'Frequency $\nu$ (GHz)')
plt.xscale('log')
plt.yscale('log')
#adjust the tick values and add grid lines at minor tick locations
subs = [1.0, 2.0, 5.0]
ax.xaxis.set_major_locator(ticker.LogLocator(subs=subs))
ax.yaxis.set_major_locator(ticker.LogLocator(subs=subs))
ax.xaxis.set_minor_formatter(ticker.NullFormatter())
ax.yaxis.set_minor_formatter(ticker.NullFormatter())
ax.xaxis.set_major_formatter(ticker.FuncFormatter(ticks_format_freq))
ax.yaxis.set_major_formatter(ticker.FuncFormatter(ticks_format_flux))
ax.grid(b=True, which='minor', color='w', linewidth=0.5)
#plot flux measurements
plt.errorbar(freqs,
fluxes,
yerr=errs,
linestyle='none',
marker='.',
c='r',
zorder=15)
best_bic = 0
dBIC = 3
offset = 0
plotted_models = 0
#plot each model
for i in range(len(models)):
ylin = models[i](xlin, *params[i])
txt = "{0}:\n {1}".format(labels[i],
r'$\chi^2_{\rm red} = %.1f$' % rcs[i])
#compare BIC values
bic = BICs[i]
if i > 0:
dBIC = best_bic - bic
if model_selection != 'best':
txt += ', {0}'.format(r'$\Delta{\rm BIC} = %.1f$' % (dBIC))
if dBIC >= 3:
best_bic = bic
#plot model if selected according to input
if model_selection == 'all' or (model_selection == 'better' and dBIC >=
3) or (model_selection == 'best'
and BICs[i] == min(BICs)):
plotted_models += 1
plt.plot(xlin,
ylin,
c=colours[i],
linestyle='--',
zorder=i + 1,
label=labels[i])
plt.legend(scatterpoints=1,
fancybox=True,
frameon=True,
shadow=True)
txt += '\n'
#add each fitted parameter to string (in LaTeX format)
for j, param in enumerate(names[i]):
units = ''
tokens = param.split('_')
if len(tokens[0]) > 1:
tokens[0] = "\\" + tokens[0]
if len(tokens) > 1:
param = r'%s_{\rm %s}' % (tokens[0], tokens[1])
else:
param = tokens[0]
val = params[i][j]
err = param_errs[i][j]
if param.startswith('S'):
units = 'Jy'
if val < 0.01:
val = val * 1e3
err = err * 1e3
units = 'mJy'
elif 'nu' in param:
units = 'MHz'
if val > 100:
val = val / 1e3
err = err / 1e3
units = 'GHz'
val = sig_figs(val)
err = sig_figs(err)
txt += ' ' + r'${0}$ = {1} $\pm$ {2} {3}'.format(
param, val, err, units) + '\n'
#annotate all fit info if it will fit on figure
if annotate and plotted_models <= 3:
plt.text(offset,
0,
txt,
horizontalalignment='left',
verticalalignment='bottom',
transform=ax.transAxes)
offset += 0.33
#write figure and close
plt.savefig('SEDs/{0}'.format(figname))
plt.close()
#%%
'''test data 분석'''
Atest_ = Atest_.toarray().reshape(-1, PARAMS['keywords'], PARAMS['keywords'])[:, di[0], di[1]]
test_words = []
for i in range(len(Atest_)):
test_words.append([keywords[w] for w in np.where(Atest_[i, :] == 1)[0]])
# test words save
with open("./result/test_words.txt", "w") as f:
for w in test_words:
f.write(' '.join(w) + '\n')
plt.figure(figsize=(20, 20))
for j in range(10):
plt.subplot(5, 2, j+1)
count = {x:0 for x in keywords}
temp = sum(test_words[100*j:100*(j+1)], [])
for i in range(len(temp)):
count[temp[i]] = count.get(temp[i]) + 1
plt.bar(range(len(count)), list(count.values()), align='center')
plt.xticks(size = 20)
plt.yticks(size = 20)
plt.title('{}월'.format(j+1), fontsize=30)
# plt.xticks(range(len(count)), list(count.keys()))
plt.tight_layout()
plt.savefig('./result/test_freq.png',
dpi=200, bbox_inches="tight", pad_inches=0.1)
plt.show()
#%%
# reconstruction
self.plot_psf(U)
if __name__ == '__main__':
# handy object for plotting the PSF
psfplot = PSFPlot()
# beta (diffraction-limited), N_beta = cpsf.czern.nk
beta = np.zeros(psfplot.cpsf.czern.nk, dtype=np.complex)
beta[0] = 1.0
beta[5] = 1j*0.3
beta[6] = -1j*0.3
# plot the results
nn, mm = 2, math.ceil(psfplot.fspace.size//2)
p.figure(1)
for fi, f in enumerate(psfplot.fspace):
ax = p.subplot(nn, mm, fi + 1)
# plot the psf
psfplot.plot_beta_f(beta, fi)
p.colorbar()
# defocus in rad
p.title('d={:.1f}'.format(enz.get_defocus(f)))
p.tight_layout()
p.show()
# plt.figure()
# librosa.display.waveplot(y=samples, sr=sampling_rate)
# plt.xlabel("time (seconds) -->")
# plt.ylabel("amplitude")
# plt.show()
D = librosa.stft(y)
D_harmonic, D_percussive = librosa.decompose.hpss(D)
# Pre-compute a global reference power from the input spectrum
rp = np.max(np.abs(D))
plt.figure(figsize=(12, 8))
plt.subplot(3, 1, 1)
librosa.display.specshow(librosa.amplitude_to_db(np.abs(D), ref=rp), y_axis='log')
plt.colorbar()
plt.title('Full spectrogram')
plt.subplot(3, 1, 2)
librosa.display.specshow(librosa.amplitude_to_db(np.abs(D_harmonic), ref=rp), y_axis='log')
plt.colorbar()
plt.title('Harmonic spectrogram')
plt.subplot(3, 1, 3)
librosa.display.specshow(librosa.amplitude_to_db(np.abs(D_percussive), ref=rp), y_axis='log',
x_axis='time')
plt.colorbar()
plt.title('Percussive spectrogram')
plt.tight_layout()
def __repr__(self):
# TODO: Currently plotting the wrong number of facets.
if self.facet_type=="grid":
fig, axs = plt.subplots(self.n_high, self.n_wide,
sharex=True, sharey=True)
plt.subplots_adjust(wspace=.05, hspace=.05)
elif self.facet_type=="wrap":
subplots_available = self.n_wide * self.n_high
extra_subplots = subplots_available - self.n_dim_x
fig, axs = plt.subplots(self.n_high, self.n_wide)
for extra_plot in axs.flatten()[-extra_subplots:]:
extra_plot.axis('off')
# TODO: This isn't working
plots = [None for i in range(self.n_dim_x)]
for i in range(self.n_dim_x):
idx = (i % self.n_high) * self.n_wide + (i % self.n_wide)
plots[idx] = (i % self.n_wide, i % self.n_high)
plots = [plot for plot in plots if plot is not None]
plots = sorted(plots, key=lambda x: x[1] + x[0] * self.n_high + 1)
else:
fig, axs = plt.subplots(self.n_high, self.n_wide)
plt.subplot(self.n_wide, self.n_high, 1)
# Faceting just means doing an additional groupby. The
# dimensions of the plot remain the same
if self.facets:
cntr = 0
if len(self.facets)==2:
for facets, frame in self.data.groupby(self.facets):
pos = self.facet_pairs.index(facets) + 1
plt.subplot(self.n_wide, self.n_high, pos)
for layer in self._get_layers(frame):
for geom in self.geoms:
callbacks = geom.plot_layer(layer)
# This needs to enumerate all possibilities
for pos, facets in enumerate(self.facet_pairs):
pos += 1
if pos <= self.n_high:
plt.subplot(self.n_wide, self.n_high, pos)
plt.table(cellText=[[facets[1]]], loc='top',
cellLoc='center', cellColours=[['lightgrey']])
if (pos % self.n_high)==0:
plt.subplot(self.n_wide, self.n_high, pos)
x = max(plt.xticks()[0])
y = max(plt.yticks()[0])
ax = axs[pos % self.n_high][pos % self.n_wide]
plt.text(x*1.025, y/2., facets[0],
bbox=dict(facecolor='lightgrey', color='black'),
fontdict=dict(rotation=-90, verticalalignment="center")
)
plt.subplot(self.n_wide, self.n_high, pos)
# Handle the different scale types here (free|free_y|free_x|None) and
# also make sure that only the left column gets y scales and the bottom
# row gets x scales
scale_facet(self.n_wide, self.n_high, self.facet_pairs, self.facet_scales)
else:
for facet, frame in self.data.groupby(self.facets):
for layer in self._get_layers(frame):
for geom in self.geoms:
if self.facet_type=="wrap":
if cntr+1 > len(plots):
continue
pos = plots[cntr]
if pos is None:
continue
y_i, x_i = pos
pos = x_i + y_i * self.n_high + 1
plt.subplot(self.n_wide, self.n_high, pos)
else:
plt.subplot(self.n_wide, self.n_high, cntr)
# TODO: this needs some work
if (cntr % self.n_high)==-1:
plt.tick_params(axis='y', which='both',
bottom='off', top='off',
labelbottom='off')
callbacks = geom.plot_layer(layer)
if callbacks:
for callback in callbacks:
fn = getattr(axs[cntr], callback['function'])
fn(*callback['args'])
#TODO: selective titles
plt.title(facet)
cntr += 1
else:
for layer in self._get_layers(self.data):
for geom in self.geoms:
plt.subplot(1, 1, 1)
callbacks = geom.plot_layer(layer)
if callbacks:
for callback in callbacks:
fn = getattr(axs, callback['function'])
fn(*callback['args'])
# Handling the details of the chart here; probably be a better
# way to do this...
if self.title:
plt.title(self.title)
if self.xlab:
if self.facet_type=="grid":
fig.text(0.5, 0.025, self.xlab)
else:
plt.xlabel(self.xlab)
if self.ylab:
if self.facet_type=="grid":
fig.text(0.025, 0.5, self.ylab, rotation='vertical')
else:
plt.ylabel(self.ylab)
if self.xmajor_locator:
plt.gca().xaxis.set_major_locator(self.xmajor_locator)
if self.xtick_formatter:
plt.gca().xaxis.set_major_formatter(self.xtick_formatter)
fig.autofmt_xdate()
if self.xbreaks: # xbreaks is a list manually provided
plt.gca().xaxis.set_ticks(self.xbreaks)
if self.xtick_labels:
plt.gca().xaxis.set_ticklabels(self.xtick_labels)
if self.ytick_formatter:
plt.gca().yaxis.set_major_formatter(self.ytick_formatter)
if self.xlimits:
plt.xlim(self.xlimits)
if self.ylimits:
plt.ylim(self.ylimits)
if self.scale_y_reverse:
plt.gca().invert_yaxis()
if self.scale_x_reverse:
plt.gca().invert_xaxis()
# TODO: Having some issues here with things that shouldn't have a legend
# or at least shouldn't get shrunk to accomodate one. Need some sort of
# test in place to prevent this OR prevent legend getting set to True.
if self.legend:
if self.facets:
if 1==2:
ax = axs[0][self.n_wide]
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
cntr = 0
for ltype, legend in self.legend.items():
lname = self.aesthetics.get(ltype, ltype)
ax.add_artist(draw_legend(ax, legend, ltype, lname, cntr))
cntr += 1
else:
box = axs.get_position()
axs.set_position([box.x0, box.y0, box.width * 0.8, box.height])
cntr = 0
for ltype, legend in self.legend.items():
if legend:
lname = self.aesthetics.get(ltype, ltype)
axs.add_artist(draw_legend(axs, legend, ltype, lname, cntr))
cntr += 1
# TODO: We can probably get more sugary with this
return "<ggplot: (%d)>" % self.__hash__()
def draw_mix_u(d, navi_u, tele_u, mix_u, gain):
fig = plt.figure(figsize=(10, 3))
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 2])
ax1 = plt.subplot(gs[0])
ds = 0.4
epsilon = 0.1
dd = [-ds + i * 0.005 for i in range(200)]
gg = [rho(ddi) / (rho(ddi) + rho(epsilon - ddi)) for ddi in dd]
ax1.plot(dd,
gg,
color='k',
linestyle='-',
linewidth=3,
label=r'$\kappa(\cdot)$')
ax1.set_xlabel(r'$d_t-d_s(m)$', fontsize=20)
ax1.legend(loc=(.55, .62),
labelspacing=0.7,
numpoints=3,
handlelength=2.5,
ncol=1,
prop={'size': 15})
ax1.set_xlim(dd[0], dd[-1])
ax1.grid()
ax2 = plt.subplot(gs[1])
ax2.plot(d,
navi_u,
color='r',
linestyle='-',
linewidth=3,
marker='o',
mfc='r',
fillstyle='full',
markersize=6,
label=r'$u_r$')
ax2.plot(d,
tele_u,
color='g',
linestyle='-',
linewidth=3,
marker='d',
mfc='g',
fillstyle='full',
markersize=6,
label=r'$u_h$')
ax2.plot(d,
mix_u,
color='b',
linestyle='-',
linewidth=3,
marker='>',
mfc='b',
fillstyle='full',
markersize=6,
label=r'$u$')
ax2.plot(d,
gain,
color='k',
linestyle='-',
linewidth=3,
marker='*',
mfc='k',
fillstyle='full',
markersize=6,
label=r'$\kappa$')
ax2.set_xlabel(r'$d_t(m)$', fontsize=20)
ax2.legend(loc=(.6, .62),
numpoints=3,
handlelength=2.0,
ncol=2,
prop={'size': 15})
ax2.set_xlim(0, d[-1] + 0.01)
ax2.grid()
fig.tight_layout()
plt.savefig('mix_u.pdf', bbox_inches='tight')
return fig
ACF, J2 = [], []
energy = []
for step in range(nsteps):
x = MATRIX(1, 1)
x.set(0, 0, s1_energy[step])
energy.append(x)
Tij, ACFij, uACFij, Wij, Jij, J2ij = infsp.recipe1(energy, params2)
ACF.append(ACFij)
J2.append(np.array(J2ij))
plt.figure(num=None,
figsize=(3.21, 2.41),
dpi=300,
edgecolor='black',
frameon=True)
plt.subplot(1, 1, 1)
plt.title('S1 Energy', fontsize=10) # traj'+str(subtraj)+'', fontsize=10)
plt.xlabel('Times, fs', fontsize=10)
plt.ylabel('Energy, eV', fontsize=10)
plt.plot(range(nsteps), s1_energy, label="", linewidth=1)
plt.tight_layout()
#plt.ylim(0,3)
#plt.legend(fontsize=8, ncol=3, loc="lower left")
plt.savefig("S1.png", dpi=300)
plt.figure(num=None,
figsize=(3.21, 2.41),
dpi=300,
edgecolor='black',
frameon=True)
plt.subplot(1, 1, 1)
signal = macd.ewm(span=45).mean()
macdhist = macd - signal
df = df.assign(ema130=ema130, ema60=ema60, macd=macd, signal=signal, macdhist=macdhist).dropna()
df['number'] = df.index.map(mdates.date2num)
ohlc = df[['number','open','high','low','close']]
ndays_high = df.high.rolling(window=14, min_periods=1).max()
ndays_low = df.low.rolling(window=14, min_periods=1).min()
fast_k = (df.close - ndays_low) / (ndays_high - ndays_low) * 100
slow_d = fast_k.rolling(window=3).mean()
df = df.assign(fast_k = fast_k, slow_d = slow_d).dropna()
plt.figure(figsize=(9, 9))
p1 = plt.subplot(3,1,1)
plt.title('Triple Screen Trading (NCSOFT)')
plt.grid(True)
candlestick_ohlc(p1,ohlc.values, width=.6, colorup='red', colordown='blue')
p1.xaxis.set_major_formatter(mdates.DateFormatter('%X-%m'))
plt.plot(df.number, df['ema130'], color='c', label='EMA130')
for i in range(1,len(df.close)):
if df.ema130.values[i-1] < df.ema130.values[i] and \
df.slow_d.values[i-1] >= 20 and df.slow_d.values[i] < 20:
plt.plot(df.number.values[i], 250000, 'r^')
elif df.ema130.values[i-1] > df.ema130.values[i] and \
df.slow_d.values[i-1] <= 80 and df.slow_d.values[i] > 80:
plt.plot(df.number.values[i],250000,'bv')
plt.legend(loc='best')
p2=plt.subplot(3,1,2)
plt.figure()
plt.imshow(image, cmap=plt.cm.binary)
plt.colorbar()
plt.grid(False)
plt.show()
# %%
"""
Display the first 25 images from the *training set* and display the class name below each image. Verify that the data is in the correct format and we're ready to build and train the network.
"""
# %%
plt.figure(figsize=(10, 10))
for i, (image, label) in enumerate(test_dataset.take(25)):
image = image.numpy().reshape((28, 28))
plt.subplot(5, 5, i + 1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(image, cmap=plt.cm.binary)
plt.xlabel(class_names[label])
plt.show()
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
tf.keras.layers.Dense(128, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
"""
'Epoch: %d' % (epoch + 1),
'DiscriminatorA Loss= %f,DiscriminatorB Loss= %f, Generator Loss= %f, Avg Loss=%f'
% (DA_loss_curr, DB_loss_curr, G_loss_curr, avg_loss))
losses.append((DA_loss_curr, DB_loss_curr, G_loss_curr, avg_loss))
# 100 에폭마다 변형되는 이미지 그림
if (epoch + 1) % 100 == 0:
samples_A = sess.run(X_BA, feed_dict={X_B: XB})
samples_B = sess.run(X_AB, feed_dict={X_A: XA})
# 도메인 A의 test 이미지
f, axes = plt.subplots(figsize=(7, 7),
nrows=1,
ncols=2,
sharey=True,
sharex=True)
for ii in range(2):
plt.subplot(1, 2, ii + 1)
plt.suptitle('Domain A')
plt.imshow(XA[ii].reshape(45, 40), 'Greys_r')
# G_AB(X_A) 결과
f, axes = plt.subplots(figsize=(7, 7),
nrows=1,
ncols=2,
sharey=True,
sharex=True)
for ii in range(2):
plt.subplot(1, 2, ii + 1)
plt.suptitle('Result of G_AB')
plt.imshow(samples_B[ii].reshape(40, 45), 'Greys_r')
# 도메인 B의 test 이미지
f, axes = plt.subplots(figsize=(7, 7),
nrows=1,
def DrawFig( figureFile, distance, leftIden, rigthIden, aveIden, nr, aa, bb, test ) :
fig = plt.figure( num=None, figsize=(16, 18), facecolor='w', edgecolor='k' )
plt.subplot(321)
"""
from matplotlib.colors import LogNorm
plt.hist2d(test[:,4], test[:,5], bins=50, norm=LogNorm())
plt.plot(test[:,0], test[:,1], 'co')
"""
plt.title('Distance distribution', fontsize=16)
plt.plot(distance[:,0] , 100 * distance[:,1]/np.sum(distance[:,1]) , 'ro-' )
plt.xlabel('The breakpoints of varints span on assemble sequence(%)', fontsize=16)
plt.ylabel('% of Number', fontsize=16)
plt.subplot(322)
plt.title('Left Side', fontsize=16)
plt.plot(leftIden[:,0] , leftIden[:,2]/np.sum(leftIden[:,1]) , 'go-' )
plt.axis([0,100,0.0,1.0])
plt.xlabel('Left Side Identity of varints(<=%)', fontsize=16)
plt.ylabel('% of Accumulate', fontsize=16)
plt.subplot(323)
plt.title('Right Side', fontsize=16)
plt.plot(rigthIden[:,0], rigthIden[:,2]/np.sum(rigthIden[:,1]), 'bo-' )
plt.axis([0,100,0.0,1.0])
plt.xlabel('Right Side Identity of varints(<=%)', fontsize=16)
plt.ylabel('% of Accumulate', fontsize=16)
plt.subplot(324)
plt.title('Averge', fontsize=16)
plt.plot(aveIden[:,0] , aveIden[:,2]/np.sum(aveIden[:,1]) , 'co-' )
plt.axis([0,100,0.0,1.0])
plt.xlabel('Averge Identity of varints(<=%)', fontsize=16)
plt.ylabel('% of Accumulate', fontsize=16)
plt.subplot(325)
plt.title('N Ratio', fontsize=16)
plt.plot(nr[:,0], nr[:,2]/np.sum(nr[:,1]), 'yo-' )
plt.axis([0,5,0.0,1.0])
plt.xlabel('N Ratio of varints\' regions(>=%)', fontsize=16)
plt.ylabel('% of Accumulate', fontsize=16)
plt.subplot(6,2,10)
plt.plot(aa[:,0], aa[:,2]/np.sum(aa[:,1]), 'mo-' )
plt.axis([0,100,0.0,1.0])
plt.xlabel('Perfect Depth(<=)', fontsize=12)
plt.ylabel('% of Accumulate', fontsize=16)
plt.subplot(6,2,12)
plt.plot(bb[:,0], bb[:,2]/np.sum(bb[:,1]), 'ko-' )
plt.axis([0,100,0.0,1.0])
plt.xlabel('Both ImPerfect Depth(<=)', fontsize=12)
plt.ylabel('% of Accumulate', fontsize=16)
fig.savefig(figureFile + '.png')
images /= 255
return images, labels
train_dataset = train_dataset.map(normalize)
test_dataset = test_dataset.map(normalize)
for image, label in test_dataset.take(1):
break
image = image.numpy().reshape((28,28))
# 显示前25张图片，在每张图片下显示类别
plt.figure(figsize=(10,10))
i = 0
for (image, label) in test_dataset.take(25):
image = image.numpy().reshape((28,28))
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.imshow(image, cmap=plt.cm.binary)
plt.xlabel(class_names[label])
i += 1
plt.savefig('./Clothing2.png')
plt.show()
for step in range(1000000):
org_im, im, em = q.get()
ls = sess.run(train_op, feed_dict={image: im, label: em})
print(ls)
if step % 1 == 0:
ls, er, out, stp, v2, v5, v1 = sess.run(
[train_op, error, out_put, global_step, dv2, dv5, con3],
feed_dict={
image: im,
label: em
})
if step % 1 == 0:
for s in range(8):
plt.subplot(221)
plt.title('original')
plt.imshow(org_im[s, :, :, :], aspect="auto")
plt.subplot(222)
plt.title('step1')
plt.imshow(v1[s, :, :, 0], aspect="auto", cmap='gray')
plt.subplot(223)
plt.title('step2')
plt.imshow(v2[s, :, :, 0], aspect="auto", cmap='gray')
plt.subplot(224)
plt.title('final')
plt.imshow(out[s, :, :, 0], aspect="auto", cmap='gray')
plt.show()
"""
===============
Demo Gridspec02
===============
"""
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
def make_ticklabels_invisible(fig):
for i, ax in enumerate(fig.axes):
ax.text(0.5, 0.5, "ax%d" % (i+1), va="center", ha="center")
ax.tick_params(labelbottom=False, labelleft=False)
fig = plt.figure()
gs = GridSpec(3, 3)
ax1 = plt.subplot(gs[0, :])
# identical to ax1 = plt.subplot(gs.new_subplotspec((0, 0), colspan=3))
ax2 = plt.subplot(gs[1, :-1])
ax3 = plt.subplot(gs[1:, -1])
ax4 = plt.subplot(gs[-1, 0])
ax5 = plt.subplot(gs[-1, -2])
fig.suptitle("GridSpec")
make_ticklabels_invisible(fig)
plt.show()
import cv2
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
from matplotlib import pyplot as plt
img = cv2.imread('line5.jpeg', 0)
# Output dtype = cv2.CV_8U
sobelx8u = cv2.Sobel(img, cv2.CV_8U, 1, 0, ksize=3)
# Output dtype = cv2.CV_64F. Then take its absolute and convert to cv2.CV_8U
sobelx64f = cv2.Sobel(img, cv2.CV_64F, 2, 0, ksize=3)
abs_sobel64f = np.absolute(sobelx64f)
sobel_8u = np.uint8(abs_sobel64f)
plt.subplot(1, 3, 1), plt.imshow(img, cmap='gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(1, 3, 2), plt.imshow(sobelx8u, cmap='gray')
plt.title('Sobel 1'), plt.xticks([]), plt.yticks([])
plt.subplot(1, 3, 3), plt.imshow(sobel_8u, cmap='gray')
plt.title('Sobel 2'), plt.xticks([]), plt.yticks([])
plt.show()
cv2.waitKey(0)
x_sample = mnist.test.next_batch(100)[0]
x_reconstruct = vae.reconstruct(x_sample)
training_epochs=10
#plotting reconstruct data
x = np.arange(0,training_epochs,1)
plt.title("Cost Graph")
plt.plot(x, new_cost)
plt.show()
#plotting the images before and after reconstruction
plt.figure(figsize=(8, 12))
for i in range(5):
plt.subplot(5, 2, 2*i + 1)
plt.imshow(x_sample[i].reshape(28, 28), vmin=0, vmax=1, cmap="gray")
plt.title("Test input")
plt.colorbar()
plt.subplot(5, 2, 2*i + 2)
plt.imshow(x_reconstruct[i].reshape(28, 28), vmin=0, vmax=1, cmap="gray")
plt.title("Reconstruction")
plt.colorbar()
plt.tight_layout()
plt.show()
#building the network to understand the latent space in 2d latent space
network_architecture = \
dict(n_hidden_recog_1=300, # 1st layer encoder neurons
file = open('./weights.txt', 'w') # 参数提取
for v in model.trainable_variables:
file.write(str(v.name) + '\n')
file.write(str(v.shape) + '\n')
file.write(str(v.numpy()) + '\n')
file.close()
############################################### show ###############################################
# 显示训练集和验证集的acc和loss曲线
acc = history.history['sparse_categorical_accuracy']
val_acc = history.history['val_sparse_categorical_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
def run_optical_flow(filepath_ind: int, param: int=500,
display: bool=True):
frame_1 = cv2.imread(filepaths[filepath_ind] + 'frame1.png')[:, :, :3]
frame_2 = cv2.imread(filepaths[filepath_ind] + 'frame2.png')[:, :, :3]
frame_1_gray = cv2.cvtColor(frame_1, cv2.COLOR_RGB2GRAY)
frame_2_gray = cv2.cvtColor(frame_2, cv2.COLOR_RGB2GRAY)
# Convert to grayscale for analysis
frame_1 = frame_1_gray.astype(float)
frame_2 = frame_2_gray.astype(float)
start_time = default_timer()
if display:
# Plot the images
plt.figure()
plt.imshow(frame_1, 'gray')
plt.figure()
plt.imshow(frame_2, 'gray')
# Initialize kernels for finding partial derivatives of the image
kernelx = np.array([[-1, 1], [-1, 1]])
kernely = np.array([[-1, -1], [1, 1]])
kernelt_1 = np.array([[1, 1], [1, 1]])
kernelt_2 = np.array([[-1, -1], [-1, -1]])
Ix = signal.convolve2d(frame_1, kernelx, mode='same')
Iy = signal.convolve2d(frame_2, kernely, mode='same')
It = signal.convolve2d(frame_1, kernelt_1, mode='same') + signal.convolve2d(frame_2, kernelt_2, mode='same')
# Create empty u and v matrices for recursion
u = np.zeros_like(frame_1)
v = np.zeros_like(frame_1)
# Alpha is the regulatory parameter
alpha_vals = np.array([1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 5e-4, 1e-3, 5e-3, 1e-2, 5e-2])
RMSE = np.zeros_like(alpha_vals)
count = 0
for alpha in alpha_vals:
u, v = horn_schunck(u, v, Ix, Iy, It, param, alpha)
end_time = default_timer()
# Determine run time
duration = end_time - start_time
clock = [int(duration // 60), int(duration % 60)]
print('Flow estimation time was {} minutes and {} seconds'
.format(*clock))
# Downsample for better visuals and results
stride = 10
m, n = frame_1.shape
x, y = np.meshgrid(range(n), range(m))
x = x.astype('float64')
y = y.astype('float64')
# Downsampled u and v
u_ds = u[::stride, ::stride]
v_ds = v[::stride, ::stride]
# Coordinates for downsampled u and v
x_ds = x[::stride, ::stride]
y_ds = y[::stride, ::stride]
# Estimated flow
estimated_flow = np.stack((u, v), axis=2)
# Read file for ground truth flow
ground_truth_flow = read_flow_file(filepaths[filepath_ind] + 'flow1_2.flo')
u_gt_orig = ground_truth_flow[:, :, 0]
v_gt_orig = ground_truth_flow[:, :, 1]
u_gt = np.where(np.isnan(u_gt_orig), 0, u_gt_orig)
v_gt = np.where(np.isnan(v_gt_orig), 0, v_gt_orig)
# Downsampled u_gt and v_gt
u_gt_ds = u_gt[::stride, ::stride]
v_gt_ds = v_gt[::stride, ::stride]
RMSE[count] = np.sqrt(np.sum(((u_ds - u_gt_ds) ** 2) + ((v_ds - v_gt_ds) ** 2)))
print(RMSE)
count = count + 1
plt.figure()
plt.semilogx(alpha_vals, RMSE)
plt.xlabel('Lambda Values')
plt.ylabel('Root Mean Squared Error')
plt.title('RMSE for Range of Lambda Values')
if display:
# Plot the optical flow field
plt.figure()
plt.subplot(1, 2, 1)
plt.imshow(frame_2, 'gray')
plt.quiver(x_ds, y_ds, u_ds, v_ds, color='r')
plt.title('Estimated', fontsize='x-small')
plt.subplot(1, 2, 2)
plt.imshow(frame_2, 'gray')
plt.quiver(x_ds, y_ds, u_gt_ds, v_gt_ds, color='r')
plt.title('Ground Truth', fontsize='x-small')
# Normalization for metric computations
normalize = lambda im: (im - np.min(im)) / (np.max(im) - np.min(im))
un = normalize(u)
un_gt = normalize(u_gt)
un_gt[np.isnan(u_gt_orig)] = 1
vn = normalize(v)
vn_gt = normalize(v_gt)
vn_gt[np.isnan(v_gt_orig)] = 1
if display:
plt.show()
return clock
fname = path + "/calibration_result/calibration_parameters.txt"
print(fname)
with open(fname, "w") as f:
f.write("{'ret':"+str(ret)+", 'mtx':"+str(list(mtx))+', "dist":'+str(list(dist))+'}')
f.close()
np.savetxt(imagesFolder+"calib_mtx_webcam.csv", mtx)
np.savetxt(imagesFolder+"calib_dist_webcam.csv", dist)
#imagesFolder = "data_image_detect/"
i=24 # select image id
plt.figure()
frame = cv2.imread(imagesFolder + "image_100.jpg".format(i))
img_undist = cv2.undistort(frame,mtx,dist,None)
plt.subplot(211)
plt.imshow(frame)
plt.title("Raw image")
plt.axis("off")
plt.subplot(212)
plt.imshow(img_undist)
plt.title("Corrected image")
plt.axis("off")
plt.show()
##Use of camera calibration to estimate 3D translation and rotation of each marker on a scene
imagesFolder = "src/ar_markers/src/data_image_detect/"
frame = cv2.imread(imagesFolder + "image_10.png")
plt.figure()
plt.imshow(frame)
plt.show()
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 17 18:04:55 2018
李立宗
"""
import numpy as np
import cv2
import matplotlib.pyplot as plt
img = cv2.imread(r'../image/lena.bmp',0)
dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT)
dftShift = np.fft.fftshift(dft)
result = 20*np.log(cv2.magnitude(dftShift[:,:,0],dftShift[:,:,1]))
plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('original'),plt.axis('off')
plt.subplot(122),plt.imshow(result, cmap = 'gray')
plt.title('result'), plt.axis('off')
plt.show()
print(dft)
import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('inu.jpg',0)
f = np.fft.fft2(img)
fshift = np.fft.fftshift(f)
magnitude_spectrum = 20*np.log(np.abs(fshift))
plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.savefig("figure1.png")
plt.show()
from handout import GaussianMixture1D
import scipy.stats as ss
np.random.seed(0)
gm1d = GaussianMixture1D(mode_range=(0, 50))
def trueDistributionCopied():
data = gm1d.sample([2000])
min_range = min(gm1d.modes) - 3 * gm1d.std_range[1]
max_range = max(gm1d.modes) + 3 * gm1d.std_range[1]
xs = np.linspace(min_range, max_range, 2000)
ys = np.zeros_like(xs)
for l, s, w in zip(gm1d.modes, gm1d.stds, gm1d.weights):
ys += ss.norm.pdf(xs, loc=l, scale=s) * w
plt.plot(xs, ys)
ax = plt.subplot(321)
knn(200,1)
trueDistribution()
ax = plt.subplot(322)
knn(200,6)
trueDistribution()
ax = plt.subplot(323)
knn(200,15)
trueDistribution()
ax = plt.subplot(324)
knn(200,30)
trueDistribution()
def graph_compare(df1, df2, freq, name1, name2, DFs=None):
t1 = []
for d in df1['t']:
t1.append(md.date2num(datetime.datetime.fromtimestamp(d/1000)))
t2 = []
for d in df2['t']:
t2.append(md.date2num(datetime.datetime.fromtimestamp(d/1000)))
fig = plt.figure(figsize=(12, 9))
gs = gridspec.GridSpec(3, 1, height_ratios=[1, 4, 1])
plt.rc('axes', grid=True)
ax2 = plt.subplot(gs[2])
ax2.set_title("Volume")
ax2.set_xlim(min(t1 + t2) - 100, max(t1 + t2) + 100)
ax0 = plt.subplot(gs[0], sharex=ax2)
ax0.set_title("spread")
ax1 = plt.subplot(gs[1], sharex=ax2)
ax1.set_title("px")
ax0.fill_between(t1, 0, df2['close'] - df1['close'], where=df2['close'] >= df1['close'], color='b', alpha=0.5)
ax0.fill_between(t1, 0, df2['close'] - df1['close'], where=df2['close'] <= df1['close'], color='y', alpha=0.5)
#plot the 1st line
ax1.plot(t1, df1['close'], color = 'y', linewidth=2)
#plot the other line
if name1[:3] == name2[:3]:
ax1.plot(t2, df2['close'], color = 'b', linewidth=2)
else:
ax1.set_ylabel(name1, color='y')
axt = ax1.twinx()
axt.plot(t2, df2['close'], color = 'b', linewidth=2)
axt.set_ylabel(name2, color='b')
if freq > 10:
M_fmt = md.DateFormatter('%Y %b %d', tz=pytz.timezone('Asia/Taipei'))
m_fmt = md.DateFormatter('%b %d', tz=pytz.timezone('Asia/Taipei'))
elif freq > 2:
M_fmt = md.DateFormatter('%b %d', tz=pytz.timezone('Asia/Taipei'))
m_fmt = md.DateFormatter('%H:%M', tz=pytz.timezone('Asia/Taipei'))
else:
M_fmt = md.DateFormatter('%H:%M', tz=pytz.timezone('Asia/Taipei'))
m_fmt = md.DateFormatter('%H:%M:%S', tz=pytz.timezone('Asia/Taipei'))
ax2.xaxis.set_major_formatter(M_fmt)
ax2.xaxis.set_minor_formatter(m_fmt)
ax2.set_xlabel('Yellow: ' + name1 + ' | Blue:' + name2)
ax2.fill_between(t1, 0, df1['v'], color='y', alpha=0.5)
ax2.fill_between(t2, 0, df2['v'], color='b', alpha=0.5)
fig.autofmt_xdate()
if DFs is not None:
if len(DFs) < 10:
print "v1"
for df in DFs:
ax1.plot(t1, df['close'])
else:
print "v2"
ax1.plot(t1, DFs['close'])
fig.savefig(name1.replace('/','_') + '_' + name2.replace('/','_') + '.png')
ax2.xaxis_date()
ax2.autoscale_view()
plt.show()
import wave
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
signal_wave = wave.open('../wavs/split-10/ulrichbessler/dievorstadtkrokodile/8.wav', 'rb')
sample_rate = signal_wave.getframerate()
sig = np.frombuffer(signal_wave.readframes(signal_wave.getnframes()), dtype=np.int16)
sig = sig[:]
plt.figure(figsize=(12, 7))
sns.set_style('darkgrid')
plt.subplots_adjust(hspace=0.3)
plt.suptitle('Waveform and spectrogram of audio sample', y=0.95)
plot_a = plt.subplot(211)
plot_a.plot(sig)
plot_a.set_xlabel('sample steps')
plot_a.set_ylabel('energy')
plt.xlim(0, 160000)
plot_b = plt.subplot(212)
plot_b.specgram(sig, NFFT=1024, Fs=sample_rate, noverlap=900, cmap='viridis')
plot_b.set_xlabel('seconds')
plot_b.set_ylabel('frequency')
plt.xlim(0, 10)
plt.savefig(f'../plots/waveform-spectrogram.png', dpi=300)
plt.close()
show_images(images, 1, titles, label_name[y_training[index]])
elif menu_choice == '4':
#Scatter plot PC transformed data
if len(X_training) == 0:
X_training, y_training = load_dataset()
#set scatter plot variable
color_dict = ['yellow', 'red', 'magenta', 'blue']
#f, axarr = plt.subplots(3, sharex=True, sharey=False)
plt.figure(1, figsize=(30, 10))
#scatter plot data first 2 PC
i = 0
ax1 = plt.subplot(131)
ax1.set_title('Scatter 2PC', ha='center')
for name in label_name:
class_index = label_name.index(name)
#select all the class data from the train set and test set
X_training_sep = X_training[y_training == class_index].copy()
trainingdata_mean = []
trainingdata_std = []
X_train_pca, X_pca_transf = compute_first_PC(X_training_sep, 2)
ax1.scatter(X_pca_transf[:, 0],
X_pca_transf[:, 1],
c=color_dict[i])
i += 1
#scatter plot data 3 to 4 PC
i = 0
def val():
# setup device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device = {}".format(device))
# load data
demo_path = os.path.join("demo")
if not os.path.isdir(demo_path):
os.mkdir(demo_path)
imgs_path_list = img_loader(demo_path)
# set model
pretrain_model = VGGNet(requires_grad=True, remove_fc=True)
model = FCNs(pretrained_net=pretrain_model, n_class=n_class)
print("model loading success...")
# set model running devices
model.to(device)
model = torch.nn.DataParallel(model, device_ids=range(torch.cuda.device_count()))
print("usable gpu num: {}".format(torch.cuda.device_count()))
# load checkpoints
load_ckpt_path = os.path.join("checkpoints",load_ckpt_name)
if torch.cuda.is_available():
checkpoint = torch.load(load_ckpt_path)
else:
checkpoint = torch.load(load_ckpt_path, map_location='cpu')
model.load_state_dict(checkpoint['model_state'])
last_best_iou = checkpoint['best_iou']
start_epoch = checkpoint['epoch']
print('Checkpoint resume success... last iou:{:.4%}'.format(last_best_iou))
time_s = time.time()
model.eval()
with torch.no_grad():
images = []
for i, img_path in zip(range(len(imgs_path_list)), imgs_path_list):
#image = plt.imread(img_path)
image = Image.open(img_path)
image = image.resize((1024, 512), Image.ANTIALIAS)
image = np.array(image) / 255.
image = image[:,:,::-1] # RGB => BGR
images.append(image)
images = np.array(images,dtype=np.float32)
images = images.transpose([0,3,1,2])
images_tensor = torch.tensor(images, dtype=torch.float32)
images_tensor.to(device)
outputs_val = model(images_tensor)
pred = outputs_val.data.max(1)[1].cpu().numpy()
for i in range(len(imgs_path_list)):
plt.figure(i)
plt.subplot(2,2,1)
plt.title("Origin image")
plt.imshow(images[i].transpose([1,2,0])[:,:,::-1])
rgb_img = index2color(pred[i, :, :])
plt.subplot(2,2,2)
plt.title("Semantic Segmentation Predict, mIoU:{:.2%}".format(last_best_iou))
plt.imshow(rgb_img.astype(np.int))
plt.subplot(2,2,3)
# show color2class bar
range_cmap = [[i for i in range(n_class)]]
# 自定义colormap
c_map = mpl.colors.LinearSegmentedColormap.from_list('cmap', np.array(get_color_index()[:n_class]) / 255., 256)
plt.imshow(range_cmap, cmap=c_map)
plt.xticks(range_cmap[0],
['Void', 'Road', 'Construction', 'Traffic light', 'Nature', 'Sky', 'Person', 'Vehicle'],
rotation=50)
print("time used per image:{:.3}s ".format((time.time() - time_s)/len(imgs_path_list)))
plt.show()
pars = ['STATURE', 'BIDELTOID_BRTH', 'THUMB-TIP_REACH']
orioncol = 'orange'
isscol = 'coral'
# Percentile limits (5th percentile Japanese Female, 95th percentile American male)
jf = np.array([[61.8, 15.3, 28.2],
[1.9454, 0.7903, 1.5198]])
am = np.array([[70.8, 19.3, 32.1],
[2.4318, 1.0335, 1.5806]])
ansur = [ansur_men, ansur_women]
plt.figure(figsize=(15, 15))
for i in range(3):
for j in range(2):
plt.subplot(3, 2, 2*(i+1)+j-1)
anth = [df.crew_height, df.crew_shoulder, df.crew_thumb][i][subcat_gender.ix[:, j+1]]
anth.hist(normed=True, label='Test Data')
(ansur[j][pars[i]]/25.4).hist(normed=True, histtype='step', lw=3, label='ANSUR Ref. Data')
plt.title(['Male', 'Female'][j]+' '+['Stature', 'Bideltoid Breadth', 'Thumb-tip Reach'][i])
stat, pval= stats.ttest_ind(anth, ansur[j][pars[i]]/25.4)
bias = anth.mean()-(ansur[j][pars[i]]/25.4).mean()
plt.annotate('Bias: %3.1f $\pm$ %3.1f in \np-value: %3.2f' % (bias, bias/stat, pval), (1, 1),
xycoords='axes fraction', va='top', ha='right', bbox=dict(boxstyle="round", lw=0, fc='white', alpha=0.75))
plt.xlabel("in")
plt.ylabel("Density (in$^{-1}$)")
if 2*(i+1)+j-1==1:
plt.legend(loc=2, fontsize='small')
plt.subplots_adjust(hspace=0.5, wspace=0.3, left=0.1)
#mark orion and iss limits
