def plot_tracks(src, fakewcs, spa=None, **kwargs):
# NOTE -- MAGIC 61 = monthly; this is ASSUMEd below.
tt = np.linspace(2010., 2015., 61)
t0 = TAITime(None, mjd=TAITime.mjd2k + 365.25*10)
#rd0 = src.getPositionAtTime(t0)
#print 'rd0:', rd0
xx,yy = [],[]
rr,dd = [],[]
for t in tt:
#print 'Time', t
rd = src.getPositionAtTime(t0 + (t - 2010.)*365.25*24.*3600.)
ra,dec = rd.ra, rd.dec
rr.append(ra)
dd.append(dec)
ok,x,y = fakewcs.radec2pixelxy(ra,dec)
xx.append(x - 1.)
yy.append(y - 1.)
if spa is None:
spa = [None,None,None]
for rows,cols,sub in spa:
if sub is not None:
plt.subplot(rows,cols,sub)
ax = plt.axis()
plt.plot(xx, yy, 'k-', **kwargs)
plt.axis(ax)
return rr,dd,tt
def plot(self):
rows = np.sqrt(self.M).round()
cols = np.ceil(self.M/rows)
if self.D==1:
xmin = self.X.min()
xmax = self.X.max()
xmin,xmax = xmin-0.1*(xmax-xmin), xmax+0.1*(xmax-xmin)
Xgrid = np.linspace(xmin,xmax,100)[:,None]
zz = self.predict(Xgrid)
if self.D==2:
xmin,ymin = np.vstack(self.X).min(0)
xmax,ymax = np.vstack(self.X).max(0)
xmin,xmax = xmin-0.1*(xmax-xmin), xmax+0.1*(xmax-xmin)
ymin,ymax = ymin-0.1*(ymax-ymin), ymax+0.1*(ymax-ymin)
xx,yy = np.mgrid[xmin:xmax:100j,ymin:ymax:100j]
Xgrid = np.vstack((xx.flatten(),yy.flatten())).T
zz = self.predict(Xgrid).reshape(100,100,self.M)
for m in range(self.M):
pb.subplot(rows,cols,m+1)
if self.D==1:
pb.hist(self.X[m,:,0],self.N/10.,normed=True)
pb.plot(Xgrid,zz[:,m],'r',linewidth=2)
elif self.D==2:
pb.plot(self.X[m,:,0],self.X[m,:,1],'rx',mew=2)
zz_data = self.predict(self.X[m])[:,m]
pb.contour(xx,yy,zz[:,:,m],[stats.scoreatpercentile(zz_data,5)],colors='r',linewidths=1.5)
pb.imshow(zz[:,:,m].T,extent=[xmin,xmax,ymin,ymax],origin='lower',cmap=pb.cm.binary,vmin=0.,vmax=zz_data.max())
def Xtest3(self):
"""
Test from Kate Marvel
As the following code snippet demonstrates, regridding a
cdms2.tvariable.TransientVariable instance using regridTool='regrid2'
results in a new array that is masked everywhere. regridTool='esmf'
and regridTool='libcf' both work as expected.
This is similar to the original test but we construct our own
uniform grid. This should passes.
"""
import cdms2 as cdms
import numpy as np
filename = cdat_info.get_sampledata_path() + '/clt.nc'
a=cdms.open(filename)
data=a('clt')[0,...]
print data.mask #verify this data is not masked
GRID = cdms.grid.createUniformGrid(-90.0, 23, 8.0, -180.0, 36, 10.0, order="yx", mask=None)
test_data=data.regrid(GRID,regridTool='regrid2')
# check that the mask does not extend everywhere...
self.assertNotEqual(test_data.mask.sum(), test_data.size)
if PLOT:
pylab.subplot(2, 1, 1)
pylab.pcolor(data[...])
pylab.title('data')
pylab.subplot(2, 1, 2)
pylab.pcolor(test_data[...])
pylab.title('test_data (interpolated data)')
pylab.show()
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_vm(self):
"""Plot Vm for presynaptic compartment and soma - along with
the same in NEURON simulation if possible."""
pylab.subplot(211)
pylab.title('Soma Vm')
pylab.plot(self.tseries*1e3, self.somaVmTab.vec * 1e3,
label='Vm (mV) - moose')
pylab.plot(self.tseries*1e3, self.injectionTab.vec * 1e9,
label='Stimulus (nA)')
try:
nrn_data = np.loadtxt('../nrn/data/%s_soma_Vm.dat' % \
(self.celltype))
nrn_indices = np.nonzero(nrn_data[:, 0] <= self.tseries[-1]*1e3)[0]
pylab.plot(nrn_data[nrn_indices,0], nrn_data[nrn_indices,1],
label='Vm (mV) - neuron')
except IOError:
print 'No neuron data found.'
pylab.legend()
pylab.subplot(212)
pylab.title('Presynaptic Vm')
pylab.plot(self.tseries*1e3, self.presynVmTab.vec * 1e3,
label='Vm (mV) - moose')
pylab.plot(self.tseries*1e3, self.injectionTab.vec * 1e9,
label='Stimulus (nA)')
try:
nrn_data = np.loadtxt('../nrn/data/%s_presynaptic_Vm.dat' % \
(self.celltype))
nrn_indices = np.nonzero(nrn_data[:, 0] <= self.tseries[-1]*1e3)[0]
pylab.plot(nrn_data[nrn_indices,0], nrn_data[nrn_indices,1],
label='Vm (mV) - neuron')
except IOError:
print 'No neuron data found.'
pylab.legend()
pylab.show()
def Xtest2(self):
"""
Test from Kate Marvel
As the following code snippet demonstrates, regridding a
cdms2.tvariable.TransientVariable instance using regridTool='regrid2'
results in a new array that is masked everywhere. regridTool='esmf'
and regridTool='libcf' both work as expected.
This passes.
"""
import cdms2 as cdms
import numpy as np
filename = cdat_info.get_sampledata_path() + '/clt.nc'
a=cdms.open(filename)
data=a('clt')[0,...]
print data.mask #verify this data is not masked
GRID= data.getGrid() # input = output grid, passes
test_data=data.regrid(GRID,regridTool='regrid2')
# check that the mask does not extend everywhere...
self.assertNotEqual(test_data.mask.sum(), test_data.size)
if PLOT:
pylab.subplot(2, 1, 1)
pylab.pcolor(data[...])
pylab.title('data')
pylab.subplot(2, 1, 2)
pylab.pcolor(test_data[...])
pylab.title('test_data (interpolated data)')
pylab.show()
def display(self, xaxis, alpha, new=True):
"""
E.display(xaxis, alpha = .8)
:Arguments: xaxis, alpha
Plots the CI region on the current figure, with respect to
xaxis, at opacity alpha.
:Note: The fill color of the envelope will be self.mass
on the grayscale.
"""
if new:
figure()
if self.ndim == 1:
if self.mass>0.:
x = concatenate((xaxis,xaxis[::-1]))
y = concatenate((self.lo, self.hi[::-1]))
fill(x,y,facecolor='%f' % self.mass,alpha=alpha, label = ('centered CI ' + str(self.mass)))
else:
pyplot(xaxis,self.value,'k-',alpha=alpha, label = ('median'))
else:
if self.mass>0.:
subplot(1,2,1)
contourf(xaxis[0],xaxis[1],self.lo,cmap=cm.bone)
colorbar()
subplot(1,2,2)
contourf(xaxis[0],xaxis[1],self.hi,cmap=cm.bone)
colorbar()
else:
contourf(xaxis[0],xaxis[1],self.value,cmap=cm.bone)
colorbar()
def trace(data, name, format='png', datarange=(None, None), suffix='', path='./', rows=1, columns=1,
num=1, last=True, fontmap = None, verbose=1):
"""
Generates trace plot from an array of data.
:Arguments:
data: array or list
Usually a trace from an MCMC sample.
name: string
The name of the trace.
datarange: tuple or list
Preferred y-range of trace (defaults to (None,None)).
format (optional): string
Graphic output format (defaults to png).
suffix (optional): string
Filename suffix.
path (optional): string
Specifies location for saving plots (defaults to local directory).
fontmap (optional): dict
Font map for plot.
"""
if fontmap is None: fontmap = {1:10, 2:8, 3:6, 4:5, 5:4}
# Stand-alone plot or subplot?
standalone = rows==1 and columns==1 and num==1
if standalone:
if verbose>0:
print_('Plotting', name)
figure()
subplot(rows, columns, num)
pyplot(data.tolist())
ylim(datarange)
# Plot options
title('\n\n %s trace'%name, x=0., y=1., ha='left', va='top', fontsize='small')
# Smaller tick labels
tlabels = gca().get_xticklabels()
setp(tlabels, 'fontsize', fontmap[rows/2])
tlabels = gca().get_yticklabels()
setp(tlabels, 'fontsize', fontmap[rows/2])
if standalone:
if not os.path.exists(path):
os.mkdir(path)
if not path.endswith('/'):
path += '/'
# Save to file
savefig("%s%s%s.%s" % (path, name, suffix, format))
def bilinear_interpolation(dataset_name, feat, unfeat, repo, nbt=3):
tlist=np.linspace(0,1,nbt)
_, _, test=get_data(dataset_name, repo)
xtest1, _, _ = test
n = xtest1.shape[-1]
N = len(xtest1)
tuple_index=np.random.permutation(N)[:4]
embeddings = feat.predict(xtest1[tuple_index])
interp_array = np.zeros((nbt, nbt, n, n))
for i in range(nbt):
for j in range(nbt):
x = (tlist[i]*embeddings[0] + (1-tlist[0])*embeddings[1])
y = (tlist[i]*embeddings[2] + (1-tlist[0])*embeddings[3])
x_interp = unfeat.predict(((tlist[j]*x + (1-tlist[j])*y))[None])
interp_array[i,j]=x_interp[0,0]
pl.figure(1)
for i in range(nbt):
for j in range(nbt):
nb=i*nbt +j+1
pl.subplot(nbt*100+(nbt)*10 +nb)
pl.imshow(interp_array[i,j], cmap='Blues',interpolation='nearest')
def plot_signal(x,y,title,labelx,labley,position):
pylab.subplot (9, 1, position)
pylab.plot(x,y)
pylab.title(title)
pylab.xlabel(labelx)
pylab.ylabel(labley)
pylab.grid(True)
def plot_samples(samples, no_of_rows, no_of_cols, pno=1, n_samples=100, plot_every=1, img_shp=(28,
28), axes=None):
if pno == 0:
axes = pylab.subplot(no_of_rows, no_of_cols, pno + 1, aspect='equal')
colored_axis(axes, "red")
pylab.imshow(samples[pno].reshape(img_shp))
plot_samples(samples,
no_of_rows,
no_of_cols,
pno=pno + plot_every,
n_samples=n_samples,
plot_every=plot_every,
img_shp=img_shp,
axes=axes)
if pno >= n_samples:
colored_axis(axes, "black")
return 0
else:
plot_no = pno / plot_every
axes = pylab.subplot(no_of_rows, no_of_cols, plot_no + 1, aspect='equal')
colored_axis(axes, "black")
pylab.imshow(samples[pno].reshape(img_shp))
plot_samples(samples,
no_of_rows,
no_of_cols,
pno=pno + plot_every,
n_samples=n_samples,
plot_every=plot_every,
img_shp=img_shp,
axes=axes)
def T2_cpmg_process(folder_to_process,plot='y'):
"""Given a folder of images will process cpmg data and return
fitted T2 values and associated uncertainties"""
data=img_roi_signal([folder_to_process],['EchoTime'])
rois=data[0][0]
TEs=data[2][0]
mean_signal_mat=data[3]
serr_signal_mat=data[4]
if plot=='y':
plt.figure()
spin_echo_fits=[]
for jj in np.arange(len(rois)-2):
mean_sig=mean_signal_mat[0,jj,:]
#serr_sig=serr_signal_mat[0,jj,:]
mean_noise=np.mean(mean_signal_mat[0,-2,:])
try:
spin_echo_fit = SE_fit_new( np.array(TEs[0:]), mean_sig[0:], mean_noise, 'n' )
if plot=='y':
TE_full=np.arange(0,400,1)
plt.subplot(4,4,jj+1)
plt.plot(np.array(TEs[0:]), mean_sig[0:],'o')
plt.plot(TE_full,spin_echo_fit(TE_full))
spin_echo_fits.append(spin_echo_fit)
except RuntimeError:
print 'RuntimeError'
spin_echo=fitting.model('M0*exp(-x/T2)+a',{'M0':0,'T2':0,'a':0})
spin_echo_fits.append(spin_echo)
return spin_echo_fits
def display_head(set_x, set_y, n = 5):
'''
show some figures based on gray image matrixs
@type set_x: TensorSharedVariable,
@param set_x: gray level value matrix of the
@type set_y: TensorVariable,
@param set_y: label of the figures
@type n: int,
@param n: numbers of figure to be display, less than 10, default 5
'''
import pylab
if n > 10: n = 10
img_x = set_x.get_value()[0:n].reshape(n, 28, 28)
img_y = set_y.eval()[0:n]
for i in range(n):
pylab.subplot(1, n, i+1);
pylab.axis('off');
pylab.title(' %d' % img_y[i])
pylab.gray()
pylab.imshow(img_x[i])
def graphError(predictedPercentChanges, actualPercentChanges, title):
# considering error and only considering it as error when the signs are different
def computeSignedError(pred, actual):
if (pred > 0 and actual > 0) or (pred < 0 and actual < 0):
return 0
else:
error = abs(pred - actual)
# print 'pred: {0}, actual: {1}, error: {2}'.format(pred, actual, error)
return error
signedError = map(
lambda pred, actual: computeSignedError(pred, actual), predictedPercentChanges, actualPercentChanges
)
pl.figure(2)
pl.title(title + " Error")
pl.subplot(211)
pl.plot(signedError)
pl.xlabel("Time step")
pl.ylabel("Error (0 if signs are same and normal error if signs are different)")
pl.figure(3)
pl.title(title + " Actual vs Predictions")
pl.subplot(211)
pl.plot(
range(len(predictedPercentChanges)),
predictedPercentChanges,
"ro",
range(len(actualPercentChanges)),
actualPercentChanges,
"bs",
)
def main():
amps = [0.167e-9,
0.25e-9,
0.333e-9]
model_dict = setup_model()
for ii, a in enumerate(amps):
do_sim(model_dict['stimulus'], a)
config.logger.info('##### %d' % (model_dict['tab_vm'].size))
vm = model_dict['tab_vm'].vector
inject = model_dict['tab_stim'].vector.copy()
t = np.linspace(0, simtime, len(vm))
fname = 'data_fig_a3_%s.txt' % (chr(ord('A')+ii))
np.savetxt(fname,
np.vstack((t, inject, vm)).transpose())
msg = 'Saved data for %g A current pulse in %s' % (a, fname)
config.logger.info(msg)
print(msg)
pylab.subplot(3,1,ii+1)
pylab.title('%g nA' % (a*1e9))
pylab.plot(t, vm, label='soma-Vm (mV)')
stim_boundary = np.flatnonzero(np.diff(inject))
pylab.plot((t[stim_boundary[0]]), (vm.min()), 'r^', label='stimulus start')
pylab.plot((t[stim_boundary[-1]]), (vm.min()), 'gv', label='stimulus end')
pylab.legend()
pylab.savefig('fig_a3.png')
pylab.show()
def display_orbit(input, amplitude=0.000001):
import matplotlib.pyplot
import pylab
# Compare the power spectral density functions of the system with and
# without the input sequence.
x = [0.4, 0.6]
X = []
for i in range(warmups):
x = network(x)
x[0] = x[0] + ( amplitude * input[0][i % len(input[0])] )
x[1] = x[1] + ( amplitude * input[1][i % len(input[1])] )
for i in range(measure):
X.append(x[0])
x = network(x)
x[0] = x[0] + ( amplitude * input[0][i % len(input[0])] )
x[1] = x[1] + ( amplitude * input[1][i % len(input[1])] )
pylab.subplot(2,1,1)
matplotlib.pyplot.psd(X,1024,32)
x = [0.4, 0.6]
X = []
for i in range(warmups):
x = network(x)
# x[0] = x[0] + ( amplitude * input[i % len(input)] )
for i in range(measure):
X.append(x[0])
x = network(x)
# x[0] = x[0] + ( amplitude * input[i % len(input)] )
pylab.subplot(2,1,2)
matplotlib.pyplot.psd(X,1024,32)
pylab.show()
def plot_pp(var):
jobs_orig.sort(key=lambda job: getattr(job, var))
pylab.subplot(211)
for ch in (10, 50, 200):
xs = [getattr(job, var) for job in jobs_orig if job.ch_objects == ch]
if xs:
pylab.plot(xs,
[(job.ef11[-1] + job.ef10[-1]) / job.ef11[0]
for job in jobs_orig if job.ch_objects==ch],
'o-', label=r'$ch=%.0f$'%ch)
pylab.xscale('log')
pylab.xlabel(r'$%s$'%(var,))
pylab.ylabel(r'$(ef_{11}^n+ef_{10}^n)/ef_{11}^0$')
pylab.legend(loc='best')
pylab.subplot(212)
for ch in (10, 50, 200):
xs = [getattr(job, var) for job in jobs_orig if job.ch_objects == ch]
if xs:
pylab.plot(xs,
[job.hf_eq11 / job.ef11[-1] for job in jobs_orig if job.ch_objects==ch],
'o-', label=r'$ch=%.0f$'%ch)
pylab.xscale('log')
pylab.xlabel(r'$%s$'%(var,))
pylab.ylabel(r'$hf{11}^n(Q=0) / ef_{11}^n$')
pylab.legend(loc='best')
pylab.savefig(var+'.png')
def show_image(*imgs):
for idx, img in enumerate(imgs):
subplot = 101 + len(imgs)*10 +idx
pl.subplot(subplot)
pl.imshow(img, cmap=pl.cm.gray)
pl.gca().set_axis_off()
pl.subplots_adjust(0.02, 0, 0.98, 1, 0.02, 0)
def draw(self):
print self.edgeno
pos = 0
dy = 8
edgeno = self.edgeno
edge = self.edges[edgeno]
edgeprev = self.edges[edgeno-1]
p = np.round(edge["top"](1024))
top = min(p+2*dy, 2048)
bot = min(p-2*dy, 2048)
self.cutout = self.flat[1][bot:top,:].copy()
pl.figure(1)
pl.clf()
start = 0
dy = 512
for i in xrange(2048/dy):
pl.subplot(2048/dy,1,i+1)
pl.xlim(start, start+dy)
if i == 0: pl.title("edge %i] %s|%s" % (edgeno,
edgeprev["Target_Name"], edge["Target_Name"]))
pl.subplots_adjust(left=.07,right=.99,bottom=.05,top=.95)
pl.imshow(self.flat[1][bot:top,start:start+dy], extent=(start,
start+dy, bot, top), cmap='Greys', vmin=2000, vmax=6000)
pix = np.arange(start, start+dy)
pl.plot(pix, edge["top"](pix), 'r', linewidth=1)
pl.plot(pix, edgeprev["bottom"](pix), 'r', linewidth=1)
pl.plot(edge["xposs_top"], edge["yposs_top"], 'o')
pl.plot(edgeprev["xposs_bot"], edgeprev["yposs_bot"], 'o')
hpp = edge["hpps"]
pl.axvline(hpp[0],ymax=.5, color='blue', linewidth=5)
pl.axvline(hpp[1],ymax=.5, color='red', linewidth=5)
hpp = edgeprev["hpps"]
pl.axvline(hpp[0],ymin=.5,color='blue', linewidth=5)
pl.axvline(hpp[1],ymin=.5,color='red', linewidth=5)
if False:
L = top-bot
Lx = len(edge["xposs"])
for i in xrange(Lx):
xp = edge["xposs"][i]
frac1 = (edge["top"](xp)-bot-1)/L
pl.axvline(xp,ymin=frac1)
for xp in edgeprev["xposs"]:
frac2 = (edgeprev["bottom"](xp)-bot)/L
pl.axvline(xp,ymax=frac2)
start += dy
def ShowDynamicalResults(indexmap,output):
import pylab
pylab.figure()
for i in range(4):
pylab.subplot('22'+str(i+1))
pylab.imshow(indexmap[i],interpolation='nearest')
pylab.savefig(output+'.png')
def lookatresults(data, modes, theta=None, vert=False, labels=None):
P = data[-1][0]
n = P.shape[0]
if labels == None:
labels = [""] * n
else:
pass
if vert == True:
subplots = range(n*100+11,n*100+n+11,1)
figsize = (6, 3*n)
elif vert == 'four':
subplots = [221, 222, 223, 224]
figsize = (10, 10)
else:
subplots = range(100+n*10+1,100+n*10+1+n,1)
figsize = (5*n, 3)
f = stats.gaussian_kde(data[-1][0])
int_guess = np.mean(data[-1][0], axis=1)
modes = minimize(neg, int_guess, args=(f)).x
thetas = []
P = data[-1][0]
labelpad = 20
for i in xrange(n):
x = P[i]
t = r'$\theta_{3:}$ {1:.2f} +{2:.2f}/-{0:.2f}'.format(
modes[i]-stats.scoreatpercentile(x, 16),
modes[i],
stats.scoreatpercentile(x, 84)-modes[i], i+1)
thetas.append(t)
if P.shape[1] > 10:
bins = np.sqrt(P.shape[1])
else:
bins=10
fig = plt.figure(figsize=figsize)
for i in xrange(n):
print subplots[i]
plt.subplot(int(subplots[i]))
#plt.title(thetas[0])
ker = stats.gaussian_kde(P[i])
h = plt.hist(P[i], bins=bins, normed=True, alpha=1)
x = np.linspace(h[1][0],h[1][-1],1000)
plt.plot(x,ker(x))
plt.xlabel(labels[i], labelpad=labelpad, fontsize=24)
if theta != None:
plt.axvline(theta[0])
for t in thetas:
print t
return fig
def main( runTime ):
try:
moose.delete('/acc92')
print("Deleted old model")
except Exception as e:
print("Could not clean. model not loaded yet")
moose.loadModel('acc92_caBuff.g',loadpath,'gsl')
ca = moose.element(loadpath+'/kinetics/Ca')
pr = moose.element(loadpath+'/kinetics/protein')
clockdt = moose.Clock('/clock').dts
moose.setClock(8, 0.1)#simdt
moose.setClock(18, 0.1)#plotdt
print clockdt
print " \t \t simdt ", moose.Clock('/clock').dts[8],"plotdt ",moose.Clock('/clock').dts[18]
ori = ca.concInit
tablepath = loadpath+'/kinetics/Ca'
tableele = moose.element(tablepath)
table = moose.Table2(tablepath+'.con')
x = moose.connect(table, 'requestOut', tablepath, 'getConc')
tablepath1 = loadpath+'/kinetics/protein'
tableele1 = moose.element(tablepath1)
table1 = moose.Table2(tablepath1+'.con')
x1 = moose.connect(table1, 'requestOut', tablepath1, 'getConc')
ca.concInit = ori
print("[INFO] Running for 4000 with Ca.conc %s " % ca.conc)
moose.start(4000)
ca.concInit = 5e-03
print("[INFO] Running for 20 with Ca.conc %s " % ca.conc)
moose.start(20)
ca.concInit = ori
moose.start( runTime ) #here give the interval time
ca.concInit = 5e-03
print("[INFO] Running for 20 with Ca.conc %s " % ca.conc)
moose.start(20)
ca.concInit = ori
print("[INFO] Running for 2000 with Ca.conc %s " % ca.conc)
moose.start(2000)
pylab.figure()
pylab.subplot(2, 1, 1)
t = numpy.linspace(0.0, moose.element("/clock").runTime, len(table.vector)) # sec
pylab.plot( t, table.vector, label="Ca Conc (interval- 8000s)" )
pylab.legend()
pylab.subplot(2, 1, 2)
t1 = numpy.linspace(0.0, moose.element("/clock").runTime, len(table1.vector)) # sec
pylab.plot( t1, table1.vector, label="Protein Conc (interval- 8000s)" )
pylab.legend()
pylab.savefig( os.path.join( dataDir, '%s_%s.png' % (table1.name, runTime) ) )
print('[INFO] Saving data to csv files in %s' % dataDir)
tabPath1 = os.path.join( dataDir, '%s_%s.csv' % (table.name, runTime))
numpy.savetxt(tabPath1, numpy.matrix([t, table.vector]).T, newline='\n')
tabPath2 = os.path.join( dataDir, '%s_%s.csv' % (table1.name, runTime) )
numpy.savetxt(tabPath2, numpy.matrix([t1, table1.vector]).T, newline='\n')
def main():
star = StarBinary(90.0, 0.5, nside=64, limb_law=-1, limb_coeff=[0.8])
Flux0 = star.flux(0.0)
phases = np.linspace(-0.5, 0.5, 100)
flux1 = np.zeros(len(phases))
for i in range(len(phases)):
flux1[i] = star.flux(phases[i]) / Flux0
# for tt in np.arange(0,360,80):
# star.makeSpot(0,-45,10.,0.8)
# star.makeSpot(45,+00,10.,0.8)
# star.makeSpot(00, -90, 20., 0.)
# for theta in range(0,360,45):
# star.makeSpot(theta,65,10.,0.8)
# star.makeSpot(00,-90,20.,0.)
# star.makeSpot(0,+45,10.,0.8)
# star.makeSpot(270,-10.,10.,0.8)
# star.makeSpot(180,-45.,10.,0.8)
# star.makeSpot(tt,65.,10.,0.5)
flux2 = np.zeros(len(phases))
for i in range(len(phases)):
flux2[i] = star.flux(phases[i]) / Flux0
H.mollview(star.I, sub=211, rot=(-90, 90))
#ff = np.loadtxt('/tmp/cl.dat', unpack=True)
py.subplot(212)
py.plot(phases, flux1, '-')
# py.plot(phases,flux2,'-')
#py.plot(ff[0], ff[1], '.')
py.show()
def graphTSPResults(resultsDir,numberOfTours):
x=[]
y=[]
files=[open("%s/objectiveFunctionReport.txt" % resultsDir),
open("%s/fitnessReport.txt" % resultsDir)]
for f in files:
x.append([])
y.append([])
i=len(x)-1
for line in f:
line=line.split(',')
if line[0] != "gen":
x[i].append(int(line[0]))
y[i].append(float(line[1] if i==1 else line[2]))
ylen=len(y[0])
pl.subplot(2,1,1)
pl.plot(x[0],y[0],'bo')
pl.ylabel('Minimum Distance')
pl.title("TSP with a %s City Tour" % numberOfTours)
pl.annotate("{0:,}".format(y[0][0]),xy=(x[0][0],y[0][0]), xycoords='data',
xytext=(30, -30), textcoords='offset points',
arrowprops=dict(arrowstyle="->") )
pl.annotate("{0:,}".format(y[0][ylen-1]),xy=(x[0][ylen-1],y[0][ylen-1]), xycoords='data',
xytext=(-30,30), textcoords='offset points',
arrowprops=dict(arrowstyle="->") )
pl.subplot(2,1,2)
pl.plot(x[1],y[1],'go')
pl.xlabel('Generation')
pl.ylabel('Fitness')
pl.savefig("%s/tsp_result.png" % resultsDir)
pl.clf()
def plot_Barycenter(dataset_name, feat, unfeat, repo):
if dataset_name==MNIST:
_, _, test=get_data(dataset_name, repo, labels=True)
xtest1,_,_, labels,_=test
else:
_, _, test=get_data(dataset_name, repo, labels=False)
xtest1,_,_ =test
labels=np.zeros((len(xtest1),))
# get labels
def bary_wdl2(index): return _bary_wdl2(index, xtest1, feat, unfeat)
n=xtest1.shape[-1]
num_class = (int)(max(labels)+1)
barys=[bary_wdl2(np.where(labels==i)) for i in range(num_class)]
pl.figure(1, (num_class, 1))
for i in range(num_class):
pl.subplot(1,10,1+i)
pl.imshow(barys[i][0,0,:,:],cmap='Blues',interpolation='nearest')
pl.xticks(())
pl.yticks(())
if i==0:
pl.ylabel('DWE Bary.')
if num_class >1:
pl.title('{}'.format(i))
pl.tight_layout(pad=0,h_pad=-2,w_pad=-2)
pl.savefig("imgs/{}_dwe_bary.pdf".format(dataset_name))
def main():
src_cv_img_1 = cv.LoadImage("data/gorskaya/images/1/g126.jpg")
src_cv_img_gray_1 = cv.LoadImage("data/gorskaya/images/1/g126.jpg",
cv.CV_LOAD_IMAGE_GRAYSCALE)
src_cv_img_2 = cv.LoadImage("data/gorskaya/images/1/g127.jpg")
src_cv_img_gray_2 = cv.LoadImage("data/gorskaya/images/1/g127.jpg",
cv.CV_LOAD_IMAGE_GRAYSCALE)
(keypoints_1, descriptors_1) = \
cv.ExtractSURF(src_cv_img_gray_1, None, cv.CreateMemStorage(),
(0, 30000, 3, 1))
(keypoints_2, descriptors_2) = \
cv.ExtractSURF(src_cv_img_gray_2, None, cv.CreateMemStorage(),
(0, 30000, 3, 1))
print("Found {0} and {1} keypoints".format(
len(keypoints_1), len(keypoints_2)))
src_arr_1 = array(src_cv_img_1[:, :])[:, :, ::-1]
src_arr_2 = array(src_cv_img_2[:, :])[:, :, ::-1]
pylab.rc('image', interpolation='nearest')
pylab.subplot(121)
pylab.imshow(src_arr_1)
pylab.plot(*zip(*[k[0] for k in keypoints_1]),
marker='.', color='r', ls='')
pylab.subplot(122)
pylab.imshow(src_arr_2)
pylab.plot(*zip(*[k[0] for k in keypoints_2]),
marker='.', color='r', ls='')
pylab.show()
def graphSimpleResults(resultsDir):
x=[]
y=[]
files=[open("%s/objectiveFunctionReport.txt" % resultsDir),
open("%s/fitnessReport.txt" % resultsDir)]
for f in files:
x.append([])
y.append([])
i=len(x)-1
for line in f:
line=line.split(',')
if line[0] != "gen":
x[i].append(int(line[0]))
y[i].append(float(line[1]))
ylen=len(y[0])
pl.subplot(2,1,1)
pl.plot(x[0],y[0],'bo')
pl.ylabel('Maximum x')
pl.title('Maximizing x**2 with SGA')
pl.annotate("{0:,}".format(y[0][0]),xy=(x[0][0],y[0][0]), xycoords='data',
xytext=(50, 30), textcoords='offset points',
arrowprops=dict(arrowstyle="->") )
pl.annotate("{0:,}".format(y[0][ylen-1]),xy=(x[0][ylen-1],y[0][ylen-1]), xycoords='data',
xytext=(-30, -30), textcoords='offset points',
arrowprops=dict(arrowstyle="->") )
pl.subplot(2,1,2)
pl.plot(x[1],y[1],'go')
pl.xlabel('Generation')
pl.ylabel('Fitness')
pl.savefig("%s/simple_result.png" % resultsDir)
def traceplot(traces, thin, burn):
'''
Plot parameter estimates for different levels of the model
into the same plots. Black lines are individual observers
and red lines are mean estimates.
'''
variables = ['Slope1', 'Slope2', 'Offset', 'Split']
for i, var in enumerate(variables):
plt.subplot(2, 2, i + 1)
vals = get_values(traces, var, thin, burn)
dim = (vals.min() - vals.std(), vals.max() + vals.std())
x = plt.linspace(*dim, num=1000)
for v in vals.T:
a = gaussian_kde(v)
y = a.evaluate(x)
y = y / y.max()
plt.plot(x, y, 'k', alpha=.5)
try:
vals = get_values(traces, 'Mean_' + var, thin, burn)
a = gaussian_kde(vals)
y = a.evaluate(x)
y = y / y.max()
plt.plot(x, y, 'r', alpha=.75)
except KeyError:
pass
plt.ylim([0, 1.1])
plt.yticks([0])
sns.despine(offset=5, trim=True)
plt.title(var)
def display_coeff(data=None):
betaAll,betaErrAll, R2adjAll = measure_stamp_coeff(data = data, zernike_max_order=20)
ind = np.arange(len(betaAll[0]))
momname = ('M20','M22.Real','M22.imag','M31.real','M31.imag','M33.real','M33.imag')
fmtarr = ['bo-','ro-','go-','co-','mo-','yo-','ko-']
pl.figure(figsize=(17,13))
for i in range(7):
pl.subplot(7,1,i+1)
pl.errorbar(ind,betaAll[i],yerr = betaErrAll[i],fmt=fmtarr[i])
pl.grid()
pl.xlim(-1,21)
if i ==0:
pl.ylim(-10,65)
elif i ==1:
pl.ylim(-5,6)
elif i ==2:
pl.ylim(-5,6)
elif i == 3:
pl.ylim(-0.1,0.1)
elif i == 4:
pl.ylim(-0.1,0.1)
elif i ==5:
pl.ylim(-100,100)
elif i == 6:
pl.ylim(-100,100)
pl.xticks(ind,('','','','','','','','','','','','','','','','','','','',''))
pl.ylabel(momname[i])
pl.xticks(ind,('0','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19'))
pl.xlabel('Zernike Coefficients')
return '--- done ! ----'
def sim_results(obs, modes, stars, model, data):
synth = model.generate_data(modes)
synth_stats = model.summary_stats(synth)
obs_stats = model.summary_stats(obs)
f = plt.figure(figsize=(15,3))
plt.suptitle('Obs Cand.:{}; Sim Cand.:{}'.format(obs.size, synth.size))
plt.rc('legend', fontsize='xx-small', frameon=False)
plt.subplot(121)
bins = opt_bin(obs_stats[0],synth_stats[0])
plt.hist(obs_stats[0], bins=bins, histtype='step', label='Data', lw=2)
plt.hist(synth_stats[0], bins=bins, histtype='step', label='Simulation', lw=2)
plt.xlabel(r'$\xi$')
plt.legend()
plt.subplot(122)
bins = opt_bin(obs_stats[1],synth_stats[1])
plt.hist(obs_stats[1], bins=np.arange(bins.min()-0.5, bins.max()+1.5,
1),
histtype='step', label='Data', log=True, lw=2)
plt.hist(synth_stats[1], bins=np.arange(bins.min()-0.5, bins.max()+1.5,
1),
histtype='step', label='Simulation', log=True, lw=2)
plt.xlabel(r'$N_p$')
plt.legend()
def plot_ts(t, data, names=None, output='show', ax=None, color=None, lw=1.0):
#print 'total date range: ',t[-1]-t[0]
#--set up date formatters
if t[-1] - t[0] < 90:
majortick = MonthLocator()
minortick = DayLocator(15)
minFmt = DateFormatter('%d')
majFmt = DateFormatter('%b')
elif t[-1] - t[0] < 365:
majortick = MonthLocator()
minortick = DayLocator()
minFmt = DateFormatter('')
majFmt = DateFormatter('%b')
elif t[-1] - t[0] < 5280:
majortick = YearLocator()
minortick = MonthLocator((5, 9))
minFmt = DateFormatter('%b')
majFmt = DateFormatter('%Y')
elif t[-1] - t[0] < 3650:
majortick = YearLocator(2)
minortick = MonthLocator()
minFmt = DateFormatter('')
majFmt = DateFormatter('%Y')
else:
majortick = YearLocator(5)
minortick = YearLocator()
minFmt = DateFormatter('')
majFmt = DateFormatter('%Y')
if ax == None:
fig = pylab.figure()
ax = pylab.subplot(111)
#print data.shape
try:
for s in range(0, np.shape(data)[1]):
if color != None:
ax.plot(t, data[:, s], label=names[s], color=color[s], lw=lw)
else:
ax.plot(t, data[:, s], label=names[s], lw=lw)
except:
if color != None:
ax.plot(t, data, label=names, color=color, lw=lw)
else:
ax.plot(t, data, label=names, lw=lw)
if names != None:
ax.legend()
ax.xaxis.set_major_locator(majortick)
ax.xaxis.set_minor_locator(minortick)
ax.xaxis.set_major_formatter(majFmt)
ax.xaxis.set_minor_formatter(minFmt)
if output == 'show':
pylab.show()
return
elif output == None:
return ax
else:
fmt = output.split('.')[-1]
pylab.savefig(output, orientation='portrait', format=fmt, dpi=150)
return
#names,data = load_ssf('flows.out')
#print names,len(data),data[0].shape
#print data[0][0,0],data[0][0,1]
#plot_ts(data[0][:,0],data[0][:,1],names[0])
def plot(self, nums, i):
pylab.subplot(1, 2, i)
pylab.hist(nums, normed=1)
pylab.title('{} numbers. M = {:.4f}. D = {:.4f}. K = {:.4f}'.format(
len(nums), M(nums), D(nums), correlation(nums)))
if __name__ == "__main__":
scratch_square = empty(grid_shape)
grid_square = zeros(grid_shape)
block_low = int(grid_shape[0] * .4)
block_high = int(grid_shape[0] * .5)
grid_square[block_low:block_high, block_low:block_high] = 0.005
grid_python = 1 - py.imread(
request.urlopen(
"http://a4.mzstatic.com/us/r30/Purple4/v4/e8/20/fd/e820fded-8a78-06ac-79d0-f1d140346976/mzl.huoealqj.png"
)).mean(2)
grid_python = asarray(grid_python, dtype='float64')
scratch_python = empty(grid_python.shape)
py.subplot(3, 2, 1)
py.imshow(grid_square.copy())
py.ylabel("t = 0 seconds")
py.gca().get_xaxis().set_ticks([])
py.gca().get_yaxis().set_ticks([])
py.subplot(3, 2, 2)
py.imshow(grid_python.copy())
py.gca().get_xaxis().set_ticks([])
py.gca().get_yaxis().set_ticks([])
for i in range(500):
evolve(grid_square, 0.1, scratch_square)
grid_square, scratch_square = scratch_square, grid_square
evolve(grid_python, 0.1, scratch_python)
grid_python, scratch_python = scratch_python, grid_python
def histogram(self, x=None, what="count(*)", grid=None, shape=64, facet=None, limits=None, figsize=None, f="identity", n=None, normalize_axis=None,
xlabel=None, ylabel=None, label=None,
selection=None, show=False, tight_layout=True, hardcopy=None,
progress=None,
**kwargs):
"""Plot a histogram.
Example:
>>> df.histogram(df.x)
>>> df.histogram(df.x, limits=[0, 100], shape=100)
>>> df.histogram(df.x, what='mean(y)', limits=[0, 100], shape=100)
If you want to do a computation yourself, pass the grid argument, but you are responsible for passing the
same limits arguments:
>>> counts = df.mean(df.y, binby=df.x, limits=[0, 100], shape=100)/100.
>>> df.histogram(df.x, limits=[0, 100], shape=100, grid=means, label='mean(y)/100')
:param x: Expression to bin in the x direction
:param what: What to plot, count(*) will show a N-d histogram, mean('x'), the mean of the x column, sum('x') the sum
:param grid: If the binning is done before by yourself, you can pass it
:param facet: Expression to produce facetted plots ( facet='x:0,1,12' will produce 12 plots with x in a range between 0 and 1)
:param limits: list of [xmin, xmax], or a description such as 'minmax', '99%'
:param figsize: (x, y) tuple passed to pylab.figure for setting the figure size
:param f: transform values by: 'identity' does nothing 'log' or 'log10' will show the log of the value
:param n: normalization function, currently only 'normalize' is supported, or None for no normalization
:param normalize_axis: which axes to normalize on, None means normalize by the global maximum.
:param normalize_axis:
:param xlabel: String for label on x axis (may contain latex)
:param ylabel: Same for y axis
:param: tight_layout: call pylab.tight_layout or not
:param kwargs: extra argument passed to pylab.plot
:return:
"""
import pylab
f = _parse_f(f)
n = _parse_n(n)
if type(shape) == int:
shape = (shape,)
binby = []
x = _ensure_strings_from_expressions(x)
for expression in [x]:
if expression is not None:
binby = [expression] + binby
limits = self.limits(binby, limits)
if figsize is not None:
pylab.figure(num=None, figsize=figsize, dpi=80, facecolor='w', edgecolor='k')
fig = pylab.gcf()
import re
if facet is not None:
match = re.match("(.*):(.*),(.*),(.*)", facet)
if match:
groups = match.groups()
facet_expression = groups[0]
facet_limits = [ast.literal_eval(groups[1]), ast.literal_eval(groups[2])]
facet_count = ast.literal_eval(groups[3])
limits.append(facet_limits)
binby.append(facet_expression)
shape = (facet_count,) + shape
else:
raise ValueError("Could not understand 'facet' argument %r, expected something in form: 'column:-1,10:5'" % facet)
if grid is None:
if what:
if isinstance(what, (vaex.stat.Expression)):
grid = what.calculate(self, binby=binby, limits=limits, shape=shape, selection=selection)
else:
what = what.strip()
index = what.index("(")
import re
groups = re.match("(.*)\((.*)\)", what).groups()
if groups and len(groups) == 2:
function = groups[0]
arguments = groups[1].strip()
functions = ["mean", "sum", "std", "count"]
if function in functions:
# grid = getattr(self, function)(arguments, binby, limits=limits, shape=shape, selection=selection)
grid = getattr(vaex.stat, function)(arguments).calculate(self, binby=binby, limits=limits, shape=shape, selection=selection, progress=progress)
elif function == "count" and arguments == "*":
grid = self.count(binby=binby, shape=shape, limits=limits, selection=selection, progress=progress)
elif function == "cumulative" and arguments == "*":
# TODO: comulative should also include the tails outside limits
grid = self.count(binby=binby, shape=shape, limits=limits, selection=selection, progress=progress)
grid = np.cumsum(grid)
else:
raise ValueError("Could not understand method: %s, expected one of %r'" % (function, functions))
else:
raise ValueError("Could not understand 'what' argument %r, expected something in form: 'count(*)', 'mean(x)'" % what)
else:
grid = self.histogram(binby, size=shape, limits=limits, selection=selection)
fgrid = f(grid)
if n is not None:
# ngrid = n(fgrid, axis=normalize_axis)
ngrid = fgrid / fgrid.sum()
else:
ngrid = fgrid
# reductions = [_parse_reduction(r, colormap, colors) for r in reduce]
# rgrid = ngrid * 1.
# for r in reduce:
# r = _parse_reduction(r, colormap, colors)
# rgrid = r(rgrid)
# grid = self.reduce(grid, )
xmin, xmax = limits[-1]
if facet:
N = len(grid[-1])
else:
N = len(grid)
xexpression = binby[0]
xar = np.arange(N + 1) / (N - 0.) * (xmax - xmin) + xmin
label = str(label or selection or x)
if facet:
import math
rows, columns = int(math.ceil(facet_count / 4.)), 4
values = np.linspace(facet_limits[0], facet_limits[1], facet_count + 1)
for i in range(facet_count):
ax = pylab.subplot(rows, columns, i + 1)
value = ax.plot(xar, ngrid[i], drawstyle="steps-mid", label=label, **kwargs)
v1, v2 = values[i], values[i + 1]
pylab.xlabel(xlabel or x)
pylab.ylabel(ylabel or what)
ax.set_title("%3f <= %s < %3f" % (v1, facet_expression, v2))
if self.iscategory(xexpression):
labels = self.category_labels(xexpression)
step = len(labels) // max_labels
pylab.xticks(range(len(labels))[::step], labels[::step], size='small')
else:
# im = pylab.imshow(rgrid, extent=np.array(limits[:2]).flatten(), origin="lower", aspect=aspect)
pylab.xlabel(xlabel or self.label(x))
pylab.ylabel(ylabel or what)
# print(xar, ngrid)
# repeat the first element, that's how plot/steps likes it..
g = np.concatenate([ngrid[0:1], ngrid])
value = pylab.plot(xar, g, drawstyle="steps-pre", label=label, **kwargs)
if self.iscategory(xexpression):
labels = self.category_labels(xexpression)
step = len(labels) // max_labels
pylab.xticks(range(len(labels))[::step], labels[::step], size='small')
if tight_layout:
pylab.tight_layout()
if hardcopy:
pylab.savefig(hardcopy)
if show:
pylab.show()
return value
def heatmap(self, x=None, y=None, z=None, what="count(*)", vwhat=None, reduce=["colormap"], f=None,
normalize="normalize", normalize_axis="what",
vmin=None, vmax=None,
shape=256, vshape=32, limits=None, grid=None, colormap="afmhot", # colors=["red", "green", "blue"],
figsize=None, xlabel=None, ylabel=None, aspect="auto", tight_layout=True, interpolation="nearest", show=False,
colorbar=True,
colorbar_label=None,
selection=None, selection_labels=None, title=None,
background_color="white", pre_blend=False, background_alpha=1.,
visual=dict(x="x", y="y", layer="z", fade="selection", row="subspace", column="what"),
smooth_pre=None, smooth_post=None,
wrap=True, wrap_columns=4,
return_extra=False, hardcopy=None):
"""Viz data in a 2d histogram/heatmap.
Declarative plotting of statistical plots using matplotlib, supports subplots, selections, layers.
Instead of passing x and y, pass a list as x argument for multiple panels. Give what a list of options to have multiple
panels. When both are present then will be origanized in a column/row order.
This methods creates a 6 dimensional 'grid', where each dimension can map the a visual dimension.
The grid dimensions are:
* x: shape determined by shape, content by x argument or the first dimension of each space
* y: ,,
* z: related to the z argument
* selection: shape equals length of selection argument
* what: shape equals length of what argument
* space: shape equals length of x argument if multiple values are given
By default, this its shape is (1, 1, 1, 1, shape, shape) (where x is the last dimension)
The visual dimensions are
* x: x coordinate on a plot / image (default maps to grid's x)
* y: y ,, (default maps to grid's y)
* layer: each image in this dimension is blended togeher to one image (default maps to z)
* fade: each image is shown faded after the next image (default mapt to selection)
* row: rows of subplots (default maps to space)
* columns: columns of subplot (default maps to what)
All these mappings can be changes by the visual argument, some examples:
>>> df.plot('x', 'y', what=['mean(x)', 'correlation(vx, vy)'])
Will plot each 'what' as a column.
>>> df.plot('x', 'y', selection=['FeH < -3', '(FeH >= -3) & (FeH < -2)'], visual=dict(column='selection'))
Will plot each selection as a column, instead of a faded on top of each other.
:param x: Expression to bin in the x direction (by default maps to x), or list of pairs, like [['x', 'y'], ['x', 'z']], if multiple pairs are given, this dimension maps to rows by default
:param y: y (by default maps to y)
:param z: Expression to bin in the z direction, followed by a :start,end,shape signature, like 'FeH:-3,1:5' will produce 5 layers between -10 and 10 (by default maps to layer)
:param what: What to plot, count(*) will show a N-d histogram, mean('x'), the mean of the x column, sum('x') the sum, std('x') the standard deviation, correlation('vx', 'vy') the correlation coefficient. Can also be a list of values, like ['count(x)', std('vx')], (by default maps to column)
:param reduce:
:param f: transform values by: 'identity' does nothing 'log' or 'log10' will show the log of the value
:param normalize: normalization function, currently only 'normalize' is supported
:param normalize_axis: which axes to normalize on, None means normalize by the global maximum.
:param vmin: instead of automatic normalization, (using normalize and normalization_axis) scale the data between vmin and vmax to [0, 1]
:param vmax: see vmin
:param shape: shape/size of the n-D histogram grid
:param limits: list of [[xmin, xmax], [ymin, ymax]], or a description such as 'minmax', '99%'
:param grid: if the binning is done before by yourself, you can pass it
:param colormap: matplotlib colormap to use
:param figsize: (x, y) tuple passed to pylab.figure for setting the figure size
:param xlabel:
:param ylabel:
:param aspect:
:param tight_layout: call pylab.tight_layout or not
:param colorbar: plot a colorbar or not
:param interpolation: interpolation for imshow, possible options are: 'nearest', 'bilinear', 'bicubic', see matplotlib for more
:param return_extra:
:return:
"""
import pylab
import matplotlib
n = _parse_n(normalize)
if type(shape) == int:
shape = (shape,) * 2
binby = []
x = _ensure_strings_from_expressions(x)
y = _ensure_strings_from_expressions(y)
for expression in [y, x]:
if expression is not None:
binby = [expression] + binby
fig = pylab.gcf()
if figsize is not None:
fig.set_size_inches(*figsize)
import re
what_units = None
whats = _ensure_list(what)
selections = _ensure_list(selection)
selections = _ensure_strings_from_expressions(selections)
if y is None:
waslist, [x, ] = vaex.utils.listify(x)
else:
waslist, [x, y] = vaex.utils.listify(x, y)
x = list(zip(x, y))
limits = [limits]
# every plot has its own vwhat for now
vwhats = _expand_limits(vwhat, len(x)) # TODO: we're abusing this function..
logger.debug("x: %s", x)
limits, shape = self.limits(x, limits, shape=shape)
shape = shape[0]
logger.debug("limits: %r", limits)
# mapping of a grid axis to a label
labels = {}
shape = _expand_shape(shape, 2)
vshape = _expand_shape(shape, 2)
if z is not None:
match = re.match("(.*):(.*),(.*),(.*)", z)
if match:
groups = match.groups()
import ast
z_expression = groups[0]
logger.debug("found groups: %r", list(groups))
z_limits = [ast.literal_eval(groups[1]), ast.literal_eval(groups[2])]
z_shape = ast.literal_eval(groups[3])
# for pair in x:
x = [[z_expression] + list(k) for k in x]
limits = np.array([[z_limits] + list(k) for k in limits])
shape = (z_shape,) + shape
vshape = (z_shape,) + vshape
logger.debug("x = %r", x)
values = np.linspace(z_limits[0], z_limits[1], num=z_shape + 1)
labels["z"] = list(["%s <= %s < %s" % (v1, z_expression, v2) for v1, v2 in zip(values[:-1], values[1:])])
else:
raise ValueError("Could not understand 'z' argument %r, expected something in form: 'column:-1,10:5'" % facet)
else:
z_shape = 1
# z == 1
if z is None:
total_grid = np.zeros((len(x), len(whats), len(selections), 1) + shape, dtype=float)
total_vgrid = np.zeros((len(x), len(whats), len(selections), 1) + vshape, dtype=float)
else:
total_grid = np.zeros((len(x), len(whats), len(selections)) + shape, dtype=float)
total_vgrid = np.zeros((len(x), len(whats), len(selections)) + vshape, dtype=float)
logger.debug("shape of total grid: %r", total_grid.shape)
axis = dict(plot=0, what=1, selection=2)
xlimits = limits
grid_axes = dict(x=-1, y=-2, z=-3, selection=-4, what=-5, subspace=-6)
visual_axes = dict(x=-1, y=-2, layer=-3, fade=-4, column=-5, row=-6)
# visual_default=dict(x="x", y="y", z="layer", selection="fade", subspace="row", what="column")
# visual: mapping of a plot axis, to a grid axis
visual_default = dict(x="x", y="y", layer="z", fade="selection", row="subspace", column="what")
def invert(x): return dict((v, k) for k, v in x.items())
# visual_default_reverse = invert(visual_default)
# visual_ = visual_default
# visual = dict(visual) # copy for modification
# add entries to avoid mapping multiple times to the same axis
free_visual_axes = list(visual_default.keys())
# visual_reverse = invert(visual)
logger.debug("1: %r %r", visual, free_visual_axes)
for visual_name, grid_name in visual.items():
if visual_name in free_visual_axes:
free_visual_axes.remove(visual_name)
else:
raise ValueError("visual axes %s used multiple times" % visual_name)
logger.debug("2: %r %r", visual, free_visual_axes)
for visual_name, grid_name in visual_default.items():
if visual_name in free_visual_axes and grid_name not in visual.values():
free_visual_axes.remove(visual_name)
visual[visual_name] = grid_name
logger.debug("3: %r %r", visual, free_visual_axes)
for visual_name, grid_name in visual_default.items():
if visual_name not in free_visual_axes and grid_name not in visual.values():
visual[free_visual_axes.pop(0)] = grid_name
logger.debug("4: %r %r", visual, free_visual_axes)
visual_reverse = invert(visual)
# TODO: the meaning of visual and visual_reverse is changed below this line, super confusing
visual, visual_reverse = visual_reverse, visual
# so now, visual: mapping of a grid axis to plot axis
# visual_reverse: mapping of a grid axis to plot axis
move = {}
for grid_name, visual_name in visual.items():
if visual_axes[visual_name] in visual.values():
index = visual.values().find(visual_name)
key = visual.keys()[index]
raise ValueError("trying to map %s to %s while, it is already mapped by %s" % (grid_name, visual_name, key))
move[grid_axes[grid_name]] = visual_axes[visual_name]
# normalize_axis = _ensure_list(normalize_axis)
fs = _expand(f, total_grid.shape[grid_axes[normalize_axis]])
# assert len(vwhat)
# labels["y"] = ylabels
what_labels = []
if grid is None:
grid_of_grids = []
for i, (binby, limits) in enumerate(zip(x, xlimits)):
grid_of_grids.append([])
for j, what in enumerate(whats):
if isinstance(what, vaex.stat.Expression):
grid = what.calculate(self, binby=binby, shape=shape, limits=limits, selection=selections, delay=True)
else:
what = what.strip()
index = what.index("(")
import re
groups = re.match("(.*)\((.*)\)", what).groups()
if groups and len(groups) == 2:
function = groups[0]
arguments = groups[1].strip()
if "," in arguments:
arguments = arguments.split(",")
functions = ["mean", "sum", "std", "var", "correlation", "covar", "min", "max", "median_approx"]
unit_expression = None
if function in ["mean", "sum", "std", "min", "max", "median"]:
unit_expression = arguments
if function in ["var"]:
unit_expression = "(%s) * (%s)" % (arguments, arguments)
if function in ["covar"]:
unit_expression = "(%s) * (%s)" % arguments
if unit_expression:
unit = self.unit(unit_expression)
if unit:
what_units = unit.to_string('latex_inline')
if function in functions:
grid = getattr(self, function)(arguments, binby=binby, limits=limits, shape=shape, selection=selections, delay=True)
elif function == "count":
grid = self.count(arguments, binby, shape=shape, limits=limits, selection=selections, delay=True)
else:
raise ValueError("Could not understand method: %s, expected one of %r'" % (function, functions))
else:
raise ValueError("Could not understand 'what' argument %r, expected something in form: 'count(*)', 'mean(x)'" % what)
if i == 0: # and j == 0:
what_label = str(whats[j])
if what_units:
what_label += " (%s)" % what_units
if fs[j]:
what_label = fs[j] + " " + what_label
what_labels.append(what_label)
grid_of_grids[-1].append(grid)
self.execute()
for i, (binby, limits) in enumerate(zip(x, xlimits)):
for j, what in enumerate(whats):
grid = grid_of_grids[i][j].get()
total_grid[i, j, :, :] = grid[:, None, ...]
labels["what"] = what_labels
else:
dims_left = 6 - len(grid.shape)
total_grid = np.broadcast_to(grid, (1,) * dims_left + grid.shape)
# visual=dict(x="x", y="y", selection="fade", subspace="facet1", what="facet2",)
def _selection_name(name):
if name in [None, False]:
return "selection: all"
elif name in ["default", True]:
return "selection: default"
else:
return "selection: %s" % name
if selection_labels is None:
labels["selection"] = list([_selection_name(k) for k in selections])
else:
labels["selection"] = selection_labels
# visual_grid = np.moveaxis(total_grid, move.keys(), move.values())
# np.moveaxis is in np 1.11 only?, use transpose
axes = [None] * len(move)
for key, value in move.items():
axes[value] = key
visual_grid = np.transpose(total_grid, axes)
logger.debug("grid shape: %r", total_grid.shape)
logger.debug("visual: %r", visual.items())
logger.debug("move: %r", move)
logger.debug("visual grid shape: %r", visual_grid.shape)
xexpressions = []
yexpressions = []
for i, (binby, limits) in enumerate(zip(x, xlimits)):
xexpressions.append(binby[0])
yexpressions.append(binby[1])
if xlabel is None:
xlabels = []
ylabels = []
for i, (binby, limits) in enumerate(zip(x, xlimits)):
if z is not None:
xlabels.append(self.label(binby[1]))
ylabels.append(self.label(binby[2]))
else:
xlabels.append(self.label(binby[0]))
ylabels.append(self.label(binby[1]))
else:
Nl = visual_grid.shape[visual_axes['row']]
xlabels = _expand(xlabel, Nl)
ylabels = _expand(ylabel, Nl)
#labels[visual["x"]] = (xlabels, ylabels)
labels["x"] = xlabels
labels["y"] = ylabels
# grid = total_grid
# print(grid.shape)
# grid = self.reduce(grid, )
axes = []
# cax = pylab.subplot(1,1,1)
background_color = np.array(matplotlib.colors.colorConverter.to_rgb(background_color))
# if grid.shape[axis["selection"]] > 1:# and not facet:
# rgrid = vaex.image.fade(rgrid)
# finite_mask = np.any(finite_mask, axis=0) # do we really need this
# print(rgrid.shape)
# facet_row_axis = axis["what"]
import math
facet_columns = None
facets = visual_grid.shape[visual_axes["row"]] * visual_grid.shape[visual_axes["column"]]
if visual_grid.shape[visual_axes["column"]] == 1 and wrap:
facet_columns = min(wrap_columns, visual_grid.shape[visual_axes["row"]])
wrapped = True
elif visual_grid.shape[visual_axes["row"]] == 1 and wrap:
facet_columns = min(wrap_columns, visual_grid.shape[visual_axes["column"]])
wrapped = True
else:
wrapped = False
facet_columns = visual_grid.shape[visual_axes["column"]]
facet_rows = int(math.ceil(facets / facet_columns))
logger.debug("facet_rows: %r", facet_rows)
logger.debug("facet_columns: %r", facet_columns)
# if visual_grid.shape[visual_axes["row"]] > 1: # and not wrap:
# #facet_row_axis = axis["what"]
# facet_columns = visual_grid.shape[visual_axes["column"]]
# else:
# facet_columns = min(wrap_columns, facets)
# if grid.shape[axis["plot"]] > 1:# and not facet:
# this loop could be done using axis arguments everywhere
# assert len(normalize_axis) == 1, "currently only 1 normalization axis supported"
grid = visual_grid * 1.
fgrid = visual_grid * 1.
ngrid = visual_grid * 1.
# colorgrid = np.zeros(ngrid.shape + (4,), float)
# print "norma", normalize_axis, visual_grid.shape[visual_axes[visual[normalize_axis]]]
vmins = _expand(vmin, visual_grid.shape[visual_axes[visual[normalize_axis]]], type=list)
vmaxs = _expand(vmax, visual_grid.shape[visual_axes[visual[normalize_axis]]], type=list)
# for name in normalize_axis:
visual_grid
if smooth_pre:
grid = vaex.grids.gf(grid, smooth_pre)
if 1:
axis = visual_axes[visual[normalize_axis]]
for i in range(visual_grid.shape[axis]):
item = [slice(None, None, None), ] * len(visual_grid.shape)
item[axis] = i
item = tuple(item)
f = _parse_f(fs[i])
with np.errstate(divide='ignore', invalid='ignore'): # these are fine, we are ok with nan's in vaex
fgrid.__setitem__(item, f(grid.__getitem__(item)))
# print vmins[i], vmaxs[i]
if vmins[i] is not None and vmaxs[i] is not None:
nsubgrid = fgrid.__getitem__(item) * 1
nsubgrid -= vmins[i]
nsubgrid /= (vmaxs[i] - vmins[i])
else:
nsubgrid, vmin, vmax = n(fgrid.__getitem__(item))
vmins[i] = vmin
vmaxs[i] = vmax
# print " ", vmins[i], vmaxs[i]
ngrid.__setitem__(item, nsubgrid)
if 0: # TODO: above should be like the code below, with custom vmin and vmax
grid = visual_grid[i]
f = _parse_f(fs[i])
fgrid = f(grid)
finite_mask = np.isfinite(grid)
finite_mask = np.any(finite_mask, axis=0)
if vmin is not None and vmax is not None:
ngrid = fgrid * 1
ngrid -= vmin
ngrid /= (vmax - vmin)
ngrid = np.clip(ngrid, 0, 1)
else:
ngrid, vmin, vmax = n(fgrid)
# vmin, vmax = np.nanmin(fgrid), np.nanmax(fgrid)
# every 'what', should have its own colorbar, check if what corresponds to
# rows or columns in facets, if so, do a colorbar per row or per column
rows, columns = int(math.ceil(facets / float(facet_columns))), facet_columns
colorbar_location = "individual"
if visual["what"] == "row" and visual_grid.shape[1] == facet_columns:
colorbar_location = "per_row"
if visual["what"] == "column" and visual_grid.shape[0] == facet_rows:
colorbar_location = "per_column"
# values = np.linspace(facet_limits[0], facet_limits[1], facet_count+1)
logger.debug("rows: %r, columns: %r", rows, columns)
import matplotlib.gridspec as gridspec
column_scale = 1
row_scale = 1
row_offset = 0
if facets > 1:
if colorbar_location == "per_row":
column_scale = 4
gs = gridspec.GridSpec(rows, columns * column_scale + 1)
elif colorbar_location == "per_column":
row_offset = 1
row_scale = 4
gs = gridspec.GridSpec(rows * row_scale + 1, columns)
else:
gs = gridspec.GridSpec(rows, columns)
facet_index = 0
fs = _expand(f, len(whats))
colormaps = _expand(colormap, len(whats))
# row
for i in range(visual_grid.shape[0]):
# column
for j in range(visual_grid.shape[1]):
if colorbar and colorbar_location == "per_column" and i == 0:
norm = matplotlib.colors.Normalize(vmins[j], vmaxs[j])
sm = matplotlib.cm.ScalarMappable(norm, colormaps[j])
sm.set_array(1) # make matplotlib happy (strange behavious)
if facets > 1:
ax = pylab.subplot(gs[0, j])
colorbar = fig.colorbar(sm, cax=ax, orientation="horizontal")
else:
colorbar = fig.colorbar(sm)
if "what" in labels:
label = labels["what"][j]
if facets > 1:
colorbar.ax.set_title(label)
else:
colorbar.ax.set_ylabel(colorbar_label or label)
if colorbar and colorbar_location == "per_row" and j == 0:
norm = matplotlib.colors.Normalize(vmins[i], vmaxs[i])
sm = matplotlib.cm.ScalarMappable(norm, colormaps[i])
sm.set_array(1) # make matplotlib happy (strange behavious)
if facets > 1:
ax = pylab.subplot(gs[i, -1])
colorbar = fig.colorbar(sm, cax=ax)
else:
colorbar = fig.colorbar(sm)
label = labels["what"][i]
colorbar.ax.set_ylabel(colorbar_label or label)
rgrid = ngrid[i, j] * 1.
# print rgrid.shape
for k in range(rgrid.shape[0]):
for l in range(rgrid.shape[0]):
if smooth_post is not None:
rgrid[k, l] = vaex.grids.gf(rgrid, smooth_post)
if visual["what"] == "column":
what_index = j
elif visual["what"] == "row":
what_index = i
else:
what_index = 0
if visual[normalize_axis] == "column":
normalize_index = j
elif visual[normalize_axis] == "row":
normalize_index = i
else:
normalize_index = 0
for r in reduce:
r = _parse_reduction(r, colormaps[what_index], [])
rgrid = r(rgrid)
row = facet_index // facet_columns
column = facet_index % facet_columns
if colorbar and colorbar_location == "individual":
# visual_grid.shape[visual_axes[visual[normalize_axis]]]
norm = matplotlib.colors.Normalize(vmins[normalize_index], vmaxs[normalize_index])
sm = matplotlib.cm.ScalarMappable(norm, colormaps[what_index])
sm.set_array(1) # make matplotlib happy (strange behavious)
if facets > 1:
ax = pylab.subplot(gs[row, column])
colorbar = fig.colorbar(sm, ax=ax)
else:
colorbar = fig.colorbar(sm)
label = labels["what"][what_index]
colorbar.ax.set_ylabel(colorbar_label or label)
if facets > 1:
ax = pylab.subplot(gs[row_offset + row * row_scale:row_offset + (row + 1) * row_scale, column * column_scale:(column + 1) * column_scale])
else:
ax = pylab.gca()
axes.append(ax)
logger.debug("rgrid: %r", rgrid.shape)
plot_rgrid = rgrid
assert plot_rgrid.shape[1] == 1, "no layers supported yet"
plot_rgrid = plot_rgrid[:, 0]
if plot_rgrid.shape[0] > 1:
plot_rgrid = vaex.image.fade(plot_rgrid[::-1])
else:
plot_rgrid = plot_rgrid[0]
extend = None
if visual["subspace"] == "row":
subplot_index = i
elif visual["subspace"] == "column":
subplot_index = j
else:
subplot_index = 0
extend = np.array(xlimits[subplot_index][-2:]).flatten()
# extend = np.array(xlimits[i]).flatten()
logger.debug("plot rgrid: %r", plot_rgrid.shape)
plot_rgrid = np.transpose(plot_rgrid, (1, 0, 2))
im = ax.imshow(plot_rgrid, extent=extend.tolist(), origin="lower", aspect=aspect, interpolation=interpolation)
# v1, v2 = values[i], values[i+1]
def label(index, label, expression):
if label and _issequence(label):
return label[i]
else:
return self.label(expression)
if visual_reverse["x"] =='x':
labelsx = labels['x']
pylab.xlabel(labelsx[subplot_index])
if visual_reverse["x"] =='x':
labelsy = labels['y']
pylab.ylabel(labelsy[subplot_index])
if visual["z"] in ['row']:
labelsz = labels['z']
ax.set_title(labelsz[i])
if visual["z"] in ['column']:
labelsz = labels['z']
ax.set_title(labelsz[j])
max_labels = 10
xexpression = xexpressions[subplot_index]
if self.iscategory(xexpression):
labels = self.category_labels(xexpression)
step = max(len(labels) // max_labels, 1)
pylab.xticks(np.arange(len(labels))[::step], labels[::step], size='small')
yexpression = yexpressions[subplot_index]
if self.iscategory(yexpression):
labels = self.category_labels(yexpression)
step = max(len(labels) // max_labels, 1)
pylab.yticks(np.arange(len(labels))[::step], labels[::step], size='small')
facet_index += 1
if title:
fig.suptitle(title, fontsize="x-large")
if tight_layout:
if title:
pylab.tight_layout(rect=[0, 0.03, 1, 0.95])
else:
pylab.tight_layout()
if hardcopy:
pylab.savefig(hardcopy)
if show:
pylab.show()
if return_extra:
return im, grid, fgrid, ngrid, rgrid
else:
return im
C, _C, _Cx = {}, {}, {}
for k in days:
I[k], _I[k], _Ix[k] = {}, {}, {}
C[k], _C[k], _Cx[k] = {}, {}, {}
for bl in x[k]:
C[k][bl] = cov(x[k][bl])
I[k][bl] = n.identity(C[k][bl].shape[0])
#C[k][bl] = C[k][bl] + 1*I[k][bl] #C+NI noise
U, S, V = n.linalg.svd(C[k][bl].conj()) #singular value decomposition
_C[k][bl] = n.einsum('ij,j,jk', V.T, 1. / S, U.T)
_I[k][bl] = n.identity(_C[k][bl].shape[0])
_Cx[k][bl] = n.dot(_C[k][bl], x[k][bl])
_Ix[k][bl] = x[k][bl].copy()
if PLOT and True:
#p.plot(S); p.show()
p.subplot(311)
capo.arp.waterfall(x[k][bl], mode='real')
p.title('Data x')
p.subplot(323)
capo.arp.waterfall(C[k][bl])
p.title('C')
p.subplot(324)
p.plot(n.einsum('ij,jk', n.diag(S), V).T.real)
p.subplot(313)
capo.arp.waterfall(_Cx[k][bl], mode='real')
p.title('C^-1 x')
p.suptitle('%d_%d' % a.miriad.bl2ij(bl) + ' ' + k)
#p.figure(2); p.plot(n.diag(S))
p.tight_layout()
p.show()
def plot(self,fn=None,idens=0,functions='all',properties=None,fignumber=1):
"""Plot density statistics against rho_cut for reference (black) and density 0 (red).
plot(filename,properties=<dict of dicts>)
Plot various functions of the density cut-off rho_cut. Current
functions are 'sites', 'volume', 'occupancy', or 'all'.
Plots can be customized by using the properties dict. To
change the ylim and add an title to the sites graph, use
properties = {'sites': {ylim':(0,220),'title':'number of sites'}}
:Arguments:
fn file name for the file; default is scan.pdf. Suffix determines file type.
idens number of density plot; the first one is 0 in self.scanarrays[].
functions list of function names or 'all'
properties dict1 of dicts; keys1: sites, volume, occupancy;
keys2: any matplotlib settable property, values2: appropriate values
fignumber pylab figure number
"""
import pylab
available_functions = ['sites', 'volume', 'occupancy']
plot_functions = []
if functions is 'all':
plot_functions = available_functions
else:
for f in functions:
if f in available_functions:
plot_functions.append(f)
else:
raise ValueError('No function '+str(f)+' is available, only '+
str(available_functions))
props = self.__plot_properties_default.copy()
if type(properties) is dict:
for k,userparams in properties.items():
try:
props[k].update(userparams)
except KeyError:
props[k] = userparams
r = self.scanarrays['reference']
d = self.scanarrays[idens]
pylab.figure(fignumber)
pylab.clf()
pylab.axes(axisbg='w',frameon=False)
par = props['sites']
pylab.subplot(221)
pylab.plot(r.rho_cut,r.N_equivalence_sites,'ko',label="N_equiv")
pylab.plot(r.rho_cut,r.N_sites,'kx',label="N_sites")
pylab.plot(r.rho_cut,d.N_sites,'rx')
pylab.ylim(par['ylim'])
#pylab.legend()
# refine err bar plots
alpha = 1 # acts on the line not on the errorbar markers
capsize=0
par = props['volume']
pylab.subplot(222)
pylab.errorbar(r.rho_cut,r.site_volume_avg,yerr=r.site_volume_std,
color='k',capsize=capsize,alpha=alpha,label="volume")
pylab.errorbar(r.rho_cut,d.site_volume_avg,yerr=d.site_volume_std,
color='r',capsize=capsize,alpha=alpha,label="volume")
pylab.ylim(par['ylim'])
pylab.ylabel(par['ylabel'])
# [pylab.set(pylab.gca(), k, v) for k,v in par.items()]
par = props['occupancy']
pylab.subplot(223)
pylab.errorbar(r.rho_cut,r.site_occupancy_rho_avg,yerr=r.site_occupancy_rho_std,
color='k',capsize=capsize,alpha=alpha)
pylab.errorbar(r.rho_cut,d.site_occupancy_rho_avg,yerr=d.site_occupancy_rho_std,
color='r',capsize=capsize,alpha=alpha)
#pylab.legend()
pylab.ylim(par['ylim'])
pylab.xlabel(par['xlabel'])
pylab.ylabel(par['ylabel'])
pylab.savefig(fn)
msg(1, "Graph saved to %s\n" % fn)
pylab.close(fignumber)
noise_independent_smooth=1.5,
noise_common_n=1,
noise_common_std=3)
# just a little helper
def get2d(ds):
return dss[0].a.mapper.reverse(ds)
import pylab as pl
pl.clf()
DS = dsvstack(dss)
# Sample plots
for s in [0, 1]:
ds2 = get2d(dss[0])
for r in [0, 1]:
pl.subplot(3, 3, 1 + r + s * 3)
pl.imshow(ds2[ds2.sa.chunks == r].samples[0],
interpolation='nearest')
pl.ylabel('subj%d' % s)
pl.xlabel('run1')
pl.subplot(3, 3, 3 + s * 3)
pl.imshow(get2d(mean_group_sample(['dissimilarity'
])(dss[0]).samples)[0],
interpolation='nearest')
pl.xlabel('mean')
ds = dsvstack(dss)
ds.a['mapper'] = dss[0].a.mapper
ds_mean = mean_group_sample(['dissimilarity', 'chunks'])(ds)
for r in [0, 1]:
ds_mean_run0 = ds.a.mapper.reverse(ds_mean[ds_mean.chunks == r])
def allele_plot(filename, normalize=False, alleles=None, generations=None):
"""Plot the alleles from each generation from the individuals file.
This function creates a plot of the individual allele values as they
change through the generations. It creates three subplots, one for each
of the best, median, and average individual. The best and median
individuals are chosen using the fitness data for each generation. The
average individual, on the other hand, is actually an individual created
by averaging the alleles within a generation. This function requires the
pylab library.
.. note::
This function only works for single-objective problems.
.. figure:: _static/allele_plot.png
:alt: Example allele plot
:align: center
An example image saved from the ``allele_plot`` function.
Arguments:
- *filename* -- the name of the individuals file produced by the file_observer
- *normalize* -- Boolean value stating whether allele values should be
normalized before plotting (default False)
- *alleles* -- a list of allele index values that should be plotted
(default None)
- *generations* -- a list of generation numbers that should be plotted
(default None)
If *alleles* is ``None``, then all alleles are plotted. Similarly, if
*generations* is ``None``, then all generations are plotted.
"""
import pylab
generation_data = []
reader = csv.reader(open(filename))
for row in reader:
g = int(row[0])
row[3] = row[3].replace('[', '')
row[-1] = row[-1].replace(']', '')
individual = [float(r) for r in row[3:]]
individual.append(float(row[2]))
try:
generation_data[g]
except IndexError:
generation_data.append([])
generation_data[g].append(individual)
for gen in generation_data:
gen.sort(key=lambda x: x[-1])
for j, g in enumerate(gen):
gen[j] = g[:-1]
best = []
median = []
average = []
for gen in generation_data:
best.append(gen[0])
plen = len(gen)
if plen % 2 == 1:
med = gen[(plen - 1) // 2]
else:
med = []
for a, b in zip(gen[plen // 2 - 1], gen[plen // 2]):
med.append(float(a + b) / 2)
median.append(med)
avg = [0] * len(gen[0])
for individual in gen:
for i, allele in enumerate(individual):
avg[i] += allele
for i, a in enumerate(avg):
avg[i] /= float(len(gen))
average.append(avg)
for plot_num, (data, title) in enumerate(
zip([best, median, average], ["Best", "Median", "Average"])):
if alleles is None:
alleles = list(range(len(data[0])))
if generations is None:
generations = list(range(len(data)))
if normalize:
columns = list(zip(*data))
max_col = [max(c) for c in columns]
min_col = [min(c) for c in columns]
for dat in data:
for i, d in enumerate(dat):
dat[i] = (d - min_col[i]) / float(max_col[i] - min_col[i])
plot_data = []
for g in generations:
plot_data.append([data[g][a] for a in alleles])
sub = pylab.subplot(3, 1, plot_num + 1)
pylab.pcolor(pylab.array(plot_data))
pylab.colorbar()
step_size = max(len(generations) // 7, 1)
ytick_locs = list(range(step_size, len(generations), step_size))
ytick_labs = generations[step_size::step_size]
pylab.yticks(ytick_locs, ytick_labs)
pylab.ylabel('Generation')
if plot_num == 2:
xtick_locs = list(range(len(alleles)))
xtick_labs = alleles
pylab.xticks(xtick_locs, xtick_labs)
pylab.xlabel('Allele')
else:
pylab.setp(sub.get_xticklabels(), visible=False)
pylab.title(title)
pylab.show()
########################################
## Load reconstructed signals
with open("op.pkl", "rb") as f:
params = pickle.load(f)
y0 = np.array(params["y0"], dtype=np.float64)
theta = np.array(params["theta"], dtype=np.float64)
########################################
## Reconstruct signal
Y0_rec = y0
W_rec, K_rec = convert_theta(len(y0), theta)
Y0_rec, W_rec, K_rec = Y0_rec[:N], W_rec[:N], K_rec[:N, :N]
y_rec = compute_kuramoto(ts, Y0_rec, W_rec, K_rec)
########################################
## Plot for each oscillator
for osc in range(N):
plt.subplot(N, 2, 2 * osc + 1)
plt.plot(ts, y_in[osc], 'g')
plt.plot(ts, y_rec[osc], 'r')
plt.title("Osc " + str(osc + 1))
plt.subplot(N, 2, 2 * osc + 2)
plt.plot(ts, y_in[osc] - y_rec[osc], 'g')
plt.title("Pointwise diff")
plt.tight_layout()
plt.show()
if interactivePlot:
pylab.ion()
pylab.figure()
pylab.title('Interactive plot of the FFT vs LPC frequency response')
pylab.gca().set_ylim([-100, 40])
pylab.gca().set_autoscale_on(False)
for frame in stream:
fft = ffter.process(windower.process(frame))
spec = loudia.magToDb(abs(fft))
wspec = whitening.process(spec)
pitch, saliency = pitchSaliency.process(wspec)
if interactivePlot:
pylab.subplot(211)
pylab.hold(False)
pylab.plot(spec[0, :plotSize])
pylab.subplot(212)
pylab.hold(False)
pylab.plot(result[0, :], label='Noise Suppressed Spectrum')
specs.append(spec[0, :plotSize])
wspecs.append(wspec[0, :plotSize])
pitches.append(pitch)
saliencies.append(saliency)
if interactivePlot:
pylab.ioff()
def regression_gaussian_process_modelselection (n=100, n_test=100, \
x_range=5, x_range_test=10, noise_var=0.4):
from modshogun import RealFeatures, RegressionLabels
from modshogun import GaussianKernel
from modshogun import GradientModelSelection, ModelSelectionParameters
from modshogun import GaussianLikelihood, ZeroMean, \
ExactInferenceMethod, GaussianProcessRegression, GradientCriterion, \
GradientEvaluation
# easy regression data: one dimensional noisy sine wave
X_train = random.rand(1, n) * x_range
X_test = array([[float(i) / n_test * x_range_test for i in range(n_test)]])
y_test = sin(X_test)
y_train = sin(X_train) + random.randn(n) * noise_var
# shogun representation
labels = RegressionLabels(y_train[0])
feats_train = RealFeatures(X_train)
feats_test = RealFeatures(X_test)
# GP specification
kernel = GaussianKernel(10, 0.05)
mean = ZeroMean()
likelihood = GaussianLikelihood(0.8)
inf = ExactInferenceMethod(kernel, feats_train, mean, labels, likelihood)
inf.set_scale(2.5)
gp = GaussianProcessRegression(inf)
means = gp.get_mean_vector(feats_test)
variances = gp.get_variance_vector(feats_test)
# plot results
figure()
subplot(2, 1, 1)
title('Initial parameter\'s values')
plot(X_train[0], y_train[0], 'bx') # training observations
plot(X_test[0], y_test[0], 'g-') # ground truth of test
plot(X_test[0], means, 'r-') # mean predictions of test
fill_between(X_test[0],
means - 1.96 * sqrt(variances),
means + 1.96 * sqrt(variances),
color='grey')
legend(["training", "ground truth", "mean predictions"])
# evaluate our inference method for its derivatives
grad = GradientEvaluation(gp, feats_train, labels, GradientCriterion(),
False)
grad.set_function(inf)
# handles all of the above structures in memory
grad_search = GradientModelSelection(grad)
# search for best parameters
best_combination = grad_search.select_model(True)
# outputs all result and information
best_combination.apply_to_machine(gp)
means = gp.get_mean_vector(feats_test)
variances = gp.get_variance_vector(feats_test)
# plot results
subplot(2, 1, 2)
title('Selected by gradient search parameter\'s values')
plot(X_train[0], y_train[0], 'bx') # training observations
plot(X_test[0], y_test[0], 'g-') # ground truth of test
plot(X_test[0], means, 'r-') # mean predictions of test
fill_between(X_test[0],
means - 1.96 * sqrt(variances),
means + 1.96 * sqrt(variances),
color='grey')
legend(["training", "ground truth", "mean predictions"])
show()
depthFrameData.load(srcVideoPath)
srcVideoPath = join(videoDirectory,firstFile+colorVideoSuffix+videoFilenameExtension)
colorFrameData = VideoFrameData()
colorFrameData.load(srcVideoPath)
i = 0
resultImages = []
depthRetval,depthFrame = depthFrameData.readFrame()
colorRetval,colorFrame = colorFrameData.readFrame()
labelRetval,labelFrame = labelFrameData.readFrame()
skeletonRetval,skeletonFrame = skeletonFrameData.readFrame()
if not depthRetval or not colorRetval or not labelRetval or not skeletonRetval:
exit
encodedFrame = FrameConverter().encode(depthFrame, colorFrame, labelFrame, skeletonFrame)
plt.subplot(1,2,1), plt.imshow(depthFrame)
plt.subplot(1,2,2), plt.imshow(colorFrame)
plt.show()
argc = len(sys.argv)
if argc > 1:
host = sys.argv[1]
else:
host = 'localhost'
client = HandShapeClient(host, port)
client.send_data(encodedFrame)
if res_fname.find('NV') > 0:
x = [i for g in sx for i in g]
y = [i for g in data[cl] for i in g]
else:
x = [
i for k, g in enumerate(sx)
if my_groups[k] in ['persistent', 'remission'] for i in g
]
y = [
i for k, g in enumerate(data[cl])
if my_groups[k] in ['persistent', 'remission'] for i in g
]
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
if not quiet:
pl.subplot(nrows, ncols, cnt)
# make the scatterplot first
pl.plot(x, y, '.b', ms=10)
line = slope * np.array(x) + intercept
pl.plot(x, line, 'r-', linewidth=5)
pl.title('r = %.2f, p < %.2f, cluster %d' % (r_value, p_value, cl + 1))
pl.xlabel('symptoms')
pl.ylabel('zscores')
ax = pl.gca()
ax.yaxis.labelpad = -5
pl.axis('tight')
cnt += 1
# now do the barplot
pl.subplot(nrows, ncols, cnt)
ybars = [np.mean(data[cl][i]) for i in range(len(my_groups))]
p #delta=-1 # Extinsion de las presas y luego de los depredadores
x[:, 0] = [a / b * (1 + delta),
c / d * (1 - delta)] #fijo condiciones iniciales
#ya podemos integrar de forma muy parecida a una variable
for i in range(len(t) - 1):
x[:, i + 1] = int_rk4(
derivada, x[:, i], dt,
params) #ahora donde ponía números pongo vectorcitos en las x
#veo como dio
x0 = x[0, :] #resultados de la primer especio
x1 = x[1, :] #resultados de la segunda especie
#grafiquemos
plb.subplot(211)
plb.plot(t, x0, label='Presas') #le pongo leyendas a cada especie
plb.plot(t, x1, label='Deredadores')
plb.xlabel('Tiempo')
plb.ylabel('Población')
plb.title('Modelo Lotka-Volterra')
plb.legend(loc='upper right', fontsize=10) #le digo dónde poner las leyendas
plb.show(
) #le digo que muestre las leyendas (sin este comando no van a aparecer) plb.subplot(121)
plb.subplot(212)
plb.plot(x0, x1) #le pongo leyendas a cada especie
plb.xlabel('Presas')
plb.ylabel('Depredadores')
all_movs,shifts,corss,_=all_movs.motion_correct(template=None,max_shift_w=45, max_shift_h=45)
#%%
template=np.median(all_movs[:],axis=0)
np.save(base_folder+'template_total',template)
pl.imshow(template,cmap=pl.cm.gray,vmax=120)
#%%
all_movs.play(backend='opencv',gain=10,fr=10)
#%%
t1 = time()
file_res=cb.motion_correct_parallel(fnames,30,template=template,margins_out=0,max_shift_w=45, max_shift_h=45,client=c,remove_blanks=False)
t2=time()-t1
print(t2)
#%%
for f in file_res:
with np.load(f+'npz') as fl:
pl.subplot(2,2,1)
pl.imshow(fl['template'],cmap=pl.cm.gray,vmin=np.percentile(fl['template'],1),vmax=np.percentile(fl['template'],99))
pl.subplot(2,2,3)
pl.plot(fl['xcorrs'])
pl.subplot(2,2,2)
pl.plot(fl['shifts'])
pl.pause(0.1)
pl.cla()
print((time() - t1 - 200))
#%%
all_movs=[]
for f in glob.glob(base_folder+'*.hdf5'):
print(f)
with np.load(f[:-4]+'npz') as fl:
pylab.legend()
#### Dois (ou mais gráficos) em uma janela de figura
O comando `pylab.subplot` permite-lhe organizar vários gráficos dentro da mesma janela. A sintaxe geral é
subplot(numRows, numCols, plotNum)
Aqui está um exemplo completo de plotagem das curvas seno e cosseno em dois gráficos alinhados um embaixo do outro na mesma janela:
import numpy as N
t = N.arange (0 , 2 * N . pi , 0.01)
import pylab
pylab.subplot(2, 1, 1)
pylab.plot(t, N.sin(t))
pylab.xlabel('t')
pylab.ylabel('sen(t)')
pylab.subplot(2, 1, 2)
pylab.plot(t, N.cos(t))
pylab.xlabel('t')
pylab.ylabel('cos(t)')
import pylab
pylab.figure(1)
pylab.plot(range(10),'o')
pylab.figure(2)
pylab.plot(range(100),'x')
}
benchs = list(json.loads(Path("ultraopt.json").read_text()).keys())
cols = int(np.sqrt(len(benchs)))
rows = int(np.ceil(len(benchs) / cols))
plt.rcParams['font.family'] = 'YaHei Consolas Hybrid' # 设置字体样式
plt.rcParams['figure.figsize'] = (15, 12)
# plt.suptitle("对比")
# log_scale=True
for log_scale in [True, False]:
plt.close()
index = 1
for bench in benchs:
plt.subplot(rows, cols, index)
for name, (color,) in info.items():
mean_std = json.loads(Path(f"{name}.json").read_text())[bench]
mean = np.array(mean_std["mean"])
std = np.array(mean_std["std"])
iters = range(len(mean))
if not log_scale:
plt.fill_between(
iters, mean - std, mean + std, alpha=0.1,
color=color
)
plt.plot(
iters, mean, color=color, label=name, alpha=0.9
)
plt.title(bench)
index += 1
bins = 20
xlabel = 'Ground state probability'
ylabel = 'Population'
xlim = [0, 1]
ylim = [0, sims]
labelfsize = 16
normed = False
fig = pl.figure(figsize=(8, 9))
fig.suptitle(r'$N_{qubits} = ' + str(n) + '$, $T_{final} = ' + str(time) +
'$, $P = 3$, $G = N-n/2N$',
fontsize=14)
pl.grid(True)
# Plot the stuff
pl.subplot(3, 1, 1)
pl.title('Hebb rule')
pl.xlim(xlim)
pl.ylim(ylim)
pl.hist(x=hebbData, bins=bins, range=(0, 1), normed=normed)
pl.subplot(3, 1, 2)
pl.title('Storkey rule')
pl.ylabel(ylabel, fontweight='bold', fontsize=labelfsize)
pl.xlim(xlim)
pl.ylim(ylim)
pl.hist(x=storkData, bins=bins, range=(0, 1), normed=normed)
pl.subplot(3, 1, 3)
pl.title('Projection rule')
pl.xlabel(xlabel, fontweight='bold', fontsize=labelfsize)
f.close()
rot = []
cofx = []
cofy = []
coa = []
for line in lines:
words = line.split()
rot.append(float(words[1]))
cofx.append(float(words[2]))
cofy.append(float(words[3]))
coa.append(float(words[4]))
# pylab.figure(figsize=(10,14))
pylab.figure()
pylab.subplot(221)
pylab.plot(rot)
pylab.title("rot")
pylab.subplot(222)
pylab.plot(cofx)
pylab.title('cofx')
pylab.subplot(223)
pylab.plot(cofy)
pylab.title('cofy')
pylab.subplot(224)
pylab.plot(coa)
pylab.title('coa')
i = i + 1
#print(array)
# ADC_output_code = MCP3201.readADC_LSB()
# ADC_voltage = MCP3201.convert_to_voltage(ADC_output_code)
# print("MCP3201 output code (LSB-mode): %d" % ADC_output_code)
# print("MCP3201 voltage: %0.2f V" % ADC_voltage)
#print()
#sleep(0.1)
write_data(array)
fft_function()
except (KeyboardInterrupt):
print('\n', "Exit on Ctrl-C: Good bye!")
except:
print("Other error or exception occurred!")
raise
finally:
fft_signal = fft_function(array)
plt.subplot(221)
plt.plot(time, array)
plt.subplot(222)
plt.plot(20 * log10(abs(fft_signal)))
#plt.xlim(0,25)
plt.show()
print()
def VibrationSpecgram(self, event):
import pylab as pl
pipeline = self.visFr.pipeline
x = pipeline['x']
y = pipeline['y']
x -= x.mean()
y -= y.mean()
xStd = []
yStd = []
window = 80
for i in range(len(x) - window):
xStd.append(x[i:i + window].std())
yStd.append(y[i:i + window].std())
xDrift = abs(x[0:window].mean() - x[-window - 1:-1].mean())
yDrift = abs(y[0:window].mean() - y[-window - 1:-1].mean())
### create Spectrogram data and axes bounds
# set parameters for specgram
NFFT = 1024
noverlap = int(NFFT * .9)
Fs = 1 / pipeline.mdh.getEntry('Camera.CycleTime')
# create specgram data
pl.figure('Specgram for X and Y', figsize=(16, 6))
xData, xFreq, xBins, a = pl.specgram(x,
NFFT=NFFT,
noverlap=noverlap,
Fs=Fs,
detrend=pl.detrend_linear)
yData, yFreq, yBins, b = pl.specgram(y,
NFFT=NFFT,
noverlap=noverlap,
Fs=Fs,
detrend=pl.detrend_linear)
pl.clf()
# convert to dB
xData = 10 * np.log10(xData)
yData = 10 * np.log10(yData)
# create upper limit for colorbar
ColorbarMax = max(25, xData.max(), yData.max())
### plot spectrograms
# X
pl.subplot(121)
pl.imshow(xData,
aspect='auto',
clim=[-15, ColorbarMax],
origin='lower',
interpolation='nearest',
extent=[xBins[0], xBins[-1], xFreq[0], xFreq[-1]])
pl.title('X')
pl.ylabel('frequency [Hz]')
#pl.yticks(freqLabels[0], freqLabels[1])
pl.xlabel(
'framebin [s]\nx-drift(min-max): %d nm, vibration-std(80fr): %d nm'
% (xDrift, np.average(xStd)))
#pl.xticks(binLabels[0], binLabels[1])
pl.colorbar()
# Y
pl.subplot(122)
pl.imshow(yData,
aspect='auto',
clim=[-15, ColorbarMax],
origin='lower',
interpolation='nearest',
extent=[xBins[0], xBins[-1], xFreq[0], xFreq[-1]])
pl.title('Y')
pl.ylabel('frequency [Hz]')
#pl.yticks(freqLabels[0], freqLabels[1])
pl.xlabel(
'framebin [s]\ny-drift(min-max): %d nm, vibration-std(80fr): %d nm'
% (yDrift, np.average(yStd)))
#pl.xticks(binLabels[0], binLabels[1])
pl.colorbar()
# plot x, y vs time to visualize drift
pl.figure('x- and y-drift visualization')
pl.plot(pipeline['t'] / Fs, x)
pl.xlabel('Time [s]')
pl.plot(pipeline['t'] / Fs, y)
pl.ylabel('relative position [nm]')
def main(argv=None):
"""script main.
parses command line options in sys.argv, unless *argv* is given.
"""
if argv is None:
argv = sys.argv
parser = E.OptionParser(
version=
"%prog version: $Id: plot_matrix.py 2782 2009-09-10 11:40:29Z andreas $"
)
parser.add_option("-c",
"--columns",
dest="columns",
type="string",
help="columns to take from table.")
parser.add_option("-a",
"--hardcopy",
dest="hardcopy",
type="string",
help="write hardcopy to file.",
metavar="FILE")
parser.add_option("-f",
"--file",
dest="input_filename",
type="string",
help="filename with table data.",
metavar="FILE")
parser.add_option("-p",
"--plot",
dest="plot",
type="string",
help="plots to plot.",
action="append")
parser.add_option("-t",
"--threshold",
dest="threshold",
type="float",
help="min threshold to use for counting method.")
parser.add_option("-o",
"--colours",
dest="colours",
type="int",
help="column with colour information.")
parser.add_option("-l",
"--plot-labels",
dest="labels",
type="string",
help="column labels for x and y in matched plots.")
parser.add_option("-e",
"--header-names",
dest="headers",
action="store_true",
help="headers are supplied in matrix.")
parser.add_option("--no-headers",
dest="headers",
action="store_false",
help="headers are not supplied in matrix.")
parser.add_option("--normalize",
dest="normalize",
action="store_true",
help="normalize matrix.")
parser.add_option("--palette",
dest="palette",
type="choice",
choices=("rainbow", "gray", "blue-white-red", "autumn",
"bone", "cool", "copper", "flag", "gray", "hot",
"hsv", "jet", "pink", "prism", "spring",
"summer", "winter", "spectral", "RdBu", "RdGy",
"BrBG", "BuGn", "Blues", "Greens", "Reds",
"Oranges", "Greys"),
help="colour palette [default=%Default]")
parser.add_option("--reverse-palette",
dest="reverse_palette",
action="store_true",
help="reverse the palette [default=%default].")
parser.add_option("",
"--xrange",
dest="xrange",
type="string",
help="xrange.")
parser.add_option("",
"--yrange",
dest="yrange",
type="string",
help="yrange.")
parser.add_option("",
"--zrange",
dest="zrange",
type="string",
help="zrange.")
parser.add_option("",
"--xticks",
dest="xticks",
type="string",
help="xticks.")
parser.add_option("",
"--yticks",
dest="yticks",
type="string",
help="yticks.")
parser.add_option("--bar-format",
dest="bar_format",
type="string",
help="format for ticks on colourbar.")
parser.add_option("--title",
dest="title",
type="string",
help="title to use.")
parser.add_option("--missing-value",
dest="missing",
type="float",
help="value to use for missing data.")
parser.add_option(
"--subplots",
dest="subplots",
type="string",
help=
"split matrix into several subplots. Supply number of rows and columns separated by a comma."
)
parser.set_defaults(hardcopy=None,
input_filename="-",
columns="all",
statistics=[],
plot=[],
threshold=0.0,
labels="x,y",
colours=None,
xrange=None,
yrange=None,
zrange=None,
palette=None,
reverse_palette=False,
xticks=None,
yticks=None,
normalize=False,
bar_format="%1.1f",
headers=True,
missing=None,
title=None,
subplots=None)
(options, args) = E.start(parser)
# import matplotlib/pylab. Has to be done here
# for batch scripts without GUI.
import matplotlib
if options.hardcopy:
matplotlib.use("cairo")
import pylab
if len(args) > 0:
options.input_filename = ",".join(args)
if options.xticks:
options.xticks = options.xticks.split(",")
if options.yticks:
options.yticks = options.yticks.split(",")
if options.xrange:
options.xrange = list(map(float, options.xrange.split(",")))
if options.yrange:
options.yrange = list(map(float, options.yrange.split(",")))
if options.columns != "all":
options.columns = [int(x) - 1 for x in options.columns.split(",")]
filenames = options.input_filename.split(",")
if len(filenames) > 1:
nsubrows = (len(filenames) / 3) + 1
nsubcols = 3
elif options.subplots:
nsubrows, nsubcols = [int(x) for x in options.subplots.split(",")]
else:
nsubrows, nsubcols = 1, 1
nsubplots = nsubrows * nsubcols
# Setting up color maps
if options.palette:
if options.palette == "gray":
_gray_data = {
'red': ((0., 1, 1), (1., 0, 0)),
'green': ((0., 1, 1), (1., 0, 0)),
'blue': ((0., 1, 1), (1., 0, 0))
}
LUTSIZE = pylab.rcParams['image.lut']
colors_gray = matplotlib.colors.LinearSegmentedColormap(
'gray', _gray_data, LUTSIZE)
plot_id = 0
for filename in filenames:
plot_id += 1
pylab.subplot(nsubrows, nsubcols, plot_id)
if filename == "-":
infile = sys.stdin
else:
infile = IOTools.open_file(filename, "r")
matrix, row_headers, col_headers = MatlabTools.readMatrix(
infile,
numeric_type=numpy.float32,
take=options.columns,
headers=options.headers,
missing=options.missing)
if min(matrix.flat) == max(matrix.flat):
options.stderr.write("matrix is uniform - no plotting done.\n")
sys.exit(0)
if options.normalize:
v = max(matrix.flat)
matrix = matrix / v
if options.zrange:
options.zrange = GetRange(matrix, options.zrange)
nrows, ncols = matrix.shape
if options.palette:
if options.palette == "gray":
color_scheme = colors_gray
else:
if options.reverse_palette:
color_scheme = eval("pylab.cm.%s_r" % options.palette)
else:
color_scheme = eval("pylab.cm.%s" % options.palette)
else:
color_scheme = None
if options.zrange:
vmin, vmax = options.zrange
matrix[matrix < vmin] = vmin
matrix[matrix > vmax] = vmax
else:
vmin, vmax = None, None
if options.subplots:
if nsubcols > 1:
increment_x = int(float(nrows + 1) / nsubcols)
increment_y = nrows
x = 0
y = 0
for n in range(nsubplots):
pylab.subplot(nsubrows, nsubcols, plot_id)
plot_id += 1
print(n, "rows=", nsubrows, "cols=", nsubcols, y,
y + increment_y, x, x + increment_x)
print(matrix[y:y + increment_y, x:x + increment_x].shape)
print(matrix.shape)
plotMatrix(matrix[y:y + increment_y, x:x + increment_x],
color_scheme, row_headers[y:y + increment_y],
col_headers[x:x + increment_x], 0, 100, options)
x += increment_x
elif nsubrows > 1:
increment_x = int(float(ncols + 1) / nsubrows)
x = 0
for n in range(nsubplots):
pylab.subplot(nsubrows, nsubcols, plot_id)
plot_id += 1
plotMatrix(matrix[0:nrows,
x:x + increment_x], color_scheme,
row_headers, col_headers[x:x + increment_x],
vmin, vmax, options)
x += increment_x
else:
plotMatrix(matrix, color_scheme, row_headers, col_headers, vmin,
vmax, options)
if options.xrange:
pylab.xlim(options.xrange)
if options.yrange:
pylab.ylim(options.yrange)
if options.labels:
xlabel, ylabel = options.labels.split(",")
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
if not options.subplots:
pylab.colorbar(format=options.bar_format)
if options.title is None or options.title != "":
pylab.title(filename)
if options.hardcopy:
pylab.savefig(os.path.expanduser(options.hardcopy))
else:
pylab.show()
E.stop()
# coding=utf-8 from matplotlib.font_manager import FontProperties import pylab as pl import numpy as np chinese_font = FontProperties(fname='/usr/share/fonts/truetype/wqy/wqy-microhei.ttc') sampling_rate = 8000 fft_size = 512 t = np.arange(0, 1.0, 1.0/sampling_rate) x = np.sin(2*np.pi*156.25*t) + 2*np.sin(2*np.pi*234.375*t) xs = x[:fft_size] xf = np.fft.rfft(xs)/fft_size freqs = np.linspace(0, sampling_rate/2, fft_size/2+1) xfp = 20*np.log10(np.clip(np.abs(xf), 1e-20, 1e100)) pl.figure(figsize=(8,4)) pl.subplot(211) pl.plot(t[:fft_size], xs) pl.xlabel(u"时间(秒)",fontproperties=chinese_font) pl.title(u"156.25Hz和234.375Hz的波形和频谱", fontproperties=chinese_font) pl.subplot(212) pl.plot(freqs, xfp) pl.xlabel(u"频率(Hz)",fontproperties=chinese_font) pl.subplots_adjust(hspace=0.4) pl.show()
plt.title(' Расстояние от центра Земли от времени', size=15)
plot(list(m1[:, 1] / 1000), list(m1[:, 0]), "-*k", markersize=0.1)
plt.ylabel('Расстояние, км ')
plt.xlabel('Время, 10^3 c')
plt.grid()
show()
plt.title(' Cкорость от времени', size=15)
plot(list(m2[:, 1] / 1000), list(m2[:, 0]), "-*k", markersize=0.1)
plt.ylabel('Скорость, км/с ')
plt.xlabel('Время, 10^3 с')
plt.grid()
show()
i = 0
while i < 460000:
pylab.subplot(131)
plt.scatter(m[i][0], m[i][1], color='black')
# y(x)
pylab.subplot(132)
plt.scatter(m2[i][1] / 1000, m2[i][0], color='black')
# r(t)
pylab.subplot(133)
plt.scatter(m1[i][1] / 1000, m1[i][0], color='black')
# v(t)
i += 1000
plt.pause(0.001)
plt.pause(10)
output.close
output2.close
output3.close
splits=splits,
num_splits_to_process=num_splits_to_process,
num_iter=num_iter,
template=new_templ,
shifts_opencv=shifts_opencv,
save_movie=save_movie)
new_templ = total_template_wls
if len(num_splits_to_process_list) > 1:
num_splits_to_process_list = [None]
total_shifts_els.append([x_shifts_els, y_shifts_els])
templates_all_els.append(total_template_wls)
#%%
pl.subplot(2, 1, 1)
pl.plot(np.concatenate([shfts[0] for shfts in total_shifts_els], 0))
pl.subplot(2, 1, 2)
pl.plot(np.concatenate([shfts[1] for shfts in total_shifts_els], 0))
#%%
border_to_0 = np.ceil(np.max(np.array(total_shifts_els))).astype(np.int)
#%%
fnames_map = [os.path.abspath(flfl) for flfl in glob.glob('*.mmap')]
fnames_map.sort()
print(fnames_map)
#%%
# add_to_movie=np.nanmin(templates_rig)+1# the movie must be positive!!!
downsample_factor = 1 # use .2 or .1 if file is large and you want a quick answer
idx_xy = None
base_name = 'Yr'
pos = util.get_realdata(True)
neg = util.get_realdata(False)
traindatList[i] = concatenate((pos, neg), axis=1)
trainfeatList[i] = util.get_realfeatures(pos, neg)
trainlabsList[i] = util.get_labels(True)
trainlabList[i] = util.get_labels()
kernelList[i] = GaussianKernel(trainfeatList[i], trainfeatList[i], width)
svmList[i] = LibSVM(10, kernelList[i], trainlabList[i])
for i in range(num_svms):
print "Training svm nr. %d" % (i)
currentSVM = svmList[i]
currentSVM.train()
print currentSVM.get_num_support_vectors()
print "Done."
x, y, z = util.compute_output_plot_isolines(currentSVM, kernelList[i],
trainfeatList[i])
subplot(num_svms / 2, 2, i + 1)
pcolor(x, y, z, shading='interp')
contour(x, y, z, linewidths=1, colors='black', hold=True)
scatter(traindatList[i][0, :],
traindatList[i][1, :],
s=20,
marker='o',
c=trainlabsList[i],
hold=True)
axis('tight')
connect('key_press_event', util.quit)
show()
pylab.plot(range(training_epochs), d_da3)
pylab.xlabel('iterations')
pylab.ylabel('cross-entropy')
pylab.title('Cost Entropy of Denoising Auto-encoder 3')
pylab.savefig(method + '_figure_cross_entropyda3.png')
pylab.show()
H3_new, Z_2 = test_da3(H2_new)
pylab.figure()
# Plots of first 100 weights in encoding layer 1
w1 = W1.get_value()
pylab.figure()
pylab.gray()
for i in range(100):
pylab.subplot(10, 10, i + 1)
pylab.axis('off')
pylab.imshow(w1[:, i].reshape(28, 28))
pylab.savefig(method + '_figure_w1.png')
# Plots of first 100 weights in encoding layer 2
w2 = W2.get_value()
pylab.figure()
pylab.gray()
for i in range(100):
pylab.subplot(10, 10, i + 1)
pylab.axis('off')
pylab.imshow(w2[:, i].reshape(30, 30))
pylab.savefig(method + '_figure_w2.png')
# Plots of first 100 weights in encoding layer 3
#!/usr/bin/env python
from tabulate_like import *
import pylab, cPickle, scipy
print "starting"
G = cPickle.load(open('grids/combined.pickle'))
if False:
for i, gf in enumerate(G.grid):
pylab.figure()
pylab.subplot(1, 2, 1)
pylab.imshow(gf[0], extent=(-1, 1, -1, 1))
pylab.colorbar()
pylab.subplot(1, 2, 2)
pylab.imshow(gf[0] - G.grid[0][0], extent=(-1, 1, -1, 1))
pylab.colorbar()
pylab.savefig('fig%i.pdf' % (i))
diffB = (G.grid[3][0] - G.grid[0][0])
#d2=(G.grid[3][0]+G.grid[4][0]-2*G.grid[0][0])/0.02
diffA = (G.grid[2][0] - G.grid[0][0])
s = 0.005
d1 = (8 * diffA - diffB) / (6 * s)
d3 = (diffB - 2 * diffA) / (6 * s**3)
pylab.figure()
pylab.subplot(2, 2, 1)
pylab.imshow(d1, extent=(-1, 1, -1, 1))
pylab.colorbar()
pylab.subplot(2, 2, 2)
r, g, b
]) # Reconstruction image format RGB ou np.concatenate((b,g,r),axis=1)
imgRGB = cv2.cvtColor(
img_C, cv2.COLOR_BGR2RGB
) # Passage BGR --> RGB via cv2.cvtColor (non utilisé par la suite)
# 2.1.1 Affichage image via opencv --> affichage format BGR
cv2.namedWindow("mon image BGR",
cv2.WINDOW_NORMAL) # Pour dimensionner la fenetre d'affichage
cv2.imshow("mon image BGR", img_C)
cv2.namedWindow("mon image RGB", cv2.WINDOW_NORMAL)
cv2.imshow("mon image RGB", img_C2)
# Affichage image via plt --> affichage format RGB
plt.figure()
plt.subplot(121)
plt.imshow(img_C)
plt.xticks([]), plt.yticks([])
plt.title(" Mon image BGR")
plt.subplot(122)
plt.imshow(img_C2)
plt.xticks([]), plt.yticks([])
plt.title(" Mon image RGB")
plt.show()
# 2.1.2 Affichage des trois canaux séparéments
plt.figure()
plt.subplot(131)
plt.imshow(b, cmap='gray')
plt.xticks([]), plt.yticks([])
plt.title(" Mon image B")
