def create_lifetime_chart(self, classname, filename=''):
"""
Create chart that depicts the lifetime of the instance registered with
`classname`. The output is written to `filename`.
"""
try:
from pylab import figure, title, xlabel, ylabel, plot, savefig
except ImportError:
return HtmlStats.nopylab_msg % (classname + " lifetime")
cnt = []
for tobj in self.index[classname]:
cnt.append([tobj.birth, 1])
if tobj.death:
cnt.append([tobj.death, -1])
cnt.sort()
for i in range(1, len(cnt)):
cnt[i][1] += cnt[i - 1][1]
x = [t for [t, c] in cnt]
y = [c for [t, c] in cnt]
figure()
xlabel("Execution time [s]")
ylabel("Instance #")
title("%s instances" % classname)
plot(x, y, 'o')
savefig(filename)
return self.chart_tag % (os.path.basename(filename))
def check_vpd_ks2_astrometry():
"""
Check the VPD and quiver plots for our KS2-extracted, re-transformed astrometry.
"""
catFile = workDir + '20.KS2_PMA/wd1_catalog.fits'
tab = atpy.Table(catFile)
good = (tab.xe_160 < 0.05) & (tab.ye_160 < 0.05) & \
(tab.xe_814 < 0.05) & (tab.ye_814 < 0.05) & \
(tab.me_814 < 0.05) & (tab.me_160 < 0.05)
tab2 = tab.where(good)
dx = (tab2.x_160 - tab2.x_814) * ast.scale['WFC'] * 1e3
dy = (tab2.y_160 - tab2.y_814) * ast.scale['WFC'] * 1e3
py.clf()
q = py.quiver(tab2.x_814, tab2.y_814, dx, dy, scale=5e2)
py.quiverkey(q, 0.95, 0.85, 5, '5 mas', color='red', labelcolor='red')
py.savefig(workDir + '20.KS2_PMA/vec_diffs_ks2_all.png')
py.clf()
py.plot(dy, dx, 'k.', ms=2)
lim = 30
py.axis([-lim, lim, -lim, lim])
py.xlabel('Y Proper Motion (mas)')
py.ylabel('X Proper Motion (mas)')
py.savefig(workDir + '20.KS2_PMA/vpd_ks2_all.png')
idx = np.where((np.abs(dx) < 10) & (np.abs(dy) < 10))[0]
print('Cluster Members (within dx < 10 mas and dy < 10 mas)')
print((' dx = {dx:6.2f} +/- {dxe:6.2f} mas'.format(dx=dx[idx].mean(),
dxe=dx[idx].std())))
print((' dy = {dy:6.2f} +/- {dye:6.2f} mas'.format(dy=dy[idx].mean(),
dye=dy[idx].std())))
def plot_matches(self, name, show_below = True, match_maximum = None):
""" 対応点を線で結んで画像を表示する
入力： im1,im2（配列形式の画像）、locs1,locs2（特徴点座標）
machescores（match()の出力）、
show_below（対応の下に画像を表示するならTrue）"""
im1 = self._image_1.get_array_image()
im2 = self._image_2.get_array_image()
self.appendimages()
im3 = self._append_image
if self._match_score is None:
self.match()
locs1 = self._image_1.get_shift_location()
locs2 = self._image_2.get_shift_location()
if show_below:
im3 = numpy.vstack((im3,im3))
pylab.figure(dpi=160)
pylab.gray()
pylab.imshow(im3, aspect = 'auto')
cols1 = im1.shape[1]
match_num = 0
for i,m in enumerate(self._match_score):
if m > 0 :
pylab.plot([locs1[i][0],locs2[m][0]+cols1], [locs1[i][1],locs2[m][1]], 'c')
match_num = match_num + 1
if match_maximum is not None and match_num >= match_maximum:
break
pylab.axis('off')
pylab.savefig(name, dpi=160)
def create_pie_chart(self, snapshot, filename=''):
"""
Create a pie chart that depicts the distribution of the allocated
memory for a given `snapshot`. The chart is saved to `filename`.
"""
try:
from pylab import figure, title, pie, axes, savefig
from pylab import sum as pylab_sum
except ImportError:
return self.nopylab_msg % ("pie_chart")
# Don't bother illustrating a pie without pieces.
if not snapshot.tracked_total:
return ''
classlist = []
sizelist = []
for k, v in list(snapshot.classes.items()):
if v['pct'] > 3.0:
classlist.append(k)
sizelist.append(v['sum'])
sizelist.insert(0, snapshot.asizeof_total - pylab_sum(sizelist))
classlist.insert(0, 'Other')
#sizelist = [x*0.01 for x in sizelist]
title("Snapshot (%s) Memory Distribution" % (snapshot.desc))
figure(figsize=(8, 8))
axes([0.1, 0.1, 0.8, 0.8])
pie(sizelist, labels=classlist)
savefig(filename, dpi=50)
return self.chart_tag % (self.relative_path(filename))
def compareAnimals(animals, precision):
"""Assumes animals is a list of animals, precision an int >= 0
Builds a table of Euclidean distance between each animal"""
#Get labels for columns and rows
columnLabels = []
for a in animals:
columnLabels.append(a.getName())
rowLabels = columnLabels[:]
tableVals = []
#Get distances between pairs of animals
#For each row
for a1 in animals:
row = []
#For each column
for a2 in animals:
if a1 == a2:
row.append('--')
else:
distance = a1.distance(a2)
row.append(str(round(distance, precision)))
tableVals.append(row)
#Produce table
table = pylab.table(rowLabels = rowLabels,
colLabels = columnLabels,
cellText = tableVals,
cellLoc = 'center',
loc = 'center',
colWidths = [0.2]*len(animals))
table.scale(1, 2.5)
pylab.axis('off') #Don't display x and y-axes
pylab.savefig('distances')
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 geweke_plot(data, name, format='png', suffix='-diagnostic', path='./', fontmap = None,
verbose=1):
# Generate Geweke (1992) diagnostic plots
if fontmap is None: fontmap = {1:10, 2:8, 3:6, 4:5, 5:4}
# Generate new scatter plot
figure()
x, y = transpose(data)
scatter(x.tolist(), y.tolist())
# Plot options
xlabel('First iteration', fontsize='x-small')
ylabel('Z-score for %s' % name, fontsize='x-small')
# Plot lines at +/- 2 sd from zero
pyplot((nmin(x), nmax(x)), (2, 2), '--')
pyplot((nmin(x), nmax(x)), (-2, -2), '--')
# Set plot bound
ylim(min(-2.5, nmin(y)), max(2.5, nmax(y)))
xlim(0, nmax(x))
# Save to file
if not os.path.exists(path):
os.mkdir(path)
if not path.endswith('/'):
path += '/'
savefig("%s%s%s.%s" % (path, name, suffix, format))
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 plotKerasExperimentcifar10():
index = 5
for experiment_number in range(1,index+1):
outputPath_part_final = os.path.realpath( "/home/jie/docker_folder/random_keras/output_cifar10_mlp/errorFile/hyperopt_experiment_withoutparam_accuracy" + str(experiment_number) + ".txt")
output_plot = os.path.realpath(
"/home/jie/docker_folder/random_keras/output_cifar10_mlp/errorFile/plotErrorCurve" + str(experiment_number) + ".pdf")
df = pd.read_csv(outputPath_part_final,delimiter='\t',header=None)
df.drop(df.columns[[600]], axis=1, inplace=True)
i=1
epochnum = []
while i<=250:
epochnum.append(i)
i = i+1
i=0
while i<10:
df_1=df[df.columns[0:250]].ix[i]
np.reshape(df_1, (1,250))
plt.plot(epochnum,df_1)
i = i+1
# plt.show()
# plt.show()
plt.savefig(output_plot)
plt.close()
def aa(current_data):
title_hours(current_data)
if 0:
from pylab import savefig
fname = 'pacific%s.png' % str(current_data.frameno).zfill(4)
savefig(fname)
print 'Saved ',fname
def simplegrid():
nzones = 7
gr = gpu.grid(nzones, xmin=0, xmax=1)
gpu.drawGrid(gr, edgeTicks=0)
# label a few cell-centers
gpu.labelCenter(gr, nzones/2, r"$i$")
gpu.labelCenter(gr, nzones/2-1, r"$i-1$")
gpu.labelCenter(gr, nzones/2+1, r"$i+1$")
# label a few edges
gpu.labelEdge(gr, nzones/2, r"$i-1/2$")
gpu.labelEdge(gr, nzones/2+1, r"$i+1/2$")
# draw an average quantity
gpu.drawCellAvg(gr, nzones/2, 0.4, color="r")
gpu.labelCellAvg(gr, nzones/2, 0.4, r"$\,\langle a \rangle_i$", color="r")
pylab.axis([gr.xmin-1.5*gr.dx,gr.xmax+1.5*gr.dx, -0.25, 1.5])
pylab.axis("off")
pylab.subplots_adjust(left=0.05,right=0.95,bottom=0.05,top=0.95)
f = pylab.gcf()
f.set_size_inches(10.0,2.5)
pylab.savefig("simplegrid2.png")
pylab.savefig("simplegrid2.eps")
def makeContourPlot(scores, average, HEIGHT, WIDTH, outputId, maskId, plt_title, outputdir, barcodeId=-1, vmaxVal=100):
pylab.bone()
#majorFormatter = FormatStrFormatter('%.f %%')
#ax = pylab.gca()
#ax.xaxis.set_major_formatter(majorFormatter)
pylab.figure()
ax = pylab.gca()
ax.set_xlabel(str(WIDTH) + ' wells')
ax.set_ylabel(str(HEIGHT) + ' wells')
ax.autoscale_view()
pylab.jet()
pylab.imshow(scores,vmin=0, vmax=vmaxVal, origin='lower')
pylab.vmin = 0.0
pylab.vmax = 100.0
ticksVal = getTicksForMaxVal(vmaxVal)
pylab.colorbar(format='%.0f %%',ticks=ticksVal)
print "'%s'" % average
if(barcodeId!=-1):
if(barcodeId==0): maskId = "No Barcode Match,"
else: maskId = "Barcode Id %d," % barcodeId
if plt_title != '': maskId = '%s\n%s' % (plt_title,maskId)
print "Checkpoint A"
pylab.title('%s Loading Density (Avg ~ %0.f%%)' % (maskId, average))
pylab.axis('scaled')
print "Checkpoint B"
pngFn = outputdir+'/'+outputId+'_density_contour.png'
print "Try save to", pngFn;
pylab.savefig(pngFn, bbox_inches='tight')
print "Plot saved to", pngFn;
def plotEventFlop(library, num, eventNames, sizes, times, events, filename = None):
from pylab import legend, plot, savefig, semilogy, show, title, xlabel, ylabel
import numpy as np
arches = sizes.keys()
bs = events[arches[0]].keys()[0]
data = []
names = []
for event, color in zip(eventNames, ['b', 'g', 'r', 'y']):
for arch, style in zip(arches, ['-', ':']):
if event in events[arch][bs]:
names.append(arch+'-'+str(bs)+' '+event)
data.append(sizes[arch][bs])
data.append(1e-3*np.array(events[arch][bs][event])[:,1])
data.append(color+style)
else:
print 'Could not find %s in %s-%d events' % (event, arch, bs)
semilogy(*data)
title('Performance on '+library+' Example '+str(num))
xlabel('Number of Dof')
ylabel('Computation Rate (GF/s)')
legend(names, 'upper left', shadow = True)
if filename is None:
show()
else:
savefig(filename)
return
def create_figure():
psd = test_correlog()
f = linspace(-0.5, 0.5, len(psd))
psd = cshift(psd, len(psd)/2)
plot(f, 10*log10(psd/max(psd)))
savefig('psd_corr.png')
def plot_sphere_x( s, fname ):
""" put plot of ionization fractions from sphere `s` into fname """
plt.figure()
s.Edges.units = 'kpc'
s.r_c.units = 'kpc'
xx = s.r_c
L = s.Edges[-1]
plt.plot( xx, np.log10( s.xHe1 ),
color='green', ls='-', label = r'$x_{\rm HeI}$' )
plt.plot( xx, np.log10( s.xHe2 ),
color='green', ls='--', label = r'$x_{\rm HeII}$' )
plt.plot( xx, np.log10( s.xHe3 ),
color='green', ls=':', label = r'$x_{\rm HeIII}$' )
plt.plot( xx, np.log10( s.xH1 ),
color='red', ls='-', label = r'$x_{\rm HI}$' )
plt.plot( xx, np.log10( s.xH2 ),
color='red', ls='--', label = r'$x_{\rm HII}$' )
plt.xlim( -L/20, L+L/20 )
plt.xlabel( 'r_c [kpc]' )
plt.ylim( -4.5, 0.2 )
plt.ylabel( 'log 10 ( x )' )
plt.grid()
plt.legend(loc='best', ncol=2)
plt.tight_layout()
plt.savefig( 'doc/img/x_' + fname )
def plot_heatingrate(data_dict, filename, do_show=True):
pl.figure(201)
color_list = ['b','r','g','k','y','r','g','b','k','y','r',]
fmtlist = ['s','d','o','s','d','o','s','d','o','s','d','o']
result_dict = {}
for key in data_dict.keys():
x = data_dict[key][0]
y = data_dict[key][1][:,0]
y_err = data_dict[key][1][:,1]
p0 = np.polyfit(x,y,1)
fit = LinFit(np.array([x,y,y_err]).transpose(), show_graph=False)
p1 = [0,0]
p1[0] = fit.param_dict[0]['Slope'][0]
p1[1] = fit.param_dict[0]['Offset'][0]
print fit
x0 = np.linspace(0,max(x))
cstr = color_list.pop(0)
fstr = fmtlist.pop(0)
lstr = key + " heating: {0:.2f} ph/ms".format((p1[0]*1e3))
pl.errorbar(x/1e3,y,y_err,fmt=fstr + cstr,label=lstr)
pl.plot(x0/1e3,np.polyval(p0,x0),cstr)
pl.plot(x0/1e3,np.polyval(p1,x0),cstr)
result_dict[key] = 1e3*np.array(fit.param_dict[0]['Slope'])
pl.xlabel('Heating time (ms)')
pl.ylabel('nbar')
if do_show:
pl.legend()
pl.show()
if filename != None:
pl.savefig(filename)
return result_dict
def Doplots_monthly(mypathforResults,PlottingDF,variable_to_fill, Site_ID,units,item):
ANN_label=str(item+"_NN") #Do Monthly Plots
print "Doing MOnthly plot"
#t = arange(1, 54, 1)
NN_label='Fc'
Plottemp = PlottingDF[[NN_label,item]][PlottingDF['day_night']!=1]
#Plottemp = PlottingDF[[NN_label,item]].dropna(how='any')
figure(1)
pl.title('Nightime ANN v Tower by year-month for '+item+' at '+Site_ID)
try:
xdata1a=Plottemp[item].groupby([lambda x: x.year,lambda x: x.month]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[NN_label].groupby([lambda x: x.year,lambda x: x.month]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.xlabel('Year - Month')
pl.legend()
pl.savefig(mypathforResults+'/ANN and Tower plots by year and month for variable '+item+' at '+Site_ID)
#pl.show()
pl.close()
time.sleep(1)
def swi_histogram(self,dir,name,measure,dpi=80,width=8,height=6,b_left='0.1',b_bot='0.1',b_top='0.1',b_right='0.1',bins='20'):
s=ccm.stats.Stats('%s/%s'%(dir,name))
data=s.get_raw(measure)
bins=int(bins)
pylab.figure(figsize=(float(width),float(height)))
try: b_left=float(b_left)
except: b_left=0.1
try: b_right=float(b_right)
except: b_right=0.1
try: b_top=float(b_top)
except: b_top=0.1
try: b_bot=float(b_bot)
except: b_bot=0.1
pylab.axes((b_left,b_bot,1.0-b_left-b_right,1.0-b_top-b_bot))
pylab.hist(data,bins=bins)
img=StringIO.StringIO()
if type(dpi) is list: dpi=dpi[-1]
pylab.savefig(img,dpi=int(dpi),format='png')
return 'image/png',img.getvalue()
def testTelescope(self):
import matplotlib
matplotlib.use('AGG')
import matplotlib.mlab as ml
import pylab as pl
import time
w0 = 8.0
k = 2*np.pi/3.0
gb = GaussianBeam(w0, k)
lens = ThinLens(150, 150)
gb2 = lens*gb
self.assertAlmostEqual(gb2._z0, gb._z0 + 2*150.0)
lens2 = ThinLens(300, 600)
gb3 = lens2*gb2
self.assertAlmostEqual(gb3._z0, gb2._z0 + 2*300.0)
self.assertAlmostEqual(gb._w0, gb3._w0/2.0)
z = np.arange(0, 150)
z2 = np.arange(150, 600)
z3 = np.arange(600, 900)
pl.plot(z, gb.w(z, k), z2, gb2.w(z2, k), z3, gb3.w(z3, k))
pl.grid()
pl.xlabel('z')
pl.ylabel('w')
pl.savefig('testTelescope1.png')
time.sleep(0.1)
pl.close('all')
def plotslice(pos,filename='',boxsize=100.):
ng = pos.shape[0]
M.clf()
M.scatter(pos[ng/4,:,:,1].flatten(),pos[ng/4,:,:,2].flatten(),s=1.,lw=0.)
M.axis('tight')
if filename != '':
M.savefig(filename)
def window_fn_matrix(Q,N,num_remov=None,save_tag=None,lms=None):
Q = n.matrix(Q); N = n.matrix(N)
Ninv = uf.pseudo_inverse(N,num_remov=None) # XXX want to remove dynamically
#print Ninv
info = n.dot(Q.H,n.dot(Ninv,Q))
M = uf.pseudo_inverse(info,num_remov=num_remov)
W = n.dot(M,info)
if save_tag!=None:
foo = W[0,:]
foo = n.real(n.array(foo))
foo.shape = (foo.shape[1]),
print foo.shape
p.scatter(lms[:,0],foo,c=lms[:,1],cmap=mpl.cm.PiYG,s=50)
p.xlabel('l (color is m)')
p.ylabel('W_0,lm')
p.title('First Row of Window Function Matrix')
p.colorbar()
p.savefig('{0}/{1}_W.pdf'.format(fig_loc,save_tag))
p.clf()
print 'W ',W.shape
p.imshow(n.real(W))
p.title('Window Function Matrix')
p.colorbar()
p.savefig('{0}/{1}_W_im.pdf'.format(fig_loc,save_tag))
p.clf()
return W
def exercise_4_1():
exp_t = np.load('exp_t.npy')
exp_somav = np.load('exp_v.npy')
exp_somav -= exp_somav[0]
exp_somav /= abs(exp_somav.max())
soma_rall, dend_rall = return_ball_and_stick_soma()
stim = insert_current_clamp(soma_rall(0.5))
t, v_rall = run_simulation(soma_rall(0.5))
v_rall -= v_rall[0]
v_rall /= abs(v_rall.max())
soma_ball = return_ball_soma()
stim_ball = insert_current_clamp(soma_ball(0.5))
t_ball, v_ball = run_simulation(soma_ball(0.5))
v_ball -= v_ball[0]
v_ball /= abs(v_ball.max())
fig = plt.figure()
ax1 = fig.add_subplot(111, xlabel="Time [ms]", ylabel="Voltage [mV]")
ax1.plot(t, exp_somav, 'gray', label='"Experiment"')
ax1.plot(t, v_rall, 'g', label='Rall')
ax1.plot(t_ball, v_ball, 'b', label='ball')
plt.legend(loc=4, frameon=False)
plt.savefig('exercise_4_1_.png')
plt.show()
def manhattonPlot(phenotype_ID, pvalues_lm, ouFprefix, pos, chromBounds):
for ip, p_ID in enumerate(phenotype_ID):
pl.figure(figsize=[12,4])
plot_manhattan(posCum=pos['pos_cum'],pv=pvalues_lm[p_ID].values,chromBounds=chromBounds,thr_plotting=0.05)
pl.title(p_ID)
pl.savefig(ouFprefix + '.' + p_ID + '.pdf')
pl.close('all')
def bar_plot_raw(inF):
ouF = inF + '.pdf'
X = []
Y = []
inFile = open(inF)
for line in inFile:
line = line.strip()
fields = line.split('\t')
X.append(int(fields[0]))
#Y.append(math.log(int(fields[1])+1,2))
Y.append(int(fields[1]))
fig = pl.figure()
N = len(X)
ax = fig.add_subplot(111)
ax.set_xlim(0,N + 1)
ax.set_xticks(range(0,N+2))
ax.set_xticklabels([0,1] + ['']*(N-1) + [max(X)])
ax.bar(range(1,N+1), Y, align='center')
ax.set_xlabel('Start position in the protein')
ax.set_ylabel('Number of peptides')
pl.setp(ax.get_xticklines(),visible=False)
pl.setp(ax.get_xticklabels(),fontsize=6)
ax.get_children()[2].set_color('g')
ax.get_children()[3].set_color('r')
pl.savefig(ouF)
inFile.close()
def SingleTraitLM(inF1, inF2, ouF):
geno_reader = gr.genotype_reader_tables(inF1)
pheno_reader = phr.pheno_reader_tables(inF2)
dataset = data.QTLData(geno_reader=geno_reader,pheno_reader=pheno_reader)
geno = dataset.getGenotypes()
position = dataset.getPos()
pos,chromBounds = data_util.estCumPos(position=position,offset=0)
ouFile = open(ouF, 'w')
P_max = len(dataset.phenotype_ID)
phenotype_ID = dataset.phenotype_ID[0:P_max]
for p_ID in phenotype_ID[0:]:
#phenotype_vals, sample_idx = dataset.getPhenotypes([pI], center=False)
phenotype_vals, sample_idx = dataset.getPhenotypes([p_ID])
phenotype_vals_ranks = preprocess.rankStandardizeNormal(phenotype_vals.values)
lm_ranks = qtl.test_lm(snps=geno[sample_idx],pheno=phenotype_vals_ranks)
pvalues_lm_ranks = pd.DataFrame(data=lm_ranks.pvalues.T,index=dataset.geno_ID,columns=[p_ID])
pvt = lm_ranks.pvalues.T
for i in xrange(pvt.shape[0]):
p = pvt[i,0]
if p <= SIG:
ouFile.write('\t'.join([position['chrom'][i], str(position['pos'][i]), str(p), p_ID]) + '\n')
ouFile.close()
manhattonPlot(['NMD'],pvalues_lm_ranks,inF2,pos, chromBounds)
pl.figure(figsize=[12,4])
qqplot(pvalues_lm_ranks['NMD'].values)
pl.savefig('pvalues-qqplot.pdf')
def makeimg(wav):
global callpath
global imgpath
fs, frames = wavfile.read(os.path.join(callpath, wav))
pylab.ion()
# generate specgram
pylab.figure(1)
# generate specgram
pylab.specgram(
frames,
NFFT=256,
Fs=22050,
detrend=pylab.detrend_none,
window=numpy.hamming(256),
noverlap=192,
cmap=pylab.get_cmap('Greys'))
x_width = len(frames)/fs
pylab.ylim([0,11025])
pylab.xlim([0,round(x_width,3)-0.006])
img_path = os.path.join(imgpath, wav.replace(".wav",".png"))
pylab.savefig(img_path)
return img_path
def density(ouF, bandwidth):
AX = []
df = pd.read_table('Mouse_Gene_Promoter_Cov_ProteinCoding-Norm', header=0)
Sample = df.columns[4:]
#Sample2 = Sample
Sample2 = [' '.join(x.split('_')[0:-1]) for x in df.columns[4:]]
fig = plt.figure()
ax = fig.add_axes([0.15,0.15,0.8,0.8])
for i in range(4,df.shape[1]):
AX.append(sns.kdeplot(np.log2(df.ix[:,i]), shade=True, color=LineColor(i-4), legend=True, label=GetLabel(i-4, Sample2), bw=bandwidth))
'''
patch1 = mpatches.Patch(color='r', label='Tspan8 negative MHCII low')
patch2 = mpatches.Patch(color='b', label='Tspan8 negative MHCII high')
patch3 = mpatches.Patch(color='g', label='Tspan8 positive MHCII low')
patch4 = mpatches.Patch(color='m', label='Tspan8 positive MHCII high')
plt.legend(handles=[patch1, patch2, patch3, patch4])
'''
ax.set_xlabel('Normalized number of reads (log2), bandwidth=%s'%bandwidth)
ax.set_ylabel('Density of gene numbers')
ax.set_xlim(0, ax.get_xlim()[1])
plt.savefig(ouF +'-bw_'+ str(bandwidth) + '.pdf')
def draw(inF):
G = nx.Graph()
inFile = open(inF)
S = set()
for line in inFile:
line = line.strip()
fields = line.split('\t')
for item in fields:
S.add(item)
inFile.close()
L = list(S)
G.add_nodes_from(L)
LC = []
for x in L:
if x == 'EGR1' or x == 'RBM20':
LC.append('r')
else:
LC.append('w')
inFile = open(inF)
for line in inFile:
line = line.strip()
fields = line.split('\t')
for i in range(len(fields)-1):
G.add_edge(fields[i], fields[i+1])
inFile.close()
nx.draw_networkx(G,pos=nx.spring_layout(G), node_size=800, font_size=6, node_color=LC)
limits=plt.axis('off')
plt.savefig(inF + '.pdf')
def __call__(self, n):
if len(self.f.shape) == 3:
# f = f[x,v,t], 2 dim in phase space
ft = self.f[n,:,:]
pylab.pcolormesh(self.X, self.V, ft.T, cmap = 'jet')
pylab.colorbar()
pylab.clim(0,0.38) # for Landau test case
pylab.grid()
pylab.axis([self.xmin, self.xmax, self.ymin, self.ymax])
pylab.xlabel('$x$', fontsize = 18)
pylab.ylabel('$v$', fontsize = 18)
pylab.title('$N_x$ = %d, $N_v$ = %d, $t$ = %2.1f' % (self.x.N, self.v.N, self.it*self.t.width))
pylab.savefig(self.path + self.filename)
pylab.clf()
return None
if len(self.f.shape) == 2:
# f = f[x], 1 dim in phase space
ft = self.f[n,:]
pylab.plot(self.x.gridvalues,ft,'ob')
pylab.grid()
pylab.axis([self.xmin, self.xmax, self.ymin, self.ymax])
pylab.xlabel('$x$', fontsize = 18)
pylab.ylabel('$f(x)$', fontsize = 18)
pylab.savefig(self.path + self.filename)
return None
def img_create(self):
'''
Create the output jpg of the file.
:return:
'''
pylab.imshow(self._dcm.pixel_array, cmap=pylab.cm.bone)
pylab.savefig(self._str_outputImageFile)
cnt = cnt + 1
pathname = scenrio + out_name + '/%03d.jpg' % cnt
cv2.imwrite(pathname, image3)
# cv2.imshow('result',image3)
# cv2.waitKey(2)
tmp_IOU = 0
for i in range(len(IOU_set)):
tmp_IOU = tmp_IOU + IOU_set[i]
if len(IOU_set) != 1:
average_iou = tmp_IOU / len(IOU_set)
# ss2=0
# for i in range(len(IOU_set)-1):
# ss2 = ss2+(IOU_set[i]-average_iou)*(IOU_set[i]-average_iou)
# ss2 = math.sqrt(ss2 / (len(IOU_set) - 1))
print(IOU_set)
pl.plot(np.arange(1, len(IOU_set) + 1, 1), IOU_set)
pl.xlabel("Image number")
pl.ylabel("IOU value")
pl.title("ATR images IOU diagram")
pl.savefig(scenrio + out_name + '/iou.jpg')
pl.close()
# pl.show()
# IOU_set.append('avg:')
IOU_set.append(average_iou)
# IOU_set.append('ss2:')
# IOU_set.append(ss2)
np.savetxt(scenrio + out_name + '/iou.txt', IOU_set)
print(average_iou)
gen_model = generator()
dis_model = discriminator()
serializers.load_npz('generator.model', gen_model)
serializers.load_npz('discriminator.model', dis_model)
gen_model.to_gpu()
dis_model.to_gpu()
gen_opt = set_optimizer(gen_model, 1e-4, 0.5)
dis_opt = set_optimizer(dis_model, 1e-4, 0.5)
z1 = xp.random.uniform(-1, 1, (1, 100), dtype=np.float32)
z2 = xp.random.uniform(-1, 1, (1, 100), dtype=np.float32)
inter = (z2 - z1) / 20.0
for i in range(21):
pylab.rcParams['figure.figsize'] = (1.0, 1.0)
pylab.clf()
vec = z1 + i * inter
z = Variable(vec)
with chainer.using_config('train', False):
x = gen_model(z)
x = x.data.get()
tmp = ((np.vectorize(clip_img)(x[0, :, :, :]) + 1) / 2).transpose(1, 2, 0)
pylab.imshow(tmp)
pylab.axis('off')
pylab.savefig('%s/morphing_%d.png' % (image_vec_dir, i))
print(pred.cputime(3., 10., 50.))
# This one won't work
#pred(-999)
# Extract the Run 1 metadata and evaluate the predicted CPU times
run1meta = pd.read_csv(
os.path.join(os.environ['TWINKLES_DIR'], 'data',
'run1_metadata_v6.csv'),
usecols=['filter', 'moonalt', 'moonphase', 'cputime_fell'])
filter = np.array(run1meta['filter'])
moonalt = np.array(run1meta['moonalt'])
moonphase = np.array(run1meta['moonphase'])
actual = np.array(run1meta['cputime_fell'])
predicted = np.zeros(filter.size, dtype=float)
for i in range(filter.size):
predicted[i] = pred.cputime(filter[i], moonalt[i], moonphase[i])
plt.scatter(np.log10(actual), np.log10(predicted))
plt.plot([4, 6.5], [4, 6.5])
pylab.ylim([4, 6.5])
pylab.xlim([4, 6.5])
plt.xlabel('log10(Actual Fell CPU time, s)')
plt.ylabel('log10(Predicted Fell CPU time, s)')
plt.title('Run 1 CPU Times Predicted vs. Actual')
pylab.savefig('predicted_vs_actual.png', bbox_inches='tight')
plt.show()
def train( self, x, x_valid,
epochs, num_batches,
print_every = 1,
learning_rate = 3e-4,
beta1 = 0.9,
beta2 = 0.999,
seed = 31415,
stop_iter = 100,
save_path = None,
load_path = None,
draw_img = 1 ):
self.num_examples = x.shape[0]
self.num_batches = num_batches
assert self.num_examples % self.num_batches == 0, '#Examples % #Batches != 0'
self.batch_size = self.num_examples // self.num_batches
''' Session and Summary '''
if save_path is None:
self.save_path = 'checkpoints/model_VAE_{}-{}_{}.cpkt'.format(learning_rate,self.batch_size,time.time())
else:
self.save_path = save_path
np.random.seed(seed)
tf.set_random_seed(seed)
with self.G.as_default():
self.optimiser = tf.train.AdamOptimizer( learning_rate = learning_rate, beta1 = beta1, beta2 = beta2 )
self.train_op = self.optimiser.minimize( self.cost )
init = tf.initialize_all_variables()
self._test_vars = None
with self.session as sess:
sess.run(init)
if load_path == 'default': self.saver.restore( sess, self.save_path )
elif load_path is not None: self.saver.restore( sess, load_path )
training_cost = 0.
best_eval_log_lik = - np.inf
stop_counter = 0
for epoch in range(epochs):
''' Shuffle Data '''
np.random.shuffle( x )
''' Training '''
for x_batch in utils.feed_numpy( self.batch_size, x ):
training_result = sess.run( [self.train_op, self.cost],
feed_dict = { self.x: x_batch } )
training_cost = training_result[1]
''' Evaluation '''
stop_counter += 1
if epoch % print_every == 0:
test_vars = tf.get_collection(bookkeeper.GraphKeys.TEST_VARIABLES)
if test_vars:
if test_vars != self._test_vars:
self._test_vars = list(test_vars)
self._test_var_init_op = tf.initialize_variables(test_vars)
self._test_var_init_op.run()
eval_log_lik, x_recon_eval = \
sess.run( [self.eval_log_lik, self.x_recon_eval],
feed_dict = { self.x: x_valid } )
if eval_log_lik > best_eval_log_lik:
best_eval_log_lik = eval_log_lik
self.saver.save( sess, self.save_path )
stop_counter = 0
utils.print_metrics( epoch+1,
['Training', 'cost', training_cost],
['Validation', 'log-likelihood', eval_log_lik] )
if draw_img > 0 and epoch % draw_img == 0:
import matplotlib
matplotlib.use('Agg')
import pylab
import seaborn as sns
five_random = np.random.random_integers(x_valid.shape[0], size = 5)
x_sample = x_valid[five_random]
x_recon_sample = x_recon_eval[five_random]
sns.set_style('white')
f, axes = pylab.subplots(5, 2, figsize=(8,12))
for i,row in enumerate(axes):
row[0].imshow(x_sample[i].reshape(28, 28), vmin=0, vmax=1)
im = row[1].imshow(x_recon_sample[i].reshape(28, 28), vmin=0, vmax=1,
cmap=sns.light_palette((1.0, 0.4980, 0.0549), input="rgb", as_cmap=True))
pylab.setp([a.get_xticklabels() for a in row], visible=False)
pylab.setp([a.get_yticklabels() for a in row], visible=False)
f.subplots_adjust(left=0.0, right=0.9, bottom=0.0, top=1.0)
cbar_ax = f.add_axes([0.9, 0.1, 0.04, 0.8])
f.colorbar(im, cax=cbar_ax, use_gridspec=True)
pylab.tight_layout()
pylab.savefig('img/recon-'+str(epoch)+'.png', format='png')
pylab.clf()
pylab.close('all')
if stop_counter >= stop_iter:
print('Stopping VAE training')
print('No change in validation log-likelihood for {} iterations'.format(stop_iter))
print('Best validation log-likelihood: {}'.format(best_eval_log_lik))
print('Model saved in {}'.format(self.save_path))
break
sys.exit(1)
else:
labels = None
for fi in range(0, len(filenames)):
f = filenames[fi]
process_file(f)
for i in range(0, len(x)):
if first_only[i] and fi != 0:
x[i] = []
y[i] = []
if labels:
lab = labels[fi * len(fields):(fi + 1) * len(fields)]
else:
lab = fields[:]
if args.multi:
col = colors[:]
else:
col = colors[fi * len(fields):]
plotit(x, y, lab, colors=col)
for i in range(0, len(x)):
x[i] = []
y[i] = []
if args.output is None:
pylab.show()
pylab.draw()
raw_input('press enter to exit....')
else:
pylab.legend(loc=2, prop={'size': 8})
pylab.savefig(args.output, bbox_inches='tight', dpi=200)
# don't allow overwriting of these, just in case
try:
x_profiles
except NameError:
x_profiles = []
z_profiles = []
S_profiles = []
A_profiles = []
# plot init conds
if make_output_plots:
mg = fr.route_flow(grid=mg)
pylab.figure('long_profile_anim')
ylim([0, y_max])
prf.analyze_channel_network_and_plot(mg)
savefig('0profile_anim_init.png')
close('long_profile_anim')
(profile_IDs, dists_upstr) = prf.analyze_channel_network_and_plot(mg)
start_node = [profile_IDs[0]]
time_on = time()
#perform the loops:
for i in range(nt):
#print 'loop ', i
mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_per_step
mg = fr.route_flow()
#mg.calculate_gradient_across_cell_faces(mg.at_node['topographic__elevation'])
#neighbor_slopes = mg.calculate_gradient_along_node_links(mg.at_node['topographic__elevation'])
#mean_slope = np.mean(np.fabs(neighbor_slopes),axis=1)
#max_slope = np.max(np.fabs(neighbor_slopes),axis=1)
def feature_extraction():
"""
This method restores a TensorFlow checkpoint file (.ckpt) and rebuilds inference
model with restored parameters. From then on you can basically use that model in
any way you want, for instance, feature extraction, finetuning or as a submodule
of a larger architecture. However, this method should extract features from a
specified layer and store them in data files such as '.h5', '.npy'/'.npz'
depending on your preference. You will use those files later in the assignment.
Args:
[optional]
Returns:
None
"""
########################
# PUT YOUR CODE HERE #
########################
#model = convnet.ConvNet(n_classes=10)
#x = tf.placeholder(tf.float32, [None, 32, 32, 3])
#y = tf.placeholder(tf.float32, [None, 10])
#logits = model.inference(x)
#accuracy = model.accuracy(logits, y)
#init = tf.initialize_all_variables()
#saver = tf.train.Saver()
with tf.Session() as sess:
#saver.restore(sess, "checkpoints/convnet")
cifar10 = cifar10_utils.get_cifar10('cifar10/cifar-10-batches-py')
x_test, y_test = cifar10.test.images, cifar10.test.labels
#acc, fc2_out, fc1_out, flatten = sess.run([accuracy, model.fc2_out, model.fc1_out, model.flatten], feed_dict={x: x_test, y: y_test})
#print('Accuracy: ' + str(acc))
tsne = manifold.TSNE(n_components=2, random_state=0)
#fc2_tsne = tsne.fit_transform(np.squeeze(fc2_out))
#fc1_tsne = tsne.fit_transform(np.squeeze(fc1_out))
#flatten_tsne = tsne.fit_transform(np.squeeze(flatten))
#fc2_tsne = np.load('fc2_tsne')
#fc1_tsne = np.load('fc1_tsne')
#flatten_tsne = np.load('flatten_tsne')
#labels = np.argmax(y_test, axis=1)
#plt.figure(figsize=(25, 20)) #in inches
#x = fc2_tsne[:,0]/np.linalg.norm(fc2_tsne[:,0])
#y = fc2_tsne[:,1]/np.linalg.norm(fc2_tsne[:,1])
#plt.scatter(x, y, c=labels)
#plt.colorbar()
#plt.savefig('fc2_tsne_norm.png')
#plt.figure(figsize=(25, 20))
#x = fc1_tsne[:,0]/np.linalg.norm(fc1_tsne[:,0])
#y = fc1_tsne[:,1]/np.linalg.norm(fc1_tsne[:,1])
#plt.scatter(x, y, c=labels)
#plt.colorbar()
#plt.savefig('fc1_tsne_norm.png')
#plt.figure(figsize=(25, 20)) #in inches
#x = flatten_tsne[:,0]/np.linalg.norm(flatten_tsne[:,0])
#y = flatten_tsne[:,1]/np.linalg.norm(flatten_tsne[:,1])
#plt.scatter(x, y, c=labels)
#plt.colorbar()
#plt.savefig('flatten_tsne_norm.png')
#fc2_tsne.dump('fc2_tsne')
#fc1_tsne.dump('fc1_tsne')
#flatten_tsne.dump('flatten_tsne')
#print('fc1 scores: ')
#_classify(fc1_tsne, labels)
#print('fc2 scores: ')
#_classify(fc2_tsne, labels)
#print('flatten layer scores: ')
#_classify(flatten_tsne, labels)
model = siamese.Siamese()
x1 = tf.placeholder(tf.float32, [None, 32, 32, 3])
model.inference(x1, reuse=False)
with tf.Session() as siamese_sess:
init = tf.initialize_all_variables()
saver = tf.train.Saver()
saver.restore(siamese_sess, "checkpoints/siamese")
dataset = cifar10_utils.get_cifar10('cifar10/cifar-10-batches-py')
x_test, y_test = cifar10.test.images, cifar10.test.labels
l2_out = siamese_sess.run(model.l2_out, feed_dict={x1: x_test})
siamese_tsne = tsne.fit_transform(np.squeeze(l2_out))
plt.figure(figsize=(25, 20)) #in inches
labels = np.argmax(y_test, axis=1)
x = siamese_tsne[:,0]/np.linalg.norm(siamese_tsne[:,0])
y = siamese_tsne[:,1]/np.linalg.norm(siamese_tsne[:,1])
plt.scatter(x, y, c=labels)
plt.colorbar()
plt.savefig('siamese_l2out.png')
siamese_tsne.dump('siamese_tsne')
print('siamese L2 scores: ')
_classify(siamese_tsne, labels)
import pickle
import pylab as plt
with open("data.pickle", "rb") as fr:
data = pickle.load(fr)
n = len(data)
# Use latex
plt.rc('text', usetext=True)
plt.rc('font', family='serif')
# Plot
plt.figure(figsize=(10, 6), dpi=300)
plt.title(r"Title", fontsize=16)
plt.xlabel(r'$x', fontsize=14)
plt.ylabel(r'$y$', fontsize=14)
plt.legend(fontsize=12)
plt.grid()
x = data[0]
for i in range(1, n):
plt.plot(x, data[i], label=r'$i=' + str(i) + '$')
plt.savefig("plot.png", dpi=300)
def make_histogram_predef(filename,
columns,
bin_ranges,
bin_numbers,
file_lineskip=1,
titles=None,
xlabels=None,
savefig=False):
"""Read data from 'filename' in columns 'columns' and create a histogram from the result.
This method reads the data and immediately bins the data to produce a histogram, without saving
the data in memory. Uses bin_ranges and bin_numbers to create histogram bins.
Can optionally subsample the file, reading only every file_lineskip line.
Returns the histogram binned data in a dictionary of numpy arrays, so new plots could be created."""
# filename = name of data file.
# columns = column numbers to read from data file. Count starts at 1. List of ints.
# bin_ranges = must be specified. gives lower/upper ranges for the histogram.
# List of pairs of values, same length as columns.
# bin_numbers = must be specified. gives number of bins in histogram.
# gives number of bins in histogram. List of ints, same length as columns.
# file_lineskip = read only lines which are multiples of file_lineskip.
# Check input types.
for c in columns:
if not (isinstance(c, int)):
raise Exception('Error - columns should be list of ints.')
if (bin_numbers == None) | (bin_ranges == None):
raise Exception(
'Error - bin_ranges and bin_numbers have to be predefined.')
if ((len(bin_numbers) != len(columns)) & (len(bin_numbers) > 1)):
raise Exception(
'Error - bin_numbers should be same length as columns or length 1.'
)
if len(bin_ranges) != len(columns):
raise Exception(
'Error - bin_ranges should be same length as columns. (2 pairs per list item).'
)
# Set up histogram bins and values to help assign values into histogram bins.
histobins = {}
histovals = {}
minval = {}
stepval = {}
nbinmax = {}
i = 0
for c in columns:
minval[c] = bin_ranges[i][0]
hival = bin_ranges[i][1]
stepval[c] = (hival - minval[c]) / float(bin_numbers[i])
histobins[c] = numpy.arange(minval[c],
hival + stepval[c],
stepval[c],
dtype='float')
histovals[c] = numpy.zeros(len(histobins[c]), dtype='int')
nbinmax[c] = len(histobins[c])
i = i + 1
# Set up for calculating some basic statistics for output.
stats = {}
statlist = ('data_min', 'data_max', 'data_ave', 'hist_min', 'hist_max',
'hist_ave')
for c in columns:
stats[c] = {}
stats[c]['data_min'] = 1e9
stats[c]['data_max'] = -1e9
stats[c]['data_ave'] = 0
# Read the data.
# Open data file.
f = open(filename, 'r')
line_num = 0
for line in f:
line_num = line_num + 1
# Skip comment lines.
if (line.startswith("#") | line.startswith("!")):
continue
# Skip the lines which are not multiples of file_lineskip (to enable subsampling file).
# i.e. if file_lineskip = 10, this will read only every tenth line.
if (line_num % file_lineskip != 0):
continue
values = line.split()
# If there are not enough values in the line, quit reading (assume end of file).
if len(values) < max(columns):
break
# Assign data to histogram bins.
for c in columns:
dataval = float(values[c - 1])
histidx = min(int((dataval - minval[c]) / stepval[c]),
nbinmax[c] - 1)
histovals[c][histidx] = histovals[c][histidx] + 1
# And calculate the min/max/ave of the data.
stats[c]['data_min'] = min(dataval, stats[c]['data_min'])
stats[c]['data_max'] = max(dataval, stats[c]['data_max'])
stats[c]['data_ave'] = stats[c]['data_ave'] + dataval
# Close file.
f.close()
# Print some basic output.
for c in columns:
print("# For column ", c, " used ", len(histovals[c]), " bins.")
print("# And ", histovals[c].sum(), " values from the data file.")
stats[c]['data_ave'] = stats[c]['data_ave'] / histovals[c].sum()
stats[c]['hist_min'] = histovals[c].min()
stats[c]['hist_max'] = histovals[c].max()
stats[c]['hist_ave'] = histovals[c].sum() / float(len(histovals[c]))
print("")
writestring = "# column "
for key in statlist:
writestring = writestring + " %s " % (key)
print(writestring)
for c in columns:
writestring = "c %d " % (c)
for key in statlist:
writestring = writestring + "%g " % (stats[c][key])
print(writestring)
# Make histogram plots.
i = 0
for c in columns:
pylab.figure()
pylab.bar(histobins[c], histovals[c], width=stepval[c], linewidth=0)
if titles == None:
pylab.title("%s Column %d" % (filename, c))
else:
pylab.title(titles[i])
if xlabels != None:
pylab.xlabel(xlabels[i])
if savefig:
figname = "hist_%d" % (c)
pylab.savefig(figname + "." + figformat, format=figformat)
i = i + 1
return histobins, histovals
def main():
global no_char
x_train, y_train, x_test, y_test, no_char = data_read_words()
# 2 cells
x = tf.placeholder(tf.int64, [None, MAX_DOCUMENT_LENGTH])
y_ = tf.placeholder(tf.int64)
logits, word_list = rnn_model(x)
# 1 cell
x2 = tf.placeholder(tf.int64, [None, MAX_DOCUMENT_LENGTH])
y2_ = tf.placeholder(tf.int64)
logits2, word_list2 = rnn_model2(x2)
#2 cells
entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(labels=tf.one_hot(
y_, MAX_LABEL),
logits=logits))
train_op = tf.train.AdamOptimizer(lr).minimize(entropy)
accuracy = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(logits, axis=1), y_), tf.float64))
#1cell
entropy2 = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(labels=tf.one_hot(
y2_, MAX_LABEL),
logits=logits2))
train_op2 = tf.train.AdamOptimizer(lr).minimize(entropy2)
accuracy2 = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(logits2, axis=1), y2_), tf.float64))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# 2 cells
loss = []
loss_batch = []
acc = []
# 1 cell
loss2 = []
loss_batch2 = []
acc2 = []
# breaking down into batches
N = len(x_train)
idx = np.arange(N)
for e in range(no_epochs):
np.random.shuffle(idx)
trainX_batch, trainY_batch = x_train[idx], y_train[idx]
for start, end in zip(range(0, N, batch_size),
range(batch_size, N, batch_size)):
word_list_, _, loss_ = sess.run([word_list, train_op, entropy],
{
x: trainX_batch[start:end],
y_: trainY_batch[start:end]
})
loss_batch.append(loss_)
word_list2_, _, loss2_ = sess.run(
[word_list2, train_op2, entropy2], {
x2: trainX_batch[start:end],
y2_: trainY_batch[start:end]
})
loss_batch2.append(loss2_)
#2cells
loss.append(sum(loss_batch) / len(loss_batch))
loss_batch[:] = []
acc.append(accuracy.eval(feed_dict={x: x_test, y_: y_test}))
#1cell
loss2.append(sum(loss_batch2) / len(loss_batch2))
loss_batch2[:] = []
acc2.append(accuracy2.eval(feed_dict={x2: x_test, y2_: y_test}))
if e % 10 == 0:
print('2 Cells, epoch: %d, entropy: %g' % (e, loss[e]))
print('2 Cells, epoch: %d, accuracy: %g' % (e, acc[e]))
print('1 Cell, epoch: %d, entropy: %g' % (e, loss2[e]))
print('1 Cell, epoch: %d, accuracy: %g' % (e, acc2[e]))
pylab.figure(1)
pylab.plot(range(len(loss)), loss)
pylab.plot(range(len(loss2)), loss2)
pylab.xlabel('epochs')
pylab.ylabel('entropy')
pylab.legend(['2 Cells', '1 Cell'])
pylab.savefig('figures/partb_6b(3)_entropy_merged.png')
pylab.figure(2)
pylab.plot(range(len(acc)), acc)
pylab.plot(range(len(acc2)), acc2)
pylab.xlabel('epochs')
pylab.ylabel('accuracy')
pylab.legend(['2 Cells', '1 Cell'])
pylab.savefig('figures/partb_6b(3)_accuracy_merged.png')
pylab.show()
def make_2d_scatterhist(filename,
columns,
bin_numbers=None,
file_lineskip=1,
titles=None,
xlabels=None,
savefig=False):
"""Read data from 'filename' in columns 'columns' and create a histogram from the result.
This method reads the data and stores it in memory, to allow pylab to create the histogram
with the optimal ranges for the data, while the number of bins can be specified with 'bin_numbers'.
Can optionally subsample the file, reading only every file_lineskip line.
Returns the data read from 'filename' in a dictionary of numpy arrays so if this was called from an
interactive python shell, the histogram could be redone to visually examine the results of
different ranges and number of bins. """
# filename = name of data file.
# columns = column numbers to read from data file. Count starts at 1. List of ints. Can only be 2 columns.
# bin_numbers = can be specified (otherwise defaults to 100).
# gives number of bins in histogram. List of ints, same length as columns.
# file_lineskip = read only lines which are multiples of file_lineskip.
if len(columns) > 2:
raise Exception('This routine can only handle 2 columns.')
for c in columns:
if not (isinstance(c, int)):
raise Exception('Error - columns should be list of ints.')
if bin_numbers != None:
if ((len(bin_numbers) != len(columns)) & (len(bin_numbers) > 1)):
raise Exception(
'Error - bin_numbers should be same length as columns or length 1.'
)
# Set up dictionary and lists to save data while being read.
data = {}
for c in columns:
data[c] = []
# Read the data.
# Open data file.
f = open(filename, 'r')
line_num = 0
for line in f:
line_num = line_num + 1
# Skip comment lines.
if (line.startswith("#") | line.startswith("!")):
continue
# Skip the lines which are not multiples of file_lineskip (to enable subsampling file).
# i.e. if file_lineskip = 10, this will read only every tenth line.
if ((line_num % file_lineskip) != 0):
continue
values = line.split()
# If there are not enough values in the line, quit reading (assume end of file).
if len(values) < max(columns):
break
# Assign data to dictionary.
for c in columns:
data[c].append(values[c - 1])
# Close file.
f.close()
# Convert to numpy arrays.
for c in columns:
data[c] = numpy.array(data[c], dtype='float')
# Set up to create histograms.
# Set bin_numbers to default value, if not set by user.
if bin_numbers == None:
bin_numbers = [100]
if len(bin_numbers) == 1:
for c in columns:
bin_numbers.append(bin_numbers[0])
# Create scatter plot / histograms. One figure only.
nullfmt = NullFormatter() # no labels
# definitions for the axes - set any values.
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left + width + 0.02
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
# start with a rectangular Figure
pylab.figure(1, figsize=(8, 8))
axScatter = pylab.axes(rect_scatter)
axHistx = pylab.axes(rect_histx)
axHisty = pylab.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
# Create the scatter plot.
axScatter.scatter(data[columns[0]], data[columns[1]])
# Now determine nice limits by hand.
xymax = numpy.max(
[numpy.max(data[columns[0]]),
numpy.max(data[columns[1]])])
xymin = numpy.min(
[numpy.min(data[columns[0]]),
numpy.min(data[columns[1]])])
binwidth = (xymax - xymin) / bin_numbers[0]
lim = (int(xymax / binwidth) + 0.5) * binwidth
axScatter.set_xlim((-lim, lim))
axScatter.set_ylim((-lim, lim))
bins = numpy.arange(-lim, lim + binwidth, binwidth)
n = {}
n[columns[0]], b, p = axHistx.hist(data[columns[0]], bins=bins)
n[columns[1]], b, p = axHisty.hist(data[columns[1]],
bins=bins,
orientation='horizontal')
axHistx.set_xlim(axScatter.get_xlim())
axHisty.set_ylim(axScatter.get_ylim())
if xlabels != None:
pylab.xlabel(xlabels[0])
pylab.ylabel(xlabels[1])
if savefig:
figname = "hist_%d" % (c)
pylab.savefig(figname + "." + figformat, format=figformat)
# Calculate some basic statistics for output.
stats = {}
statlist = ('data_min', 'data_max', 'data_ave', 'hist_min', 'hist_max',
'hist_ave')
for c in columns:
stats[c] = {}
stats[c]['data_min'] = data[c].min()
stats[c]['data_max'] = data[c].max()
stats[c]['data_ave'] = data[c].sum() / float(len(data[c]))
stats[c]['hist_min'] = n[c].min()
stats[c]['hist_max'] = n[c].max()
stats[c]['hist_ave'] = n[c].sum() / float(len(n[c]))
print("")
writestring = "# column "
for key in statlist:
writestring = writestring + " %s " % (key)
print(writestring)
for c in columns:
writestring = "c %d " % (c)
for key in statlist:
writestring = writestring + "%g " % (stats[c][key])
print(writestring)
return data, stats
zorder=10)
ts_map = copy.copy(blank)
ts_map[pix] = ts[idx] if ts.ndim > 1 else ts
stellar_map = copy.copy(blank)
stellar_map[pix] = stellar[idx] if stellar.ndim > 1 else stellar
##frac_map = copy.copy(blank); frac_map[pix] = frac[idx]
slices = [(ts_map, 'TS'), (stellar_map, 'Stellar'),
(maglim_map, 'Maglim (g)'), (density_map, 'Density')]
for i, (map, label) in enumerate(slices):
img = healpy.gnomview(map,
rot=[glon, glat],
xsize=xsize,
reso=reso,
title='',
sub=[2, 2, i + 1],
notext=True)
fig.gca().annotate(label, **label_kwargs)
fig.suptitle(title,
y=0.95,
bbox={
'boxstyle': "round",
'fc': '1'
},
zorder=10)
plt.draw()
plt.savefig(name + '_analysis.png', bbox_inches='tight')
#*****************************************************************************
import pylab
from scipy import arange
# Got this data using
# python sailing_uct.py "main(5)"
# and so on.
partial_run_20 = [
107, 55366, 5577, 130710, 173, 597, 2254, 24113, 74626, 131, 196, 55926,
433053, 147, 280688, 362, 296, 1003, 7, 519, 7736
]
estimate_20 = sum(partial_run_20) / (1.0 * len(partial_run_20)) * 100
lake_size = [0, 5, 10, 20]
grid_size = [x**2 for x in lake_size]
nr_samples = [0, 21743, 436847, estimate_20]
pylab.loglog(grid_size, nr_samples, marker='*')
pylab.title("Number of samples to achieve error < 0.1 for sailing problem")
pylab.xlabel("grid size")
pylab.ylabel("number of samples")
pylab.xlim(xmin=1)
pylab.ylim(ymin=1)
pylab.grid(True)
pylab.savefig("nr_samples_uct_sailing.pdf")
def make_histogram(filename,
columns,
bin_numbers=None,
file_lineskip=1,
titles=None,
xlabels=None,
savefig=False):
"""Read data from 'filename' in columns 'columns' and create a histogram from the result.
This method reads the data and stores it in memory, to allow pylab to create the histogram
with the optimal ranges for the data, while the number of bins can be specified with 'bin_numbers'.
Can optionally subsample the file, reading only every file_lineskip line.
Returns the data read from 'filename' in a dictionary of numpy arrays so if this was called from an
interactive python shell, the histogram could be redone to visually examine the results of
different ranges and number of bins. """
# filename = name of data file.
# columns = column numbers to read from data file. Count starts at 1. List of ints.
# bin_numbers = can be specified (otherwise defaults to 100).
# gives number of bins in histogram. List of ints, same length as columns.
# file_lineskip = read only lines which are multiples of file_lineskip.
for c in columns:
if not (isinstance(c, int)):
raise Exception('Error - columns should be list of ints.')
if bin_numbers != None:
if ((len(bin_numbers) != len(columns)) & (len(bin_numbers) > 1)):
raise Exception(
'Error - bin_numbers should be same length as columns or length 1.'
)
# Set up dictionary and lists to save data while being read.
data = {}
for c in columns:
data[c] = []
# Read the data.
# Open data file.
f = open(filename, 'r')
line_num = 0
for line in f:
line_num = line_num + 1
# Skip comment lines.
if (line.startswith("#") | line.startswith("!")):
continue
# Skip the lines which are not multiples of file_lineskip (to enable subsampling file).
# i.e. if file_lineskip = 10, this will read only every tenth line.
if ((line_num % file_lineskip) != 0):
continue
values = line.split()
# If there are not enough values in the line, quit reading (assume end of file).
if len(values) < max(columns):
break
# Assign data to dictionary.
for c in columns:
data[c].append(values[c - 1])
# Close file.
f.close()
# Convert to numpy arrays.
for c in columns:
data[c] = numpy.array(data[c], dtype='float')
# Set up to create histograms.
# Set bin_numbers to default value, if not set by user.
if bin_numbers == None:
bin_numbers = [100]
if len(bin_numbers) == 1:
for c in columns:
bin_numbers.append(bin_numbers[0])
# Create histograms - a new figure for each column.
i = 0
n = {}
b = {}
p = {}
for c in columns:
pylab.figure()
n[c], b[c], p[c] = pylab.hist(data[c], bins=bin_numbers[i])
if titles == None:
pylab.title("%s Column %d" % (filename, c))
else:
pylab.title(titles[i])
if xlabels != None:
pylab.xlabel(xlabels[i])
if savefig:
figname = "hist_%d" % (c)
pylab.savefig(figname + "." + figformat, format=figformat)
i = i + 1
# Calculate some basic statistics for output.
stats = {}
statlist = ('data_min', 'data_max', 'data_ave', 'hist_min', 'hist_max',
'hist_ave')
for c in columns:
stats[c] = {}
stats[c]['data_min'] = data[c].min()
stats[c]['data_max'] = data[c].max()
stats[c]['data_ave'] = data[c].sum() / float(len(data[c]))
stats[c]['hist_min'] = n[c].min()
stats[c]['hist_max'] = n[c].max()
stats[c]['hist_ave'] = n[c].sum() / float(len(n[c]))
print("")
writestring = "# column "
for key in statlist:
writestring = writestring + " %s " % (key)
print(writestring)
for c in columns:
writestring = "c %d " % (c)
for key in statlist:
writestring = writestring + "%g " % (stats[c][key])
print(writestring)
return data, stats
celltypes = ['pyr', 'pv']
sub_fig_num = len(layers)
pylab.figure(1)
for xi, xin in enumerate(layers):
pylab.subplot(sub_fig_num, 1, xi + 1)
if xi == 0:
pylab.title('V1_1')
for yin in celltypes:
spks = spikes['V1_1' + xin + yin]
pylab.scatter(spks[0], spks[1], c=colors[yin], s=5, edgecolors='none')
pylab.xlim([0.0, simtime])
pylab.ylabel(xin)
pylab.savefig('../figs/raster_pref' + str(top_down_pyr) + '_' +
str(top_down_pv) + '_' + str(msd) + '_' + str(fraction) + '_' +
sim_len + '.eps')
pylab.figure(2)
for xi, xin in enumerate(layers):
pylab.subplot(sub_fig_num, 1, xi + 1)
if xi == 0:
pylab.title('V1_2')
for yin in celltypes:
spks = spikes['V1_2' + xin + yin]
pylab.scatter(spks[0], spks[1], c=colors[yin], s=5, edgecolors='none')
pylab.xlim([0.0, simtime])
pylab.ylabel(xin)
pylab.savefig('../figs/raster_nonpref' + str(top_down_pyr) + '_' +
str(top_down_pv) + '_' + str(msd) + '_' + str(fraction) + '_' +
def main(subArea, runName, chartTitlePre, ownership):
outDir = "C:\\Users\\olsenk\\Dropbox\\FPF\\Envision Runs\\keith_production\\"
varList = [
' Early Successional (ha) Forest', ' Pole and Small (ha) Forest',
' Medium (ha) Forest', ' Large and Giant (ha) Forest',
' Open Canopy (ha) Forest', ' Closed Canopy (ha) Forest'
]
yLabelText = 'Area (%)'
chartTitle = chartTitlePre
PMG345Ha = reporterFunc.getPMG345Ha(subArea)
forestedHa = reporterFunc.getOwnerForestedHa(subArea)
figTextList = [
'Early successional', 'Pole and small', 'Medium', 'Large and giant',
'Open canopy', 'Closed canopy'
]
# list of ownerships to graphs
ownersToGraph = [
'Federal', 'State', 'Private Non-Industrial', 'Private Industrial',
'Tribal', 'Homeowner'
]
reporterName = r'ForestStructure2_by_OWNER_pivot.csv'
ownerLabelField = ' OWNER_label'
if ownership == 'All':
pdfFile = PdfPages(outDir + 'report4_ForestStructure2_landscape.pdf')
elif ownership in ownersToGraph:
ownersToGraph = [ownership]
pdfFile = PdfPages(outDir + 'report4_ForestStructure2_' +
ownersToGraph[0] + '.pdf')
else:
ownersToGraph = [ownership]
pdfFile = PdfPages(outDir + 'report4_ForestStructure2_' +
ownersToGraph[0] + '.pdf')
ownerLabelField = ' OWNER_DETL_label'
reporterName = r'ForestStructure2_by_OWNER_DETL_pivot.csv'
fig = pl.figure(1, figsize=(8, 6.5))
for varStruct in varList:
# setup plot for all scenarios
ax = fig.add_subplot(2, 3, varList.index(varStruct) + 1)
for scenario in [
'CurrentPolicy', 'No_Treatment_Fed', 'Restoration',
'noFireNoTreatFed'
]:
inDir = outDir + runName + "_" + scenario + "\\"
if os.path.isdir(inDir):
yearList = list(
set(pd.io.parsers.read_csv(inDir + reporterName)[' Year']))
repList = list(
set(pd.io.parsers.read_csv(inDir + reporterName)[' Run']))
totalArea = pd.io.parsers.read_csv(inDir + reporterName)
# get stats from multiple reps
statsList = []
for year in range(1, max(yearList) + 1):
yearArea = totalArea[totalArea[' Year'] == year]
dataList = []
for rep in repList:
repArea = yearArea[yearArea[' Run'] == rep]
# sum output over selected ownerships
for ownerToGraph in ownersToGraph:
if ownerToGraph == ownersToGraph[0]:
ownerArea = pd.DataFrame(repArea[
repArea[ownerLabelField] == ownerToGraph])
fireProneArea345 = PMG345Ha[ownerToGraph]
fireProneArea = forestedHa[ownerToGraph]
else:
tempArea = repArea[repArea[ownerLabelField] ==
ownerToGraph]
for varName in varList:
# totalArea.loc[list(ownerArea.index)[0],varName] += tempArea[varName].iloc[0]
ownerArea[varName].iloc[0] += tempArea[
varName].iloc[0]
fireProneArea345 += PMG345Ha[ownerToGraph]
fireProneArea += forestedHa[ownerToGraph]
ownerToGraph = 'All'
if varStruct in [
' Resilient (ha) PMG345',
' Semi-Resilient (ha) PMG345',
' Low Resilience (ha) PMG345'
]:
if fireProneArea345 > 0:
dataList.append(ownerArea[varStruct].iloc[0] /
fireProneArea345 * 100)
else:
dataList.append(0.0)
else:
if fireProneArea > 0:
dataList.append(ownerArea[varStruct].iloc[0] /
fireProneArea * 100)
else:
dataList.append(0.0)
# convert to numpy array
numpyList = np.array(dataList)
lower95th = np.mean(numpyList, axis=0) - (
(1.96 * np.std(numpyList, axis=0)) /
np.sqrt(len(repList)))
upper95th = np.mean(numpyList, axis=0) + (
(1.96 * np.std(numpyList, axis=0)) /
np.sqrt(len(repList)))
if lower95th < 0:
lower95th = 0.0
# add year data to dictionary
dataDict = {
'timeStep': year,
'mean': np.mean(numpyList, axis=0),
'std': np.std(numpyList, axis=0),
'lower': lower95th,
'upper': upper95th
}
# convert to list for DataFrame
statsList.append(dataDict)
# convert to DataFrame
dataTable = pd.DataFrame(statsList)
plotLegend = (-99, -99)
if varStruct == ' Pole and Small (ha) Forest':
plotLegend = (0.99, 0.33)
if varList.index(varStruct) >= (len(varList) - 3):
labelXtick = True
else:
labelXtick = False
if varList.index(varStruct) == 0 or varList.index(
varStruct) == 3:
labelYtick = True
else:
labelYtick = False
xLabelText = yLabelText = ''
reporterFunc.plotReporter4(
fig, ax, '', pdfFile, dataTable,
['mean', 'lower', 'upper'], xLabelText, yLabelText,
scenario, labelXtick, labelYtick, plotLegend,
figTextList[varList.index(varStruct)])
reporterFunc.plotFigureText(fig, 'Simulation Year', 'Area (%)')
pl.savefig(outDir + 'report4_ForestStructure2_landscape.png',
bbox_inches='tight',
dpi=300)
pdfFile.savefig()
pl.close()
pdfFile.close()
print "Done."
def get_cartesian_coords(q1,
q2,
q1_start_local_left=None,
q2_start_local_bottom=None,
return_jacobian=False):
q1_midpoint = 0.5 * (af.max(q1) + af.min(q1))
q2_midpoint = 0.5 * (af.max(q2) + af.min(q2))
N_g = domain.N_ghost
# Default initialisation to rectangular grid
x = q1
y = q2
jacobian = [[1. + 0. * q1, 0. * q1], [0. * q1, 1. + 0. * q1]]
[[dx_dq1, dx_dq2], [dy_dq1, dy_dq2]] = jacobian
# Radius and center of circular region
radius = 0.5
center = [0, 0]
if (q1_start_local_left != None and q2_start_local_bottom != None):
x_0 = -0.33333333 #-radius/np.sqrt(2)
x_y_bottom_left = [x_0, 0.]
x_y_bottom_center = [0., 0.]
x_y_bottom_right = [0.33333333, 0.]
x_y_left_center = [x_0, (1.33333333) / 2]
x_y_right_center = [0.33333333, (1.33333333) / 2]
x_y_top_left = [x_0, 1.33333333]
x_y_top_center = [0., 1.33333333]
x_y_top_right = [0.33333333, 1.33333333]
x, y, jacobian = quadratic(
q1,
q2,
x_y_bottom_left,
x_y_bottom_right,
x_y_top_right,
x_y_top_left,
x_y_bottom_center,
x_y_right_center,
x_y_top_center,
x_y_left_center,
q1_start_local_left,
q2_start_local_bottom,
)
pl.plot(af.moddims(dx_dq1[0, 0, :, N_g],
q1.dims()[2]).to_ndarray(),
'-o',
color='C0',
alpha=0.5,
label="dx_dq1")
pl.plot(af.moddims(dy_dq1[0, 0, :, N_g],
q1.dims()[2]).to_ndarray(),
'-o',
color='k',
alpha=0.5,
label="dy_dq1")
pl.plot(af.moddims(dx_dq2[0, 0, :, N_g],
q1.dims()[2]).to_ndarray(),
'-o',
color='C2',
alpha=0.5,
label="dx_dq2")
pl.plot(af.moddims(dy_dq2[0, 0, :, N_g],
q1.dims()[2]).to_ndarray(),
'-o',
color='C3',
alpha=0.5,
label="dy_dq2")
pl.legend(loc='best')
pl.savefig(
"/home/quazartech/bolt/example_problems/electronic_boltzmann/test_quadratic/iv.png"
)
pl.clf()
if (return_jacobian):
return (x, y, jacobian)
else:
return (x, y)
else:
print(
"Error in get_cartesian_coords(): q1_start_local_left or q2_start_local_bottom not provided"
)
for line in ret.split():
if line[0].isdigit():
times[para - 1] = float(line)
print times
fig = pylab.figure()
x = range(1, 10)
y = times
pylab.plot(x, y)
pylab.xlabel("Parallelization Factor")
pylab.ylabel("Execution Time in Seconds")
pylab.title(
"Execution Time Generating {0} Images vs Parallelization Factor".
format(image_num))
pylab.savefig(hiddencube_home + '/benchmark/para_vs_executiontime.png')
pylab.close(fig)
except KeyError:
print "\t ERROR: You need to set the HIDDENCUBE_HOME environment variable to the path to the home directory of this project. Execute a command similar to 'export HIDDENCUBE_HOME=/home/ncarey/gitrepos/HiddenCubeDataset'"
#print "Total: {0}".format(times[0])
# print "Total: {0}".format(times[-1] - times[0])
# print "Start Set: {0}".format(times[1] - times[0])
# print "Sim Set: {0}".format(times[2] - times[1])
# print "RandRots: {0}".format(times[3] - times[2])
# print "Color: {0}".format(times[4] - times[3])
#
for step in range(nsteps):
if step % 2 == 0:
while True:
#x = random.uniform(-1.0, 1.0)
#p = math.exp(-0.5 * x ** 2 - alpha * x ** 4 )
x=gauss_cut()
p=math.exp(- alpha * x ** 4 )
if random.uniform(0.0, 1.0) < p:
break
else:
while True:
#y = random.uniform(-1.0, 1.0)
#p = math.exp(-0.5 * y ** 2 - alpha * y ** 4 )
y=gauss_cut()
p=math.exp(- alpha * y ** 4 )
if random.uniform(0.0, 1.0) < p:
break
samples_x.append(x)
samples_y.append(y)
pylab.hexbin(samples_x, samples_y, gridsize=50, bins=1000)
pylab.axis([-1.0, 1.0, -1.0, 1.0])
cb = pylab.colorbar()
pylab.xlabel('x')
pylab.ylabel('y')
pylab.title('A2_2')
pylab.savefig('plot_A2_2.png')
pylab.show()
def normalize_dat_file(directory, filename, no_of_spectra_in_bunch,
median_filter_window, show_aver_spectra):
"""
function calculates the average spectrum in DAT file and normalizes all spectra in file to average spectra
Input parameters:
directory - name of directory with initial dat file
filename - name of initial dat file
no_of_spectra_in_bunch - number of spectra in bunch to read
median_filter_window - window of median filter to process the average spectrum
show_aver_spectra - boolean variable which indicates if the picture of average spectrum to be shown and
the script paused till the picture window is closed
Output parameters:
output_file_name - name of result normalized .dat file
"""
print(
'\n Preparations and calculation of the average spectrum to normalize... \n'
)
output_file_name = directory + 'Norm_' + filename
filename = directory + filename
# Opening DAT datafile
file = open(filename, 'rb')
# *** Data file header read ***
df_filesize = os.stat(filename).st_size # Size of file
df_filename = file.read(32).decode('utf-8').rstrip(
'\x00') # Initial data file name
file.close()
if df_filename[-4:] == '.adr':
[
df_filename, df_filesize, df_system_name, df_obs_place,
df_description, CLCfrq, df_creation_timeUTC, ReceiverMode, Mode,
sumDifMode, NAvr, TimeRes, fmin, fmax, df, frequency, FFTsize,
SLine, Width, BlockSize
] = FileHeaderReaderADR(filename, 0, 0)
if df_filename[-4:] == '.jds': # If data obtained from DSPZ receiver
[
df_filename, df_filesize, df_system_name, df_obs_place,
df_description, CLCfrq, df_creation_timeUTC, SpInFile,
ReceiverMode, Mode, Navr, TimeRes, fmin, fmax, df, frequency,
FreqPointsNum, dataBlockSize
] = FileHeaderReaderJDS(filename, 0, 0)
# Calculation of the dimensions of arrays to read
nx = len(frequency) # the first dimension of the array
ny = int((
(df_filesize - 1024) /
(nx * 8))) # the second dimension of the array: file size - 1024 bytes
# Number of data blocks to read from file
num_of_blocks = int(ny // no_of_spectra_in_bunch)
# Read data from file by blocks and average it
file = open(filename, 'rb')
file.seek(1024)
average_array = np.empty((nx, 0), float)
for block in range(num_of_blocks):
if block == (num_of_blocks - 1):
spectra_num_in_bunch = ny - (num_of_blocks -
1) * no_of_spectra_in_bunch
else:
spectra_num_in_bunch = no_of_spectra_in_bunch
data = np.fromfile(file,
dtype=np.float64,
count=nx * spectra_num_in_bunch)
data = np.reshape(data, [nx, spectra_num_in_bunch], order='F')
tmp = np.empty((nx, 1), float)
# tmp[:, 0] = data.mean(axis=1)[:]
tmp[:, 0] = data.min(axis=1)[:]
average_array = np.append(average_array, tmp, axis=1) #
# Average average spectra of all data blocks
average_profile = average_array.mean(axis=1)
init_average_profile = average_profile.copy()
# # Make a figure of average spectrum (profile)
# fig = plt.figure(figsize=(9, 5))
# ax1 = fig.add_subplot(111)
# ax1.plot(10 * np.log10(average_profile), linestyle='-', linewidth='1.00', label='Average spectra')
# ax1.legend(loc='upper right', fontsize=6)
# ax1.grid(b=True, which='both', color='silver', linestyle='-')
# ax1.set_xlabel('Frequency points, num.', fontsize=6, fontweight='bold')
# ax1.set_ylabel('Intensity, dB', fontsize=6, fontweight='bold')
# pylab.savefig('Averaged_spectra_'+filename[:-4]+'_before_filtering.png', bbox_inches='tight', dpi=160)
# plt.close('all')
# Apply median filter to average profile
average_profile = median_filter(average_profile, median_filter_window)
med_average_profile = average_profile.copy()
average_profile = average_filter(average_profile,
median_filter_window + 20)
# Make a figure of filtered average spectrum (profile)
fig = plt.figure(figsize=(12, 8))
ax1 = fig.add_subplot(111)
ax1.plot(10 * np.log10(init_average_profile),
linestyle='-',
linewidth='1.50',
label='Initial spectra',
color='C0',
alpha=0.6)
ax1.plot(10 * np.log10(med_average_profile),
linestyle='-',
linewidth='1.25',
label='Median spectra',
color='C1',
alpha=0.8)
ax1.plot(10 * np.log10(average_profile),
linestyle='-',
linewidth='1.00',
label='Median averaged spectra',
color='C3')
ax1.legend(loc='upper right', fontsize=6)
ax1.grid(b=True, which='both', color='silver', linestyle='-')
ax1.set_xlabel('Frequency points, num.', fontsize=6, fontweight='bold')
ax1.set_ylabel('Intensity, dB', fontsize=6, fontweight='bold')
pylab.savefig('Averaged_spectra_' + filename[:-4] + '_after_filtering.png',
bbox_inches='tight',
dpi=160)
if show_aver_spectra:
print('\n Close the figure window to continue processing!!!\n')
plt.show()
plt.close('all')
del init_average_profile, med_average_profile
# Normalization
print(' Spectra normalization... \n')
file.seek(0)
file_header = file.read(1024)
normalized_file = open(output_file_name, 'wb')
normalized_file.write(file_header)
del file_header
bar = IncrementalBar(' Normalizing of the DAT file: ',
max=num_of_blocks,
suffix='%(percent)d%%')
bar.start()
for block in range(num_of_blocks):
if block == (num_of_blocks - 1):
spectra_num_in_bunch = ny - (num_of_blocks -
1) * no_of_spectra_in_bunch
else:
spectra_num_in_bunch = no_of_spectra_in_bunch
data = np.fromfile(file,
dtype=np.float64,
count=nx * spectra_num_in_bunch)
data = np.reshape(data, [nx, spectra_num_in_bunch], order='F')
for j in range(spectra_num_in_bunch):
data[:, j] = data[:, j] / average_profile[:]
temp = data.transpose().copy(order='C')
normalized_file.write(np.float64(temp))
bar.next()
file.close()
normalized_file.close()
bar.finish()
# *** Creating a new timeline TXT file for results ***
new_tl_file_name = output_file_name.split('_Data_', 1)[0] + '_Timeline.txt'
new_tl_file = open(
new_tl_file_name,
'w') # Open and close to delete the file with the same name
new_tl_file.close()
# *** Reading timeline file ***
old_tl_file_name = filename.split('_Data_', 1)[0] + '_Timeline.txt'
old_tl_file = open(old_tl_file_name, 'r')
new_tl_file = open(new_tl_file_name, 'w')
# Read time from timeline file
time_scale_bunch = old_tl_file.readlines()
# Saving time data to new file
for j in range(len(time_scale_bunch)):
new_tl_file.write((time_scale_bunch[j][:]) + '')
old_tl_file.close()
new_tl_file.close()
return output_file_name
def Doplots_diurnal_monthly(mypathforResults,PlottingDF,variable_to_fill, Site_ID,units,item,index_str):
ANN_label=str(item+"_NN") #Do Monthly Plot
print "Doing monthly diurnal plot for month and index ",index_str
#Do Diurnal Plots for all 12 months
#create an X axis series for all 24 hours
t = np.arange(1, 25, 1)
NN_label='Fc'
Plottemp = PlottingDF[[NN_label,item]]#[PlottingDF['day_night']!=3]
#Plottemp = PlottingDF[[NN_label,item]].dropna(how='any')
figure(1)
pl.subplot(321)
pl.title('Diurnal '+item+' month = 1')
try:
xdata1a=Plottemp[(PlottingDF.index.month==1)][item].groupby([lambda x: x.hour]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[(PlottingDF.index.month==1)][NN_label].groupby([lambda x: x.hour]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(t,xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(t,xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.subplot(322)
pl.title('Diurnal '+item+' month = 3')
try:
xdata1a=Plottemp[(PlottingDF.index.month==3)][item].groupby([lambda x: x.hour]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[(PlottingDF.index.month==3)][NN_label].groupby([lambda x: x.hour]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(t,xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(t,xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.subplot(323)
pl.title('Diurnal '+item+' month = 5')
try:
xdata1a=Plottemp[(PlottingDF.index.month==5)][item].groupby([lambda x: x.hour]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[(PlottingDF.index.month==5)][NN_label].groupby([lambda x: x.hour]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(t,xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(t,xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.subplot(324)
pl.title('Diurnal '+item+' month = 7')
try:
xdata1a=Plottemp[(PlottingDF.index.month==7)][item].groupby([lambda x: x.hour]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[(PlottingDF.index.month==7)][NN_label].groupby([lambda x: x.hour]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(t,xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(t,xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.subplot(325)
pl.title('Diurnal '+item+' month = 9')
try:
xdata1a=Plottemp[(PlottingDF.index.month==9)][item].groupby([lambda x: x.hour]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[(PlottingDF.index.month==9)][NN_label].groupby([lambda x: x.hour]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(t,xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(t,xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.subplot(326)
pl.title('Diurnal '+item+' month = 11')
try:
xdata1a=Plottemp[(PlottingDF.index.month==11)][item].groupby([lambda x: x.hour]).mean()
plotxdata1a=True
except:
plotxdata1a=False
try:
xdata1b=Plottemp[(PlottingDF.index.month==11)][NN_label].groupby([lambda x: x.hour]).mean()
plotxdata1b=True
except:
plotxdata1b=False
if plotxdata1a==True:
pl.plot(t,xdata1a,'r',label=item)
if plotxdata1b==True:
pl.plot(t,xdata1b,'b',label=NN_label)
pl.ylabel('Flux')
pl.suptitle('Monthly ANN ensemble diurnal for '+item+' at '+Site_ID+ ' index '+index_str)
pl.subplots_adjust(top=0.85)
pl.tight_layout()
pl.savefig(mypathforResults+'/Monthly ANN ensemble diurnal for '+item+' at '+Site_ID+ ' index '+index_str)
#pl.show()
pl.close()
pl.close(1)
time.sleep(1)
alpha=0.1) #, label=r"layer %u" % (layerNum))
scatCoeff = 1. / applyOpenCLWlenDependentFunction(
wlens,
mediumProps.GetScatteringLength(exampleLayerNum),
useReferenceFunction=True)
cx.plot(wlens,
1. / scatCoeff,
linewidth=3.,
linestyle='-',
color='k',
label=r"C++")
scatCoeff = 1. / applyOpenCLMediumPropertyFunction(
wlens, exampleLayerNum, mediumProps, mode="scatteringLength")
cx.plot(wlens,
1. / scatCoeff,
linewidth=1.,
linestyle='-',
color='r',
label=r"OpenCL")
cx.xaxis.set_major_locator(matplotlib.ticker.MaxNLocator(20))
cx.set_xlim(260., 690.)
cx.grid(True)
cx.legend(loc='upper right')
cx.set_xlabel(r"wavelength $\lambda [\mathrm{nm}]$")
cx.set_ylabel(r"scattering length $\lambda_\mathrm{scat;geom}$ $[\mathrm{m}]$")
pylab.savefig("medium_properties_Antares.pdf", transparent=False)
def Wave1DAnim(snapshots,
ds,
dt,
vel=None,
filename='wave1danim',
anim="gif",
fps=10):
r"""
Create an animation file from a matrix resulting from a simulation of a 1d wave field.
Creates many intermediate files to achieve that, uses ImageMagick
* snapshots : is a 2d matrix [time][nx] - pressure field
* ds : space equal in x axis
* dt : time increment between simulation steps
* vel : 1d background velocity field
* filename : file name for the animation file
* anim : animation type (gif or avi)
* fps : frames per second
"""
py.ion()
#max index time and max index space
maxt = np.shape(snapshots)[0]
maxk = np.shape(snapshots)[1]
# get the maximum and minimum u value to not blow the scale
# during the movie
ymax = snapshots.max()
ymin = snapshots.min()
# extents of the picture x starts at 0
xmin, xmax = 0, maxk * ds
extent = xmin, xmax, ymin, ymax
# font position
width = xmax - xmin
height = ymax - ymin
posx = 0.8 * width + xmin
posy = 0.8 * height + ymin
# not working?
# verticalalignment='top',
# horizontalalignment='right',
_ClearTempImages(filename, "png") # clear any previous existing
for t in range(maxt):
Wave1DPlot(snapshots[t], extent, vel)
# set axis ranges
py.hold(True)
# draw time
py.text(posx, posy, "{0:1.5f}".format(t * dt), alpha=0.8, color='b')
# since its just math objects would be perfect
# will be something like Wave1DAnim001.png
py.savefig(filename + "{0:03d}".format(t) + '.png', dpi=150)
sys.stdout.write("\r progressing .. %.1f%%" %
(100.0 * float(t) / maxt))
sys.stdout.flush()
py.clf()
sys.stdout.write(" done! \n")
py.ioff()
py.hold(False)
py.close()
if (anim == "gif"):
AnimFromPng(filename, fps=fps)
else:
AnimFromPng(filename, False, fps)
_ClearTempImages(filename, "png")
f"_selfcal{last_selfcal}", "")
if "_finaliter" in preselfcal_name:
preselfcal_name = preselfcal_name.replace(
"_finaliter", "")
if "_selfcal" in preselfcal_name:
raise ValueError("?!?!?!")
try:
with warnings.catch_warnings():
warnings.filterwarnings('ignore')
ax1, ax2, ax3, fig, diffstats = make_comparison_image(
preselfcal_name, postselfcal_name)
if not os.path.exists(f"{field}/B{band}/comparisons/"):
os.mkdir(f"{field}/B{band}/comparisons/")
pl.savefig(
f"{field}/B{band}/comparisons/{field}_B{band}_{config}_selfcal{last_selfcal}_comparison.png",
bbox_inches='tight')
except IndexError:
raise
except Exception as ex:
log.error(
f"Failure for pre={preselfcal_name} post={postselfcal_name}"
)
log.error((field, band, config, ex))
continue
matchrow = ((tbl['region'] == field) &
(tbl['band'] == f'B{band}') &
(tbl['array']
== ('12Monly' if config == '12M' else config)) &
(tbl['robust'] == 'r0.0'))
def plot_with_matchingCode(pngfilename,
plotter1_big,
plotter2_small,
biggerFile,
smallersizeFile,
custom_dpi=90):
codematches_biggerFile, codematches_smallerFile = ParseMatchingCode(
biggerFile, smallersizeFile)
# for x in codematches_biggerFile:
# print("0x%x - 0x%x" % (x[0],x[1]))
fig = figure(figsize=(16, 12))
# fig.tight_layout()
subplot1 = fig.add_subplot(211)
subplot2 = fig.add_subplot(212)
BYTES = FA.load(biggerFile)
if BYTES is None:
print("Plot error: file %s not found." % (biggerFile))
return
# Byte offsets.
BYTES_indices = np.arange(0, BYTES.size)
# subplot.axis('off')
plotter1_big._generate_plot(BYTES, BYTES_indices, subplot1)
plotRegion(subplot1, BYTES, BYTES_indices, codematches_biggerFile)
del BYTES
del BYTES_indices
BYTES_SMALLER_FILE = FA.load(smallersizeFile)
smallfileEnd = BYTES_SMALLER_FILE.size
if BYTES_SMALLER_FILE is None:
print("Plot error: file %s not found." % (smallersizeFile))
return
# Byte offsets.
BYTES_indices = np.arange(0, plotter1_big._file_size)
BYTES = np.zeros((plotter1_big._file_size), dtype=np.uint32)
BYTES[:smallfileEnd] = BYTES_SMALLER_FILE
plotter2_small._file_size = plotter1_big._file_size
plotter2_small._generate_plot(BYTES, BYTES_indices, subplot2)
plotRegion(subplot2, BYTES, BYTES_indices, codematches_smallerFile)
subplot2.set_title('{} ({} kB)'.format(plotter2_small._short_filename,
round(1.0 * (smallfileEnd / 1024))))
axvline(x=smallfileEnd, ymin=0, ymax=255, linewidth=6.0, color='r')
axvline(x=smallfileEnd, ymin=0, ymax=255, linewidth=2.0, color='k')
subplot2.add_patch(
matplotlib.patches.Rectangle((smallfileEnd, 0.0),
(plotter1_big._file_size - smallfileEnd),
255,
fill=True,
color="#cccccc"))
for ax in fig.axes:
matplotlib.pyplot.sca(ax)
xticks(rotation=315)
subplots_adjust(left=0.1,
right=0.9,
top=0.9,
bottom=0.1,
wspace=0.3,
hspace=0.3)
del BYTES
del BYTES_SMALLER_FILE
del BYTES_indices
legend(loc='upper right')
# Extra wishes to Matplotlib:
# don't waste so much white space, and put the legend to upper right.
savefig("/ram/%s" % (pngfilename), dpi=custom_dpi)
close(fig)
time.sleep(0.5)
clf()
return
def Detect_Logo_SIFT_Video(args):
Debug = int(args.debug)
logo = cv2.imread(args.logo) # logo image
scale = 4
logo = cv2.resize(logo,
None,
fx=scale,
fy=scale,
interpolation=cv2.INTER_CUBIC)
vinput = args.input # input video
if not os.path.isfile(vinput):
logging.error('---video does not exist---')
sys.exit(1)
cap = cv2.VideoCapture(vinput)
logging.warning(
'***************************************Opening the video: ' +
args.input +
' for TV Logo detection**********************************************')
fintv = float(args.frequency)
fps = cap.get(5) # frame per second in video
frn = int(cap.get(7)) # frame number
outputpath = args.outputpath
if outputpath != '' and not os.path.exists(outputpath):
os.makedirs(outputpath)
# verify beginning and end time
if args.beginning is None:
bese = 0
else:
bese = args.beginning
if args.end is None:
endse = (frn / fps)
else:
endse = args.end
if bese >= endse or bese < 0 or endse > (frn / fps):
logging.error('wrong arguments of beginning and end time')
sys.exit(1)
logging.info('process each segment of video {0}'.format(args.input))
befr = int(bese * fps) # begining frame
endfr = int(endse * fps) # ending frame
n_matches = []
frames = []
if cap.isOpened(): # if video is opened, process frames
ret, frame = cap.read()
counter = 0
#print('endfr = %d' % endfr + 'endse %d ' % endse + 'fps %d' %fps + 'frn %d' %frn )
for i in xrange(befr, endfr, int(np.round(fps / fintv))):
#print('i = %d' %i + '/ %d' %frn)
while (counter != i):
#print('counter = %d' %counter)
ret, frame = cap.read()
counter += 1
#Crop the image to the ROI and zoom for better detection performances
x1 = int(args.x1)
x2 = int(args.x2)
y1 = int(args.y1)
y2 = int(args.y2)
#print('Crop image to x1 = %d' %x1 + 'x2 = %d' %x2+'y1 = %d' %y1 + 'y2 = %d' %y2)
frame_ROI = frame[x1:x2, y1:y2]
cv2.imwrite('frame_ROI.png', frame_ROI)
scale = 4
#frame_ROI = cv2.resize(frame_ROI, None, fx= scale, fy= scale, interpolation=cv2.INTER_CUBIC)
#n_matches.append(Detect_Logo_SIFT_Frame(logo,frame_ROI,Debug, i))
#n_matches.append(Detect_Logo_SURF_Frame(logo,frame_ROI,Debug, i))
#n_matches.append(Detect_Logo_ORB_Frame(logo,frame_ROI,Debug, i))
n_matches.append(Detect_Logo_BRISK_Frame(logo, frame_ROI, Debug,
i))
#n_matches.append(Detect_Logo_FREAK_Frame(logo,frame_ROI,Debug, i))
frames.append(int(i / fps))
pl.figure(figsize=(30, 4))
chunckname_wextension = os.path.basename(args.input)
chunckname = chunckname_wextension.split('.')[0]
if not os.path.isfile('/opt/exe/textocr/demo/Chunks/GroundTruth/' +
chunckname + '_Pub_GroundTruth.txt'):
logging.warning(
'No ground Truth file found for commercial adds detection')
pl.plot(frames, n_matches, 'r')
else:
GT = np.loadtxt('/opt/exe/textocr/demo/Chunks/GroundTruth/' +
chunckname + '_Pub_GroundTruth.txt')
GT = GT * (max(n_matches))
print('GT dimension %d' % np.shape(GT))
print('histo_array dimension %d' % np.shape(n_matches))
pl.plot(frames, n_matches, 'r', label='Logo match')
#pl.plot(frames, GT, 'g', label='Ground Truth')
pl.legend()
pl.savefig(os.path.join(outputpath, args.outputname + "_logoMatch.jpg"),
dpi=50)
pl.show()
pl.rcParams["axes.labelsize"] = 18
au_in_si = 1.496e11
yr_in_si = (365.25 * 24. * 3600.)
widths = [1, 2, 3, 4, 5]
fig, ax = pl.subplots(5, 1, sharex=True, sharey=True)
for i in range(5):
for res in [300, 900, 2700, 5400]:
file = "convergence_instability_w{0}_{1}_radius.dat".format(
widths[i], res)
print "Plotting", file, "..."
fp = np.memmap(file, dtype='d', mode='r')
data = fp.reshape((-1, 3))
ax[i].plot(data[:, 0] / yr_in_si,
data[:, 1] / au_in_si,
label="{0} cells".format(res))
ax[i].axhline(y=30, linestyle="--", color="k")
ax[i].axhline(y=10, linestyle="-", color="k")
ax[i].set_title("$W = {0}$ AU".format(widths[i]))
ax[i].set_ylabel("$R_I$ (AU)")
ax[4].set_xlabel("$t$ (yr)")
ax[0].legend(loc="lower left", ncol=2)
pl.tight_layout()
pl.savefig("fig_convergence_instability.png")
def Wave2DAnim(snapshots,
ds,
dt,
vel,
filename='wave2danim',
norm=True,
vmin=None,
vmax=None,
anim="avi",
fps=15):
r"""
Create an animation file from a matrix resulting from a simulation of a 2d wave field.
Creates many intermediate files to achieve that, uses ImageMagick.
Z is downward.
* snapshots : is a 3d matrix [time][nz][nx] - pressure field
* ds : space equal in x/y axis
* dt : time increment between simulation steps
* vel : 2d background velocity field
* filename : file name for the animation file
* anim : animation type (gif or avi)
* fps : frames per second
* norm : scale the values getting the general max and min (vmax/vmin)
* vmin : global minimum of snapshots
* vmax : global maximum of snapshots
"""
py.ion()
#max index time and max index space
maxt = np.shape(snapshots)[0]
maxk = np.shape(snapshots)[1]
maxi = np.shape(snapshots)[2]
if norm:
# get the maximum and minimum values of the last 5%
# snapshots to not blow the scale during the animation
# get the maximum and minimum values of the last 5%
# snapshots to not blow the scale during the animation
snaptmp = snapshots[-int(0.05 * maxt):]
vmax = snaptmp.max()
vmin = snaptmp.min()
print "vmin : ", vmin, "vmax : ", vmax
# space axis starting at 0 in x and z (using y coz' plotting)
# extents of the picture,
xmin, xmax = 0, ds * maxi
ymin, ymax = 0, ds * maxk
extent = xmin, xmax, ymax, ymin
# font position
width = xmax - xmin
height = ymax - ymin
posx = 0.8 * width + xmin
posz = 0.8 * height + ymin
# not working?
# verticalalignment='top',
# horizontalalignment='right'
_ClearTempImages(filename, "png") # clear any previous existing
for t in xrange(maxt):
py.hold(True)
py.imshow(vel,
interpolation='bilinear',
cmap=cm.jet,
extent=extent,
origin='upper',
aspect='auto')
py.imshow(snapshots[t],
interpolation='bilinear',
cmap=cm.Greys_r,
alpha=0.8,
extent=extent,
origin='upper',
aspect='auto',
vmin=vmin,
vmax=vmax)
# optional cmap=cm.jet, apect='auto' adjust aspect to the previous plot
py.show()
# draw time
py.text(posx,
posz,
"{0:1.5f}".format(t * dt),
alpha=0.8,
style='italic',
color='b')
# since its just math objects would be perfect
# will be something like Wave1DAnim001.png
py.savefig(filename + "{0:03d}".format(t) + '.png', dpi=150)
sys.stderr.write("\r progressing .. %.1f%%" %
(100.0 * float(t) / maxt))
sys.stderr.flush()
py.clf()
sys.stdout.write(" done! \n")
py.hold(False)
py.ioff()
py.close()
if (anim == "gif"):
AnimFromPng(filename, fps=fps)
else:
AnimFromPng(filename, False, fps)
_ClearTempImages(filename, "png")
def multi_way(A=64):
pylab.ion()
pylab.figure(2, figsize=figsize)
pylab.clf()
qvec = [0.001, 0.01, 0.1]
cvec = ['b', 'c', 'g']
m = np.logspace(0, 5)
pylab.loglog(m, m, 'k:', linewidth=lw)
for (q, c) in zip(qvec, cvec):
print q
p = 1 - q
R = np.floor(np.log(q) / np.log(1 - q))
B = p**np.arange(1, R)
D = np.ones(len(B))
B = np.concatenate([B, q * p**np.arange(0, R)])
D = np.concatenate([D, np.arange(R)])
for pow in range(2, 88):
B = np.concatenate([B, q**pow * p**np.arange(0, R)])
D = np.concatenate([D, sm.comb(np.arange(R), pow)])
assert len(B) == len(D), 'len(B) != len(D)'
if len(B) > 10**8:
print pow, 'breaking'
break
B = np.concatenate(([1], B))
D = np.concatenate(([1], D))
i = B.argsort()[::-1]
B = (D[i] * B[i]).cumsum()
D = D[i].cumsum()
j = np.nonzero((D <= 10**5))[0]
#pylab.loglog(np.arange(A, 100001), A*C[np.arange(A-1, 100000)/A])
pylab.loglog(np.concatenate(([1], A * D[j])),
np.concatenate(([1], A * B[j])),
c,
linewidth=lw)
pylab.draw()
pylab.loglog(np.concatenate(([1], m * A)),
np.concatenate(([1], np.log2(m + 1) * A)),
'purple',
linewidth=lw)
pylab.xlabel('Number of cores', fontsize=fs)
pylab.ylabel('Expected speedup', fontsize=fs)
pylab.title('Expected speedup with %d-way parallelism' % A, fontsize=fs)
pylab.legend(['$E[S_J] = J$'] + [('$q = %1.4f' % q).strip('0') + '$'
for q in qvec] + ['$q = 0.5$'],
loc='upper left',
fontsize=fs)
pylab.xticks(fontsize=fs)
pylab.yticks(fontsize=fs)
pylab.axis((1, 10**4, 1, 10**4))
pylab.savefig('../figs/speedup-%d.pdf' % A)
def grid_plot(ref,
sweep,
plot_filename=None,
shapefiles=None,
interactive=False):
# Set up colormaps
from matplotlib.colors import BoundaryNorm
cmapr = _ref_ctable
cmapr.set_bad('white', 1.0)
cmapr.set_under('white', 1.0)
normr = BoundaryNorm(_ref_scale, cmapr.N)
# Create png file label
if plot_filename == None:
print(
"\n pyROTH.grid_plot: No output file name is given, writing to %s"
% "RF_...png")
filename = "RF_%2.2d_plot.%s" % (sweep, _plot_format)
else:
filename = "%s.%s" % (plot_filename, _plot_format)
fig, axes = plt.subplots(1, 2, sharey=True, figsize=(18, 10))
# Set up coordinates for the plots
sw_lon = ref.lons.min()
ne_lon = ref.lons.max()
sw_lat = ref.lats.min()
ne_lat = ref.lats.max()
bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \
lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10., ax=axes[0])
xg, yg = bgmap(ref.lons, ref.lats)
yg_2d, xg_2d = np.meshgrid(yg, xg)
yg_2d = yg_2d.transpose()
xg_2d = xg_2d.transpose()
# fix xg, yg coordinates so that pcolormesh plots them in the center.
dx2 = 0.5 * (xg[1] - xg[0])
dy2 = 0.5 * (yg[1] - yg[0])
xe = np.append(xg - dx2, [xg[-1] + dx2])
ye = np.append(yg - dy2, [yg[-1] + dy2])
# CAPPI REFLECTVITY PLOT
if shapefiles:
plot_shapefiles(bgmap,
shapefiles=shapefiles,
counties=_plot_counties,
ax=axes[0])
else:
plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[0])
# pixelated plot
ref_data = ref.data[sweep]
# im1 = bgmap.pcolormesh(xe, ye, ref_data, cmap=cmapr, norm=normr, vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[0])
# cbar = bgmap.colorbar(im1,location='right')
# cbar.set_label('Reflectivity (dBZ)')
# axes[0].set_title('Pixel Reflectivity at Height: %4.1f km' % 0.001*ref.zg[sweep])
# at = AnchoredText("Max dBZ: %4.1f" % (ref_data.max()), loc=4, prop=dict(size=10), frameon=True,)
# at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
# axes[0].add_artist(at)
# Contour filled plot
# bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \
# lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10.0, ax=axes[1])
# if shapefiles:
# plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=axes[1])
# else:
# plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[1])
#
im1 = bgmap.contourf(xg_2d, yg_2d, ref_data, levels= _ref_scale, cmap=cmapr, norm=normr, \
vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[0])
cbar = bgmap.colorbar(im1, location='right')
cbar.set_label('Reflectivity (dBZ)')
axes[0].set_title('Reflectivity at Height: %4.1f km' %
(0.001 * ref.zg[sweep]))
at = AnchoredText(
"Max dBZ: %4.1f" % (ref_data.max()),
loc=4,
prop=dict(size=10),
frameon=True,
)
at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
axes[0].add_artist(at)
# COMPOSITE PLOT
ref_data = ref.data.max(axis=0)
zero_dbz = ref.zero_dbz.data
bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \
lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10.0, ax=axes[1])
if shapefiles:
plot_shapefiles(bgmap,
shapefiles=shapefiles,
counties=_plot_counties,
ax=axes[1])
else:
plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[1])
# pixelated plot
# im1 = bgmap.pcolormesh(xe, ye, ref_data, cmap=cmapr, norm=normr, vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[2])
# cbar = bgmap.colorbar(im1,location='right')
# cbar.set_label('Reflectivity (dBZ)')
# axes[2].set_title('Pixel Composite Reflectivity at Height: %4.1f km' % 0.001*ref.zg[sweep])
# at = AnchoredText("Max dBZ: %4.1f" % (ref_data.max()), loc=4, prop=dict(size=10), frameon=True,)
# at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
# axes[2].add_artist(at)
# contoured plot
# bgmap = Basemap(projection='lcc', llcrnrlon=sw_lon,llcrnrlat=sw_lat,urcrnrlon=ne_lon,urcrnrlat=ne_lat, \
# lat_0=0.5*(ne_lat+sw_lat), lon_0=0.5*(ne_lon+sw_lon), resolution='i', area_thresh=10.0, ax=axes[3])
# if shapefiles:
# plot_shapefiles(bgmap, shapefiles=shapefiles, counties=_plot_counties, ax=axes[3])
# else:
# plot_shapefiles(bgmap, counties=_plot_counties, ax=axes[3])
im1 = bgmap.contourf(xg_2d, yg_2d, ref_data, levels= _ref_scale, cmap=cmapr, norm=normr, \
vmin = _ref_min_plot, vmax = _ref_scale.max(), ax=axes[1])
cbar = bgmap.colorbar(im1, location='right')
cbar.set_label('Reflectivity (dBZ)')
axes[1].set_title('Composite Reflectivity')
at = AnchoredText(
"Max dBZ: %4.1f" % (ref_data.max()),
loc=4,
prop=dict(size=10),
frameon=True,
)
at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
axes[1].add_artist(at)
# Plot zeros as "o"
if zero_dbz != None:
r_mask = (zero_dbz.mask == False)
print("\n Number of zero reflectivity obs found: %d" % np.sum(r_mask))
bgmap.scatter(xg_2d[r_mask], yg_2d[r_mask], s=15, facecolors='none', \
edgecolors='k', alpha=0.3, ax=axes[1])
# Get other metadata....for labeling
time_text = ref.time.strftime('%Y-%m-%d %H:%M')
title = '\nDate: %s Time: %s' % (time_text[0:10], time_text[10:19])
plt.suptitle(title, fontsize=18)
plt.savefig(filename)
if interactive: plt.show()
