def spike_psth(spike_time_ms, t1_ms=-50., t2_ms=250., bin_ms=1):
"""."""
N_trials = len(spike_time_ms)
t2_ms = pylab.ceil((t2_ms - t1_ms) / bin_ms) * bin_ms + t1_ms
N_bins = (t2_ms - t1_ms) / bin_ms
spike_count_by_trial = pylab.zeros((N_trials, N_bins), dtype=float)
if N_trials > 0:
all_spikes_ms = pylab.array([], dtype=float)
for trial in range(len(spike_time_ms)):
if spike_time_ms[trial] is None:
continue
idx = pylab.find((spike_time_ms[trial] >= t1_ms)
& (spike_time_ms[trial] <= t2_ms))
spike_count_by_trial[trial,:], bin_edges = \
pylab.histogram(spike_time_ms[trial][idx], bins = N_bins,
range = (t1_ms, t2_ms))
spike_rate = 1000 * spike_count_by_trial.mean(axis=0) / bin_ms
else:
spike_rate = pylab.nan
dummy, bin_edges = \
pylab.histogram(None, bins = N_bins, range = (t1_ms, t2_ms))
bin_center_ms = (bin_edges[1:] + bin_edges[:-1]) / 2.0
return spike_rate, spike_count_by_trial, bin_center_ms
def corr_score(file1, file2, delta, bin=1., dur=100., ncell=500):
"""Similarity score by correlation coefficient. The spike trains are convolved with a triangular kernel."""
d1 = numpy.loadtxt(file1)
d2 = numpy.loadtxt(file2)
x = numpy.zeros(int(ncell * dur / bin))
y = numpy.zeros(int(ncell * dur / bin))
for j in range(ncell):
if d1.size == 2:
s1 = numpy.array(d1[0] * (d1[1] == j))
else:
s1 = d1[d1[:, 1] == j, 0]
if d2.size == 2:
s2 = numpy.array(d2[0] * (d2[1] == j))
else:
s2 = d2[d2[:, 1] == j, 0]
kern = numpy.append(numpy.arange(delta / bin),
numpy.arange(delta / bin, -1, -1))
ts1, dump = pylab.histogram(s1, numpy.arange(0., dur + bin, bin))
ts2, dump = pylab.histogram(s2, numpy.arange(0., dur + bin, bin))
x[j * dur / bin:(j + 1) * dur / bin] = numpy.convolve(
ts1, kern, 'same')
y[j * dur / bin:(j + 1) * dur / bin] = numpy.convolve(
ts2, kern, 'same')
x = x - pylab.mean(x)
y = y - pylab.mean(y)
cor = sum(x * y) / (len(x) * pylab.std(x) * pylab.std(y))
return cor
def his(im):
'''
直方图均衡化处理
'''
r = im[:, :, 0]
g = im[:, :, 1]
b = im[:, :, 2]
imhist_r, bins_r = pl.histogram(r, 256, normed=True)
imhist_g, bins_g = pl.histogram(g, 256, normed=True)
imhist_b, bins_b = pl.histogram(b, 256, normed=True)
cdf_r = imhist_r.cumsum()
cdf_g = imhist_g.cumsum()
cdf_b = imhist_b.cumsum()
cdf_r = cdf_r * 255 / cdf_r[-1]
cdf_g = cdf_g * 255 / cdf_g[-1]
cdf_b = cdf_b * 255 / cdf_b[-1]
im_r = pl.interp(r.flatten(), bins_r[:256], cdf_r)
im_g = pl.interp(g.flatten(), bins_g[:256], cdf_g)
im_b = pl.interp(b.flatten(), bins_b[:256], cdf_b)
#原始通道图
#均衡化之后的通道图
im_r = im_r.reshape([im.shape[0], im.shape[1]])
im_g = im_g.reshape([im.shape[0], im.shape[1]])
im_b = im_b.reshape([im.shape[0], im.shape[1]])
im_p = copy.deepcopy(im)
im_p[:, :, 0] = im_r
im_p[:, :, 1] = im_g
im_p[:, :, 2] = im_b
return im_p
def plot_hist(X,Y,title,name):
# get list of tracks and list of labels
xs = X.values
ys = Y.values
ys = pl.reshape(ys,[ys.shape[0],])
pl.figure(figsize=(15, 6), dpi=100)
for i in range(many_features):
if (i==2):
counts0, bins0 = pl.histogram(xs[ys==0,i],100,range=(0.,0.08))
counts1, bins1 = pl.histogram(xs[ys==1,i],100,range=(0.,0.08))
elif (i==5):
counts0, bins0 = pl.histogram(xs[ys==0,i],100,range=(1,5))
counts1, bins1 = pl.histogram(xs[ys==1,i],100,range=(1,5))
elif (i==6):
counts0, bins0 = pl.histogram(xs[ys==0,i],100,range=(0,15))
counts1, bins1 = pl.histogram(xs[ys==1,i],100,range=(0,15))
elif (i==7):
counts0, bins0 = pl.histogram(xs[ys==0,i],100,range=(-1.5,1.))
counts1, bins1 = pl.histogram(xs[ys==1,i],100,range=(-1.5,1.))
else:
counts0, bins0 = pl.histogram(xs[ys==0,i],100)
counts1, bins1 = pl.histogram(xs[ys==1,i],100)
pl.hold()
pl.subplot(2,4,i+1)
pl.plot(bins0[0:100],counts0,'r',bins1[0:100],counts1,'b')
pl.title(feature_names[i])
pl.tight_layout()
pl.savefig("../out/{0}/{1}".format(WHICH_EXP,name),bbox_inches='tight')
def spike_psth(spike_time_ms, t1_ms = -50., t2_ms = 250., bin_ms = 1):
"""."""
N_trials = len(spike_time_ms)
t2_ms = pylab.ceil((t2_ms - t1_ms) / bin_ms)*bin_ms + t1_ms
N_bins = (t2_ms - t1_ms) / bin_ms
spike_count_by_trial = pylab.zeros((N_trials,N_bins),dtype=float)
if N_trials > 0:
all_spikes_ms = pylab.array([],dtype=float)
for trial in range(len(spike_time_ms)):
if spike_time_ms[trial] is None:
continue
idx = pylab.find((spike_time_ms[trial] >= t1_ms) &
(spike_time_ms[trial] <= t2_ms))
spike_count_by_trial[trial,:], bin_edges = \
pylab.histogram(spike_time_ms[trial][idx], bins = N_bins,
range = (t1_ms, t2_ms))
spike_rate = 1000*spike_count_by_trial.mean(axis=0)/bin_ms
else:
spike_rate = pylab.nan
dummy, bin_edges = \
pylab.histogram(None, bins = N_bins, range = (t1_ms, t2_ms))
bin_center_ms = (bin_edges[1:] + bin_edges[:-1])/2.0
return spike_rate, spike_count_by_trial, bin_center_ms
def plot_hipp_subfields(brain_file, subfield_file, figsize=(40.7, 20.3)):
fig = plt.figure(figsize=figsize)
ax = plt.subplot(1, 1, 1)
print "hello"
brain = nb.load(brain_file).get_data()
brain_affine = nb.load(brain_file).get_affine()
subfield = nb.load(subfield_file).get_data()
subfield_affine = nb.load(subfield_file).get_affine()
plt.histogram(subfield[:])
#
#plt.imshow(subfield[:,:,175], cmap="gray", origin="lower")
#plt.show()
subfield[subfield > 1] = 1
slicer = viz.plot_anat(
np.asarray(brain),
np.asarray(brain_affine),
cut_coords=np.arange(-238, -220, 2), #None, #[0,50,100,150,200,250],
slicer='z',
black_bg=True,
cmap=cm.Greys_r, # @UndefinedVariable
figure=fig,
axes=ax,
draw_cross=False)
slicer.edge_map(np.asarray(subfield),
np.asarray(subfield_affine),
color='r')
#
# fig.suptitle('subfields', fontsize='14')
plt.show()
return fig
def get_bcc_pz(self,filename_lenscat):
if self.prob_z == None:
# filename_lenscat = os.environ['HOME'] + '/data/BCC/bcc_a1.0b/aardvark_v1.0/lenscats/s2n10cats/aardvarkv1.0_des_lenscat_s2n10.351.fit'
# filename_lenscat = os.environ['HOME'] + '/data/BCC/bcc_a1.0b/aardvark_v1.0/lenscats/s2n10cats/aardvarkv1.0_des_lenscat_s2n10.351.fit'
if 'fits' in filename_lenscat:
lenscat = tabletools.loadTable(filename_lenscat)
if 'z' in lenscat.dtype.names:
self.prob_z , _ = pl.histogram(lenscat['z'],bins=self.grid_z_edges,normed=True)
elif 'z-phot' in lenscat.dtype.names:
self.prob_z , _ = pl.histogram(lenscat['z-phot'],bins=self.grid_z_edges,normed=True)
if 'e1' in lenscat.dtype.names:
select = lenscat['star_flag'] == 0
lenscat = lenscat[select]
select = lenscat['fitclass'] == 0
lenscat = lenscat[select]
select = (lenscat['e1'] != 0.0) * (lenscat['e2'] != 0.0)
lenscat = lenscat[select]
self.sigma_ell = np.std(lenscat['e1']*lenscat['weight'],ddof=1)
elif 'pp2' in filename_lenscat:
pickle = tabletools.loadPickle(filename_lenscat,log=0)
self.prob_z = pickle['prob_z']
self.grid_z_centers = pickle['bins_z']
self.grid_z_edges = plotstools.get_bins_edges(self.grid_z_centers)
def stellar_massftn():
gadget2msun=10.e10
boxsize = 47.0
max_mag=-16.
min_mag = -23.
nbins=14
hubble_h = 0.7
#subfind_folder = "/mnt/lustre/scratch/cs390/nIFTy/62.5_dmSF/outputs/"
#ahf_folder = "/mnt/lustre/scratch/cs390/nIFTy/62.5_dm/outputs/"
firstfile = first1
lastfile = last1
filter = LGalaxyStruct.properties_used
filter['DiskMass'] = True
filter['BulgeMass'] = True
#file_prefix = "SA_z0.00"
(nTrees,nGals,nTreeGals,gal) = read_lgal.readsnap_lgal(folder1,file_prefix,first1,last1,filter)
massf = gadget2msun*gal['DiskMass']+gadget2msun*gal['BulgeMass']
mass = numpy.log10(massf)
stellarmass = pylab.histogram(mass,bins=20,range=(9.0,14.0))
print stellarmass
massftn_y = stellarmass[0]
massftn_x = []
for i in range(len(stellarmass[0])):
massftn_x.append((stellarmass[1][i]+stellarmass[1][i+1])/2.)
delta_logM = massftn_x[1]-massftn_x[0]
pylab.rc('text', usetex=True)
fig = pylab.figure()
ax = fig.add_subplot(111)
ax.plot(massftn_x,massftn_y/boxsize1**3./delta_logM,'r-',label=label1)
firstfile = first2
lastfile = last2
(nTrees,nGals,nTreeGals,gal) = read_lgal.readsnap_lgal(folder2,file_prefix,first2,last2,filter)
massf = gadget2msun*gal['DiskMass']+gadget2msun*gal['BulgeMass']
mass = numpy.log10(massf)
stellarmass = pylab.histogram(mass,bins=20,range=(9.0,14.0))
print stellarmass
massftn_y = stellarmass[0]
massftn_x = []
for i in range(len(stellarmass[0])):
massftn_x.append((stellarmass[1][i]+stellarmass[1][i+1])/2.)
ax.set_xlabel(r"$\log(M_\star/M_\odot$ $h)$")
ax.set_ylabel(r"galaxies$/(Mpc^3 h^{-3})/\Delta \log(M_\star/M_\odot$ $h)$")
ax.plot(massftn_x,massftn_y/boxsize2**3./delta_logM,'b-',label=label2)
print "Stellar mass"
for i in range(len(massftn_x)):
print massftn_x[i],"\t",massftn_y[i]/boxsize**3./delta_logM
ax.set_yscale("log")
ax.legend(loc='upper right',ncol=1, fancybox=True)
#pylab.show()
pylab.savefig('stellar_mass.pdf',bbox_inches='tight')
def _temp_plot_(spk, ax, stim=0, yy=0):
exid = np.where(spk[0] < ne)[0]
inid = np.where(spk[0] >= ne)[0]
htex = pl.histogram(spk[1][exid], bins=sim_time/10, range=(0, sim_time))
htin = pl.histogram(spk[1][inid], bins=sim_time/10, range=(0, sim_time))
hr = pl.histogram(spk[0], bins=n, range=(0, n))
ax.plot(spk[1][exid]*dt, spk[0][exid], 'r.', markersize=mksz, label='Exc: '+ str(np.round(len(exid)/ne)) )
ax.plot(spk[1][inid]*dt, spk[0][inid], 'b.', markersize=mksz, label='Inh: '+str(np.round(len(inid)/ne)) )
ax.set_yticks([0, 99, 199, 299, ne-1, n-1])
ax.set_yticklabels([])
ax.set_ylim(0-10, n+10)
ax.set_xlim([0-10, sim_time+10])
ax.set_xticklabels([])
divider = make_axes_locatable(ax)
axHisty = divider.append_axes("right", size=.5, pad=0.1)
#adjust_spines(axHisty,['left', 'bottom'], outward=0)
axHisty.plot(hr[0]/(Ts), hr[1][0:-1], color='k', lw=2)
if stim == 0:
pl.text(.85, .5, str(np.round(len(exid)/ne / Ts,1)) +' Hz', transform = axHisty.transAxes, color='r')
pl.text(.85, .85, str(np.round(len(inid)/ni /Ts,1))+' Hz', transform = axHisty.transAxes, color='b')
else:
pl.text(.9, .5, str(np.round(len(exid)/ne /Ts,1)) +' Hz', transform = axHisty.transAxes, color='r')
pl.text(.9, .85, str(np.round(len(inid)/ni /Ts,1))+' Hz', transform = axHisty.transAxes, color='b')
axHisty.set_yticks([0, 99, 199, 299, ne-1, n-1])
axHisty.set_yticklabels([])
axHisty.set_xticks([0, 10])
axHisty.set_ylim(0-10, n+10)
axHistx = divider.append_axes("bottom", 1.2, pad=0.3)
#adjust_spines(axHistx,['left', 'bottom'], outward=0)
axHistx.plot(htex[1][0:-1], htex[0], color='r', lw=2, label='Exc')
axHistx.plot(htin[1][0:-1], htin[0], color='b', lw=2, label='Inh')
axHistx.set_yticks([0, 50, 100, 150])
axHistx.set_yticklabels([])
if yy == 1:
axHistx.set_xlabel('Time (ms)')
axHistx.set_ylabel('Population spike count')
axHistx.set_yticklabels([0, 50, 100, 150])
pl.legend(loc=1, frameon=False, prop={'size':12.5})
axHisty.set_xlabel('Firing rate \n (spikes/s)', size=10)
def modelYield(NFert, Irrigation= False, cycles = 10000):
'''Model yield for 10,000 iterations and plot the yield in a histogram.
'''
field1 = hectareCrop(NFert, Irrigation)
iterations = []
while cycles > 0:
iterations.append(field1.cropYield())
cycles -= 1
pylab.histogram(iterations, bins = 40)
pylab.show()
def plot_1d_pdfs(cldata):
grid = cldata['match']['grid']
logpr = grid['fit']
pr = np.exp(-0.5 * logpr)
pr /= pr.sum()
plt.figure(figsize=(15, 4))
plt.subplot(141)
y = np.unique(grid['age'])
dy = get_bins_from_center(y)
n, b = plt.histogram(cldata['match']['grid']['age'], bins=dy, weights=pr)
c = figrc.get_centers_from_bins(b)
p = n * np.diff(b) * c
plt.step(10**c, p / p.sum(), where='mid', color='k', lw=2)
plt.xscale('log')
figrc.hide_axis('top right'.split())
plt.xlabel('age [yr]')
plt.subplot(142)
Y = grid['av']
y = np.unique(Y)
dy = get_bins_from_center(y)
n, b = plt.histogram(Y, bins=dy, weights=pr)
c = figrc.get_centers_from_bins(b)
plt.step(c, n / n.sum(), where='mid', color='k', lw=2)
figrc.hide_axis('top right'.split())
plt.xlabel('Av [mag]')
plt.subplot(143)
Y = grid['z']
y = np.unique(Y)
dy = get_bins_from_center(y)
n, b = plt.histogram(Y, bins=dy, weights=pr)
c = figrc.get_centers_from_bins(b)
plt.step(c, n / n.sum(), where='mid', color='k', lw=2)
figrc.hide_axis('top right'.split())
plt.xlabel(r'Log(Z/Z$_\odot$)')
plt.subplot(144)
Y = grid['mass']
dlogm = 0.1
y = np.unique(Y)
dy = np.arange(dlogm, 6, dlogm)
n, b = plt.histogram(Y, bins=dy, weights=pr)
c = figrc.get_centers_from_bins(b)
p = n * np.diff(b) * c
# plt.step(c, n / n.sum(), where='mid')
plt.step(10**c, p / p.sum(), where='mid', color='k', lw=2)
plt.xscale('log')
figrc.hide_axis('top right'.split())
plt.xlabel(r'Mass [M$_\odot$]')
plt.tight_layout()
def semiLogFracFound(i,o,**pltKwds):
from pylab import histogram,semilogx,loglog
f=i[(o>0) &(i>0)]
l=i[(o<1) &(i>0)]
d=i.sum()
fNorm=f/d
lNorm=l/d
fHist=histogram(fNorm,logspace(-6,-2.0,30))
lHist=histogram(lNorm,logspace(-6,-2.0,30))
semilogx(fHist[1][1:],fHist[0].astype(float)/(fHist[0]+lHist[0]),**pltKwds)
def plot_hists(nus=[143,353],
map1_name=None,
map2_name=None,
maskname='wmap_temperature_kq85_analysis_mask_r10_9yr_v5.fits',
nside=2048,
fwhm=0.0,
bins=100,normed=True,
atol=1e-6, ymin=0.01, ymax=None,
xmin=-0.001, xmax=0.005):
if map1_name is None:
map1_name = 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(nus[0])
label1 = '{} GHz'.format(nus[0])
if map2_name is None:
map2_name = 'HFI_SkyMap_{}_2048_R2.02_full.fits'.format(nus[1])
label2 = '{} GHz'.format(nus[1])
map1 = prepare_map( map1_name, field=0,
maskname=maskname,
nside_out=nside, fwhm=fwhm )
map2 = prepare_map( map2_name, field=0,
maskname=maskname,
nside_out=nside, fwhm=fwhm )
y1,x1 = pl.histogram(map1[np.where(np.negative(np.isclose(map1,0.,atol=atol)))],
bins=bins,normed=normed)
bin1 = (x1[:-1] + x1[1:]) / 2.
y2,x2 = pl.histogram(map2[np.where(np.negative(np.isclose(map2,0.,atol=atol)))],
bins=bins,normed=normed)
bin2 = (x2[:-1] + x2[1:]) / 2.
#return bin1,y1,bin2,y2
fig = plt.figure()
ax = plt.gca()
ax.semilogy(bin1, y1, lw=3, label=label1,color='red')
ax.semilogy(bin2, y2, lw=3, label=label2,color='gray')
ax.set_xlim(xmin=xmin,xmax=xmax)
ax.set_ylim(ymin=ymin, ymax=ymax)
#ax.set_yscale('log')
ax.set_xlabel('$\mu K$', fontsize=20)
ax.set_yticks([])
plt.draw()
plt.legend(frameon=False, fontsize=20)
plt.savefig('pdfs_{}GHz_{}GHz_fwhm{:.3}rad.pdf'.format(nus[0],nus[1],fwhm))
def galaxy_stellar_massftn():
gadget2msun=10.e10
boxsize = 47.0
max_mag=-16.
min_mag = -23.
nbins=14
hubble_h = 0.7
model2_folder = "/mnt/lustre/scratch/cs390/AHF_halos/cubepm_131212_6_1728_47Mpc_ext2/mergertrees/outputs/"
nore_folder = "/mnt/lustre/scratch/cs390/AHF_halos/cubepm_131212_6_1728_47Mpc_ext2/mergertrees/outputs_nore/"
snaplist_file = "/mnt/lustre/scratch/cs390/AHF_halos/cubepm_131212_6_1728_47Mpc_ext2/mergertrees/cubep3m_zlist_out"
observe_folder="/mnt/lustre/scratch/cs390/codes/cubepm_131212_6_1728_47Mpc_ext2/observed_UVL/"
firstfile = 0
lastfile = 215
filter = LGalaxyStruct.properties_used
filter['DiskMass'] = True
filter['BulgeMass'] = True
file_prefix = "SA_z8.06"
(nTrees,nGals,nTreeGals,gal) = read_lgal.readsnap_lgal(model2_folder,file_prefix,firstfile,lastfile,filter)
massf = gadget2msun*gal['DiskMass']+gadget2msun*gal['BulgeMass']
mass = [i for i in massf if i > 10.e6]
mass = numpy.log10(mass)
stellarmass = pylab.histogram(mass)
print stellarmass
massftn_y = stellarmass[0]
massftn_x = []
for i in range(len(stellarmass[0])):
massftn_x.append((stellarmass[1][i]+stellarmass[1][i+1])/2.)
pylab.rc('text', usetex=True)
fig = pylab.figure()
ax = fig.add_subplot(111)
ax.plot(massftn_x,massftn_y,'r-')
file_prefix = "SA_z8.06"
(nTrees,nGals,nTreeGals,gal) = read_lgal.readsnap_lgal(nore_folder,file_prefix,firstfile,lastfile,filter)
massf = gadget2msun*gal['DiskMass']+gadget2msun*gal['BulgeMass']
mass = [i for i in massf if i > 10.e6]
mass = numpy.log10(mass)
stellarmass = pylab.histogram(mass)
print stellarmass
massftn_y = stellarmass[0]
massftn_x = []
for i in range(len(stellarmass[0])):
massftn_x.append((stellarmass[1][i]+stellarmass[1][i+1])/2.)
ax.plot(massftn_x,massftn_y,'b-')
ax.set_yscale("log")
pylab.show()
def semiLogHistLostFound(i,o):
from pylab import histogram,semilogx
f=i[(o>0) &(i>0)]
l=i[(o<1) &(i>0)]
d=i.sum()
fNorm=f/d
lNorm=l/d
fHist=histogram(fNorm,logspace(-6,-2.0,30))
lHist=histogram(lNorm,logspace(-6,-2.0,30))
semilogx(fHist[1][1:],fHist[0],label='out>0')
semilogx(lHist[1][1:],lHist[0],label='out=0')
def spikecorr_tri_conv(filename,
bin=5.,
maxtime=10000.,
start=100.,
path='./'):
data = numpy.loadtxt(path + filename)
data = data[data[:, 0] > start, :]
z1 = pylab.histogram(data[data[:, 1] == 0., 0],
numpy.arange(0, maxtime + 0.1, 0.1))
z2 = pylab.histogram(data[data[:, 1] == 1., 0],
numpy.arange(0, maxtime + 0.1, 0.1))
x1 = miscfunc.tri_convolve(z1[0], bin * 10)
x2 = miscfunc.tri_convolve(z2[0], bin * 10)
cor = miscfunc.corrcoef(x1, x2)
return cor
def old_spike_psth(data, t1_ms=-250., t2_ms=0., bin_ms=10):
"""Uses data format returned by get_spikes"""
spike_time_ms = data['spike times ms']
N_trials = data['trials']
t2_ms = pylab.ceil((t2_ms - t1_ms) / bin_ms) * bin_ms + t1_ms
N_bins = (t2_ms - t1_ms) / bin_ms
if N_trials > 0:
all_spikes_ms = pylab.array([], dtype=float)
for trial in range(len(spike_time_ms)):
if spike_time_ms[trial] is None:
continue
idx = pylab.find((spike_time_ms[trial] >= t1_ms)
& (spike_time_ms[trial] <= t2_ms))
all_spikes_ms = \
pylab.concatenate((all_spikes_ms, spike_time_ms[trial][idx]))
spike_n_bin, bin_edges = \
pylab.histogram(all_spikes_ms, bins = N_bins,
range = (t1_ms, t2_ms), new = True)
spikes_per_trial_in_bin = spike_n_bin / float(N_trials)
spike_rate = 1000 * spikes_per_trial_in_bin / bin_ms
else:
spike_rate = pylab.nan
bin_center_ms = (bin_edges[1:] + bin_edges[:-1]) / 2.0
return spike_rate, bin_center_ms
def logLogRatioFoundLost(i,o,**pltKwds):
from pylab import histogram,semilogx,loglog
f=i[(o>0) &(i>0)]
l=i[(o<1) &(i>0)]
d=i.sum()
fNorm=f/d
lNorm=l/d
fHist=histogram(fNorm,logspace(-6,-2.0,30))
lHist=histogram(lNorm,logspace(-6,-2.0,30))
#semilogx(fHist[1][1:],fHist[0].astype(float)/lHist[0])
loglog(fHist[1][1:],fHist[0].astype(float)/lHist[0],**pltKwds)
def testCollisionsE8(n,d=8):
M = pylab.eye(8,8)
S = [0.0]*n
C = [0]*n
#generate distances and buckets
for i in range(n):
p = [random() for j in xrange(d)]
q = [p[j] + (gauss(0,1)/(d**.5)) for j in xrange(d)]
S[i]=distance(p,q,d)
C[i]= int(decodeE8(dot(p,M)) == decodeE8(dot(q,M)))
ranges = pylab.histogram(S,30)[1]
bucketsCol = [0]*len(ranges)
bucketsDis = [0]*len(ranges)
#fill buckets with counts
for i in xrange(n):
k = len(ranges)-1
while S[i] < ranges[k]:k=k-1
if C[i]:bucketsCol[k]=bucketsCol[k]+1
else:bucketsDis[k] = bucketsDis[k]+1
print bucketsDis
print ranges
pylab.plot(ranges,[float(bucketsCol[i])/(float(bucketsDis[i]+.000000000001)) for i in range(len(ranges))],color='purple')
def plot_trait_distribution(params, trait_matrix, traits):
"""
Plot the time evolution of trait distribution given the params map
containing the experimental parameters, the trait matrix containing
history of traits, and current list of traits.
"""
l = pylab.histogram(traits,
100,
range=(0, params["max_trait"]),
normed=False)[0]
r = []
for bin in l:
trait = bin / (1.0 * params["population"])
r.append(1.0 - trait)
trait_matrix.append(r)
pylab.subplot(121).clear()
pylab.xlabel(r"$x$")
pylab.ylabel(r"$t$")
pylab.imshow(trait_matrix, interpolation = "bilinear",
origin = "l", cmap = cm.gray,
extent = [0, params["max_trait"], 1, \
len(trait_matrix) * params["report_freq"]])
pylab.axis("tight")
ax = pylab.gca()
ax.yaxis.major.formatter.set_powerlimits((0, 0))
pylab.draw()
def spike_make_diagram(ts, gids, name):
pylab.figure()
color_marker = "."
color_bar = "blue"
color_edge = "black"
ylabel = "Neuron ID"
hist_binwidth = 5.0
ax1 = pylab.axes([0.1, 0.3, 0.85, 0.6])
pylab.plot(ts, gids, color_marker)
pylab.ylabel(ylabel)
pylab.xticks([])
xlim = pylab.xlim()
pylab.axes([0.1, 0.1, 0.85, 0.17])
t_bins = numpy.arange(numpy.amin(ts), numpy.amax(ts), hist_binwidth)
n, bins = pylab.histogram(ts, bins=t_bins)
t_bins = t_bins[:-1] # FixMe it must work without cutting the end value
num_neurons = len(numpy.unique(gids))
heights = (1000 * n / (hist_binwidth * num_neurons))
pylab.bar(t_bins, heights, width=hist_binwidth, color=color_bar, edgecolor=color_edge)
pylab.yticks([int(a) for a in numpy.linspace(0.0, int(max(heights) * 1.1) + 5, 4)])
pylab.ylabel("Rate (Hz)")
pylab.xlabel("Time (ms)")
pylab.xlim(xlim)
pylab.axes(ax1)
pylab.title('Spike activity')
pylab.draw()
pylab.savefig(path + name + ".png", dpi=dpi_n, format='png')
pylab.close()
def dcf(X,Y,T,num_bin,noise_std): ''' This function implements the discrete correlation function (DCF) delay estimation method described in Edelson RA, Krolik JH (1988) "The discrete correlation function - A new method for analyzing unevenly sampled variability data." The Astrophysical Journal 333: 646-659. ''' #obtain the delta Ts deltaT=T[:,None]-T[None,:] #iu1 = np.triu_indices(len(T),1) iu1 = np.triu_indices(len(T)) hist, bin_edges=pb.histogram(np.abs(deltaT[iu1]),num_bin) cent=bin_edges[0:len(bin_edges)-1]+np.diff(bin_edges)*.5 dcf=np.zeros(len(cent)) sigx=np.var(X) sigy=np.var(Y) muX=np.mean(X) muY=np.mean(Y) for i in range(0,len(cent)): for j in range(0,len(T)): for k in range(j,len(T)): if i<len(cent)-1: if (np.abs(deltaT[j,k])>=bin_edges[i])&(np.abs(deltaT[j,k])<bin_edges[i+1]): dcf[i]+=((X[j]-muX)*(Y[k]-muY))/np.sqrt((sigx-noise_std**2)*(sigy-noise_std**2)) elif i==len(cent)-1: if (np.abs(deltaT[j,k])>=bin_edges[i])&(np.abs(deltaT[j,k])<=bin_edges[i+1]): dcf[i]+=((X[j]-muX)*(Y[k]-muY))/np.sqrt((sigx-noise_std**2)*(sigy-noise_std**2)) dcf[hist>0]=dcf[hist>0]/hist[hist>0] return cent[np.argmax(dcf)],dcf,cent
def old_spike_psth(data, t1_ms = -250., t2_ms = 0., bin_ms = 10):
"""Uses data format returned by get_spikes"""
spike_time_ms = data['spike times ms']
N_trials = data['trials']
t2_ms = pylab.ceil((t2_ms - t1_ms) / bin_ms)*bin_ms + t1_ms
N_bins = (t2_ms - t1_ms) / bin_ms
if N_trials > 0:
all_spikes_ms = pylab.array([],dtype=float)
for trial in range(len(spike_time_ms)):
if spike_time_ms[trial] is None:
continue
idx = pylab.find((spike_time_ms[trial] >= t1_ms) &
(spike_time_ms[trial] <= t2_ms))
all_spikes_ms = \
pylab.concatenate((all_spikes_ms, spike_time_ms[trial][idx]))
spike_n_bin, bin_edges = \
pylab.histogram(all_spikes_ms, bins = N_bins,
range = (t1_ms, t2_ms), new = True)
spikes_per_trial_in_bin = spike_n_bin/float(N_trials)
spike_rate = 1000*spikes_per_trial_in_bin/bin_ms
else:
spike_rate = pylab.nan
bin_center_ms = (bin_edges[1:] + bin_edges[:-1])/2.0
return spike_rate, bin_center_ms
def testCollisionsE8(n, d=8):
M = pylab.eye(8, 8)
S = [0.0] * n
C = [0] * n
#generate distances and buckets
for i in range(n):
p = [random() for j in xrange(d)]
q = [p[j] + (gauss(0, 1) / (d**.5)) for j in xrange(d)]
S[i] = distance(p, q, d)
C[i] = int(decodeE8(dot(p, M)) == decodeE8(dot(q, M)))
ranges = pylab.histogram(S, 30)[1]
bucketsCol = [0] * len(ranges)
bucketsDis = [0] * len(ranges)
#fill buckets with counts
for i in xrange(n):
k = len(ranges) - 1
while S[i] < ranges[k]:
k = k - 1
if C[i]: bucketsCol[k] = bucketsCol[k] + 1
else: bucketsDis[k] = bucketsDis[k] + 1
print bucketsDis
print ranges
pylab.plot(ranges, [
float(bucketsCol[i]) / (float(bucketsDis[i] + .000000000001))
for i in range(len(ranges))
],
color='purple')
def __make_spikes_diagram(times, gids, name, path):
"""
Draw spike diagram
Description:
Set parameters, include data, draw and save
Args:
times (list): times
gids (list): global IDs of neurons
name (str): name of brain part
path (str): path to save results
"""
global successed
path += "/img"
if not os.path.exists(path):
os.makedirs(path)
pylab.figure()
color_marker = "."
color_bar = "blue"
color_edge = "black"
ylabel = "Neuron ID"
hist_binwidth = 5.0
location = pylab.axes([0.1, 0.3, 0.85, 0.6])
pylab.plot(times, gids, color_marker)
pylab.ylabel(ylabel)
xlim = pylab.xlim()
pylab.xticks([])
pylab.axes([0.1, 0.1, 0.85, 0.17])
t_bins = numpy.arange(numpy.amin(times), numpy.amax(times), hist_binwidth)
if len(t_bins) == 0:
pylab.close()
return "t_bins for {0} is empty".format(name)
n, bins = pylab.histogram(times, bins=t_bins)
num_neurons = len(numpy.unique(gids))
heights = (1000 * n / (hist_binwidth * num_neurons))
# FixMe t_bins[:-1] should work without cutting the end value
pylab.bar(t_bins[:-1],
heights,
width=hist_binwidth,
color=color_bar,
edgecolor=color_edge)
pylab.yticks(
[int(a) for a in numpy.linspace(0.0,
int(max(heights) * 1.1) + 5, 4)])
pylab.ylabel("Rate (Hz)")
pylab.xlabel("Time (ms)")
pylab.grid(True)
pylab.axes(location)
pylab.title(name)
pylab.xlim(xlim)
pylab.draw()
pylab.savefig("{0}/{1}.png".format(path, name), dpi=120, format='png')
pylab.close()
successed += 1
return "OK"
def get_bcc_pz(self,filename_lenscat):
if self.prob_z == None:
# filename_lenscat = os.environ['HOME'] + '/data/BCC/bcc_a1.0b/aardvark_v1.0/lenscats/s2n10cats/aardvarkv1.0_des_lenscat_s2n10.351.fit'
# filename_lenscat = os.environ['HOME'] + '/data/BCC/bcc_a1.0b/aardvark_v1.0/lenscats/s2n10cats/aardvarkv1.0_des_lenscat_s2n10.351.fit'
lenscat = tabletools.loadTable(filename_lenscat)
if 'z' in lenscat.dtype.names:
self.prob_z , _ = pl.histogram(lenscat['z'],bins=self.grid_z_edges,normed=True)
elif 'z-phot' in lenscat.dtype.names:
self.prob_z , _ = pl.histogram(lenscat['z-phot'],bins=self.grid_z_edges,normed=True)
if 'e1' in lenscat.dtype.names:
self.sigma_ell = np.std(lenscat['e1'],ddof=1)
def spikecorr_tri_conv5(filename, bin=5., maxtime=10000., path='./'):
data = numpy.loadtxt(path + filename)
cor5 = []
for j in range(5):
z1 = pylab.histogram(
data[data[:, 1] == 0., 0],
numpy.arange(j * maxtime / 5., (j + 1) * maxtime / 5. + 0.1, 0.1))
z2 = pylab.histogram(
data[data[:, 1] == 1., 0],
numpy.arange(j * maxtime / 5., (j + 1) * maxtime / 5. + 0.1, 0.1))
x1 = miscfunc.tri_convolve(z1[0], bin * 10)
x2 = miscfunc.tri_convolve(z2[0], bin * 10)
cor5.append(miscfunc.corrcoef(x1, x2))
cor = pylab.mean(cor5)
sc = pylab.std(cor5)
return cor, sc
def plot_phases(in_file, plot_type, plot_log):
flags = ['histogram','phases']
plot_flag = 0
log_flag = 0
def no_log(x):
return x
fig = pylab.figure(1)
ax = fig.add_subplot(111)
try:
img = spimage.sp_image_read(in_file,0)
except:
raise IOError("Can't read %s." % in_file)
values = img.image.reshape(pylab.size(img.image))
if plot_log:
log_function = pylab.log
else:
log_function = no_log
if plot_type == PHASES:
hist = pylab.histogram(pylab.angle(values),bins=500)
ax.plot((hist[1][:-1]+hist[1][1:])/2.0,log_function(hist[0]))
elif plot_flag == HISTOGRAM:
hist = pylab.histogram2d(pylab.real(values),pylab.imag(values),bins=500)
ax.imshow(log_function(hist[0]),extent=(hist[2][0],hist[2][-1],-hist[1][-1],-hist[1][0]),interpolation='nearest')
else:
ax.plot(pylab.real(values),pylab.imag(values),'.')
return fig
def plot_phases(in_file, plot_type, plot_log):
plot_flag = 0
def no_log(x):
return x
fig = pylab.figure(1)
ax = fig.add_subplot(111)
try:
img = spimage.sp_image_read(in_file, 0)
except IOError:
raise IOError("Can't read %s." % in_file)
values = img.image.reshape(pylab.size(img.image))
if plot_log:
log_function = pylab.log
else:
log_function = no_log
if plot_type == PHASES:
hist = pylab.histogram(pylab.angle(values), bins=500)
ax.plot((hist[1][:-1] + hist[1][1:]) / 2, log_function(hist[0]))
elif plot_flag == HISTOGRAM:
hist = pylab.histogram2d(pylab.real(values),
pylab.imag(values),
bins=500)
ax.imshow(log_function(hist[0]),
extent=(hist[2][0], hist[2][-1], -hist[1][-1], -hist[1][0]),
interpolation='nearest')
else:
ax.plot(pylab.real(values), pylab.imag(values), '.')
return fig
def simulate_rule(Energies, Nsteps):
Nstates = len(Energies)
statesOverTime = np.zeros(Nsteps)
statesOverTime[0] = np.random.randint(0, Nstates)
for i in np.arange(Nsteps - 1):
currentState = statesOverTime[i].astype(int)
newState = currentState.astype(int)
while newState == currentState:
newState = np.random.randint(0, Nstates)
move = False
move = BoltzmannRule(currentState, newState)
if (move):
statesOverTime[i + 1] = newState
else:
statesOverTime[i + 1] = currentState
bins = np.arange(Nstates + 1) + 0.5
y, dummy = plt.histogram(statesOverTime + 1, bins=bins, normed=True)
plt.bar(np.arange(len(energies)) + 0.9,
y,
width=0.4,
fc='blue',
alpha=0.5,
label='sampledByRule')
return statesOverTime
def hist(x,nbins=100):
vals,bin_edges=pylab.histogram(x,nbins)
bins=(bin_edges[1:]+bin_edges[:-1])/2
dx=bins[1]-bins[0]
vals=1.0*vals/sum(vals)/dx
return bins,vals
def get_bcc_pz(self):
if self.prob_z == None:
filename_lenscat = os.environ['HOME'] + '/data/BCC/bcc_a1.0b/aardvark_v1.0/lenscats/s2n10cats/aardvarkv1.0_des_lenscat_s2n10.351.fit'
lenscat = tabletools.loadTable(filename_lenscat)
self.prob_z , _ = pl.histogram(lenscat['z'],bins=self.grid_z_edges,normed=True)
def getTimeHistogramm(self, color, name): diffs = plt.diff(self.times) ## compute standard histogram y,x = plt.histogram(diffs, bins=plt.linspace(diffs.min(), diffs.max(), 500)) ## notice that len(x) == len(y)+1 ## We are required to use stepMode=True so that PlotCurveItem will interpret this data correctly. curve = pg.PlotCurveItem(x, y, stepMode=True, fillLevel=0, pen=color, brush=color, name=name) return curve
def update_histogram_plt_data(self, histogram_save_data):
self.hist_data = histogram_save_data
bins = (self.Gbins, self.Dbins)
G_breaking = histogram_save_data.get_G_breaking()
D_breaking = histogram_save_data.get_D_breaking()
G_making = histogram_save_data.get_G_making()
break_histogram = pl.histogram(G_breaking, self.Gbins)
make_histogram = pl.histogram(G_making, self.Gbins)
self.histo1D_breaking_sum = self.histo1D_breaking_sum + break_histogram[
0]
self.histo1D_making_sum = self.histo1D_making_sum + make_histogram[0]
break_histogram2D = pl.histogram2d(G_breaking, D_breaking, bins)
self.histo2D_breaking_sum = self.histo2D_breaking_sum + break_histogram2D[
0]
def calculate_activity_histogram(spikes, total_neurons, bin=0.1):
"""Calculates histogram and bins specifically for neurons.
Bins are provided in seconds instead of milliseconds."""
hist, bin_edges = pylab.histogram(
[spike[0] for spike in spikes],
bins=pylab.ceil(max([spike[0] for spike in spikes])/bin))
bin_edges = pylab.delete(bin_edges, len(bin_edges)-1) / 1000.
return [[float(i)/total_neurons for i in hist], bin_edges]
def histeq(im, nbr_bins = 256): """ Histogram equalization of a grayscale image. """ # get image histogram imhist, bins = pl.histogram(im.flatten(), nbr_bins, normed = True) cdf = imhist.cumsum() # cumulative distribution function cdf = 255 * cdf / cdf[-1] # normalize # use linear interpolation of cdf to find new pixel values im2 = pl.interp(im.flatten(), bins[:-1], cdf) return im2.reshape(im.shape)
def fit_gauss(ph):
for i in range(4):
# bepaal de counts en de bingrootte in een range van 0 t/m 1000 ADC
y, bins = histogram(ph[i], bins=500, range=[0, 1000]) # loop for elke plaat
x = (bins[:-1] + bins[1:])/2. #let op neem bins om het midden te vinden van de bin
if y[np.random.random_integers(200, 300)] != 0 : # ter controle of de data van de detector betrouwbaar is, aangezien plaat 4 503 geen goede data bevatte 3-01-2013
# vanwege bartels (2012) kiezen we waar de ADC waarde tussen 150 en 410 zit voor de gauss fit, schat geeft de elementen waar tussen gefit moet worden.
schat = np.where((x > 150) & (x < 600)) # geeft een tweeledig array terug
x1 = x[schat[0]] # geeft de waarde van de elementen gevonden met de determinatie hierboven in het eerste element
#bovenstaande kan ook met x1 = fit_xa[np.where(x>150) & (x< 420)]
y1 = y[schat] # bepaling van de count in de meting
max_min = ndimage.extrema(y1)
max_y = ndimage.extrema(y1)[1] #maximale count y waarde piek van de gauss!)
min_x = max_min[0] # de laagste waarde van de count
max_x = max_min[1] # hoogste waarde van de count -> a waarde in de gauss fit
b_temp = max_min[3]
b_place = b_temp[0] # b waarde
b = x1[b_place] # de b-waarde van de gauss curve
bound1 = max_x - (max_x - min_x)*0.75
if (max_x- min_x) <= 50:
bound2 = max_x + (max_x - min_x)*1.5
else:
bound2 = max_x + (max_x - min_x)
x2 = x1.compress((bound1 <= x1) & (x1 < bound2))
y2 = y1.compress((bound1 <= x1) & (x1 < bound2))
#popt, pcov = curve_fit(func1, x1, y1, [200, 250, 50] ) # werkende fit met een handmatige guess kleine verschillen. orde van 0.2
popt, pcov = curve_fit(func1, x1, y1, [max_x, b, 20] ) # fit met guess gebruikt werkt ook
pylab.plot(func1(range(0,600), *popt), '--')
peak = popt[1]
if i == 0:
MIP1 = peak
MPV1.append(MIP1) #bij herhalen van de loop oor ander station append deze regel op de juiste manier?
elif i == 1:
MIP2 = peak
MPV2.append(MIP2)
elif i == 2:
MIP3 = peak
MPV3.append(MIP3)
elif i == 3:
MIP4 = peak
MPV4.append(MIP4)
print 'The MPV of detector',i + 1, 'lies at', peak, 'ADC'
else:
print 'The data of the detector ',i + 1, 'could not be fitted to a gauss curve'
def SPOC_hist(self, deltacr=0.5, cat=[0,0.1,1/3.,0.5,2/3.,0.9,1], cat_percent=True, crpol=False, return_val=False):
"Draws an histogram for planet visibility"
if not ((hasattr(self,'cr') or hasattr(self,'cr_rel')) and (hasattr(self,'sep') or hasattr(self,'sep_rel'))):
print "Contrast ratio or Separation is unknown, cannot process SPOC diagram."
return
if crpol and not hasattr(self,'pol'):
print "No polarization output available, switching to intensity contrast ratio."
color = ['w','#FFDD78','#7878FF','#D26E23','#AAFCED','k']
hatch = ['','','','/','/']
coloredge = ['k','k','k','k','k']
pTimeMarkers=c_planet(fr=np.linspace(0,1,1001)[:-1], t=getattr(self,'t',None), a=getattr(self,'a',None), e=getattr(self,'e',None), i=getattr(self,'i',None), w=getattr(self,'w',None), tperi=getattr(self,'tperi',None), distance=getattr(self,'distance',None), radius=getattr(self,'radius',None), albedo_scat=getattr(self,'albedo_scat',None), albedo_geo=getattr(self,'albedo_geo',None), o=getattr(self,'o',None))
pTimeMarkers.compute(silent=True)
cat=np.sort(cat)[::-1]
sep = getattr(self,'sep',0)+getattr(self,'sep_rel',0)
if crpol:
cr = np.log10(getattr(self,'crpol',0)+getattr(self,'crpol_rel',0))
xlabel='Polarized contrast ratio [log10]'
else:
cr = np.log10(getattr(self,'cr',0)+getattr(self,'cr_rel',0))
xlabel='Contrast ratio [log10]'
sepmax = sep.max()*cat_percent+1*(not cat_percent)
if cat[0]<sep.max(): cat = np.r_[sep.max(),cat] ###
if cat[-1]>sep.min(): cat = np.r_[cat,0] ###
bins = np.linspace(np.floor(cr.min()/deltacr)*deltacr, np.ceil(cr.max()/deltacr)*deltacr, np.ceil(cr.max()/deltacr)-np.floor(cr.min()/deltacr)+1)
norma = 100./cr.size
bottom = np.zeros(bins.size-1)
fig = plt.figure()
values=[]
for i in range(cat.size):
hh = cr[sep/sepmax>cat[i]]
if return_val: values.append(plt.histogram(hh, bins=bins)[0]*norma)
if hh.size!=0:
a = plt.histogram(hh, bins=bins)[0]
p = plt.bar((bins[:-1]+deltacr/2.)[a>0], a[a>0]*norma, deltacr/2., hatch=hatch[(i-1)%np.size(hatch)], color=color[(i-1)%np.size(color)], edgecolor=coloredge[(i-1)%np.size(coloredge)], bottom=bottom[a>0], label=str(round(cat[i]*sepmax,3)) + "-" + str(round(cat[i-1]*sepmax,3)))
bottom = bottom+a*norma
cr = cr[sep/sepmax<=cat[i]]
sep = sep[sep/sepmax<=cat[i]]
plt.xticks(bins+deltacr/4., np.round(bins,3))
plt.legend(title="Separation in [arcsec]", loc=0, fancybox=True, shadow=True, prop={'size':12})
plt.xlabel(xlabel)
plt.ylabel('Duration [% of Period]')
plt.show()
if return_val: return bins[:-1]+deltacr/2., cat*sepmax, values
def make_scatter_inputs(yvals, xvals,therange, nbins=10):
if len(yvals) != len(xvals):
print len(yvals), ' doeas not equal ',len(xvals)
vals, thebins = pylab.histogram(xvals, weights=yvals, bins=nbins,range=therange)
vals_sq, thebins = pylab.histogram(xvals, weights=yvals*yvals, bins=nbins ,range=therange)
vals_n, thebins = pylab.histogram(xvals, bins=nbins,range=therange)
val_errs = numpy.sqrt((vals_sq/vals_n) - (vals/vals_n)*(vals/vals_n))/numpy.sqrt(vals_n)
bincenters=[]
binerrs=[]
# print 'The Bins = ', thebins
for k in range(len(thebins)-1):
bincenters.append((thebins[k]+thebins[k+1])/2.)
binerrs.append((thebins[k+1]-thebins[k])/2.)
# print 'bincenters = ',bincenters
return bincenters, vals/vals_n, binerrs, val_errs
def plotpdf(self,x=None,xmin=None,alpha=None,nbins=50,dolog=True,dnds=False,
drawstyle='steps-post', histcolor='k', plcolor='r', **kwargs):
"""
Plots PDF and powerlaw.
kwargs is passed to pylab.hist and pylab.plot
"""
if not(x): x=self.data
if not(xmin): xmin=self._xmin
if not(alpha): alpha=self._alpha
x=numpy.sort(x)
n=len(x)
pylab.gca().set_xscale('log')
pylab.gca().set_yscale('log')
if dnds:
hb = pylab.histogram(x,bins=numpy.logspace(log10(min(x)),log10(max(x)),nbins))
h = hb[0]
b = hb[1]
db = hb[1][1:]-hb[1][:-1]
h = h/db
pylab.plot(b[:-1],h,drawstyle=drawstyle,color=histcolor,**kwargs)
#alpha -= 1
elif dolog:
hb = pylab.hist(x,bins=numpy.logspace(log10(min(x)),log10(max(x)),nbins),log=True,fill=False,edgecolor=histcolor,**kwargs)
alpha -= 1
h,b=hb[0],hb[1]
else:
hb = pylab.hist(x,bins=numpy.linspace((min(x)),(max(x)),nbins),fill=False,edgecolor=histcolor,**kwargs)
h,b=hb[0],hb[1]
# plotting points are at the center of each bin
b = (b[1:]+b[:-1])/2.0
q = x[x>=xmin]
px = (alpha-1)/xmin * (q/xmin)**(-alpha)
# Normalize by the median ratio between the histogram and the power-law
# The normalization is semi-arbitrary; an average is probably just as valid
plotloc = (b>xmin)*(h>0)
norm = numpy.median( h[plotloc] / ((alpha-1)/xmin * (b[plotloc]/xmin)**(-alpha)) )
px = px*norm
plotx = pylab.linspace(q.min(),q.max(),1000)
ploty = (alpha-1)/xmin * (plotx/xmin)**(-alpha) * norm
#pylab.loglog(q,px,'r',**kwargs)
pylab.loglog(plotx,ploty,color=plcolor,**kwargs)
axlims = pylab.axis()
pylab.vlines(xmin,axlims[2],max(px),colors=plcolor,linestyle='dashed')
pylab.gca().set_xlim(min(x),max(x))
def get_kl(x):
snr = np.sqrt(arr_normsq*(x**2)) / noise_std
h_sim, b_sim = pl.histogram(snr,bins=plotstools.get_bins_edges(b_des[b_des>min_snr_to_use],constant_spacing=True),normed=True)
h_sim = h_sim/sum(h_sim)
h_des_use = h_des[b_des>min_snr_to_use]
KL_divergence = -sum( h_des_use * np.log(h_sim) ) + sum( h_des_use * np.log(h_des_use) )
print 'KL_divergence=' , KL_divergence , 'scale=' , x
return KL_divergence
def histeq(im, numbins=256):
""" Histogram equalization of grayscale image. """
# Get image histogram
hist, bins = plt.histogram(im.flatten(), numbins, normed=True)
cdf = hist.cumsum() # Cumulative distribution function
cdf = 255 * cdf / cdf[-1]
# User linear interpolation of cdf to find new pixel values
im2 = np.interp(im.flatten(), bins[:-1], cdf)
return im2.reshape(im.shape), cdf
def testCollisionPr(n, d=24):
M = [
array([[gauss(0, 1) / (24**.5) for a in range(24)] for b in range(d)])
for k in range(4)
]
#M =[eye(24)]#[array([[gauss(0,1)/(24**.5) for a in range(24)] for b in range(d)])]
S = [0.0] * n
C = [0] * n
print "data generated"
#generate distances and buckets
i = 0
while i < n:
p = array([(random()) for j in xrange(d)])
q = array([p[j] + (gaussInv(3.0, 1) / (d**.5)) for j in xrange(d)])
#q =array( [p[j] + (gauss(0.0,1.0)/(d**.5)) for j in xrange(d)])
#q =array( [p[j] + (( random() -.5)/(d**.5)) for j in xrange(d)])
S[i] = distance(p, q, d)
j = 0
m = 2
while j < len(M) / m:
C[i] = C[i] or decodeGt24(p, M[j * m:(j + 1) * m], 0.0,
1.0) == decodeGt24(
q, M[j * m:(j + 1) * m], -0.0, 1.0)
j = j + 1
i = i + 1
ranges = histogram(S, 25)[1]
bucketsCol = [0] * len(ranges)
bucketsDis = [0] * len(ranges)
#fill buckets with counts
for i in xrange(n):
k = len(ranges) - 1
while S[i] < ranges[k]:
k = k - 1
if C[i]: bucketsCol[k] = bucketsCol[k] + 1
bucketsDis[k] = bucketsDis[k] + 1
print bucketsDis + bucketsCol
print ranges
p = [0] * len(ranges)
for m in range(len(ranges)):
if bucketsDis[m] > 0:
p[m] = bucketsCol[m] / float(bucketsDis[m])
plot(ranges, p)
def simulate_rule(stateEnergies, Nsteps):
# set physical constants
k = 8.6e-5
T = 100.0
# check how many states were provided
Nstates = len(stateEnergies)
# Create an array to show were we were (which states we were in)
# throughout the simulation
statesOverTime = np.zeros(Nsteps)
# Make the first state random by using the randint()-function
statesOverTime[0] = np.random.randint(0, Nstates)
# Now perform the simulation, by looping thourhg all the steps
for i in np.arange(Nsteps - 1):
# Randomize a new state until we get one which is
# different from the one we are allready in
currentState = statesOverTime[i].astype(int)
newState = currentState.astype(int)
while newState == currentState:
newState = np.random.randint(0, Nstates)
# Make a random number between 0 and 1
chance = np.random.rand()
#should we move?
move = False
#move=PrimeRule(newState)
move = BoltzmannRule(stateEnergies[currentState],
stateEnergies[newState], k, T)
if (move):
# move to the proposed state
statesOverTime[i + 1] = newState
else:
# set the next state to be the same as the current
statesOverTime[i + 1] = currentState
# Let's plot the resulting disitrbution in blue
bins = np.arange(Nstates + 1) + 0.5
y, dummy = plt.histogram(statesOverTime + 1, bins=bins, normed=True)
plt.bar(np.arange(len(energies)) + 0.9,
y,
width=0.4,
fc='blue',
alpha=0.5,
label='sampledByRule')
# Let's also return the array so that we can plot more things if we want to
return statesOverTime
def histeq(img, nb_bins=256):
""" Histogram equalization of a grayscale image."""
# get image histogram
img_hist, bins = pl.histogram(img.flatten(), nb_bins, normed=True)
cdf = img_hist.cumsum() # cumulative distribution function
cdf = 255 * cdf / cdf[-1] # normalize
# use linear interpolation of cdf to find new pixel values
img2 = pl.interp(img.flatten(), bins[:-1], cdf)
return img2.reshape(img.shape), cdf
def sizeHistogram(self, plot=True):
'''
Simplifies the procss of displaying histograms of payload sizes. This is a useful way to classify packets.
If plot = True, it will display the histogram, else it will return the tuple ( counts, bins ).
If you want finer grained control just import pylab as pl and get cracking!
'''
if plot:
pl.hist(self.size())
pl.show()
else:
return pl.histogram(self.size())
def draw_line_hist(data,bins=20,linewidth=3,color=None,normed=False,fig=1):
'''draws an outline histogram, returns values,bins
'''
pylab.figure(fig)
values,bins = pylab.histogram(data,bins=bins,new=True,normed=normed)
if color:
pylab.plot(bins[:-1],values,color,drawstyle='steps-post',linewidth=linewidth)
else:
pylab.plot(bins[:-1],values,drawstyle='steps-post',linewidth=linewidth)
return values,bins
def plot_layer_histogram(self, layer_name, filename):
""" Draw a plot of the given layer.
"""
layer = self._get_layer_securely(layer_name)
# Calculate the histogram:
histogram, bin_edges = pylab.histogram(layer, 50, normed=True)
# Make a plot based on the histogram:
pylab.plot(histogram)
pylab.grid(True)
pylab.title(layer_name.capitalize() + ' layer histogram plot.')
pylab.savefig(filename)
def plot_layer_histogram(self, layer_name, filename):
""" Draw a plot of the given layer.
"""
layer = self._get_layer_securely(layer_name)
# Calculate the histogram:
histogram, bin_edges = pylab.histogram(layer, 50, normed=True)
# Make a plot based on the histogram:
pylab.plot(histogram)
pylab.grid(True)
pylab.title(layer_name.capitalize() + ' layer histogram plot.')
pylab.savefig(filename)
def equalize(image, bins=256):
''' Given an image, equalize it based on the generated
histogram so all the intensities are balanced.
:param image: The image to equalize
:param bins: The number of bins for the histogram
:returns: The equalized image
'''
im_hist, bins = pl.histogram(image.flatten(), bins, normed=True)
cdf = im_hist.cumsum() # cumulative distribution function
cdf = 255 * cdf / cdf[-1] # normalize
im_norm = pl.interp(image.flatten(), bins[:-1], cdf) # linear interpolate new pixel values
return im_norm.reshape(image.shape) # restore to the correct shape
def get_kl_sigma(sigma):
snr = np.sqrt(arr_normsq) / sigma
h_sim, b_sim = pl.histogram(snr,bins=plotstools.get_bins_edges(b_des[b_des>min_snr_to_use],constant_spacing=True),normed=True)
h_sim = h_sim/sum(h_sim)
# pl.plot(b_des,h_sim)
# pl.show()
h_des_use = h_des[b_des>min_snr_to_use]
KL_divergence = -sum( h_des_use * np.log(h_sim) ) + sum( h_des_use * np.log(h_des_use) )
print 'KL_divergence=' , KL_divergence , 'sigma=' , sigma
return KL_divergence
def spike_make_diagram(ts, gids, name, title, hist):
pylab.figure()
color_marker = "."
color_bar = "blue"
color_edge = "black"
ylabel = "Neuron ID"
if hist == "True":
#TODO this part doesn't work! Trying to fix
hist_binwidth = 5.0
ts1 = ts
neurons = gids
ax1 = pylab.axes([0.1, 0.3, 0.85, 0.6])
pylab.plot(ts1, gids, color_marker)
pylab.ylabel(ylabel)
pylab.xticks([])
xlim = pylab.xlim()
pylab.axes([0.1, 0.1, 0.85, 0.17])
t_bins = numpy.arange(numpy.amin(ts), numpy.amax(ts), hist_binwidth)
n, bins = pylab.histogram(ts, bins=t_bins)
num_neurons = len(numpy.unique(neurons))
print "num_neurons " + str(num_neurons)
heights = 1000 * n / (hist_binwidth * num_neurons)
print "t_bins " + str(len(t_bins)) + "\n" + str(t_bins) + "\n" + \
"height " + str(len(heights)) + "\n" + str(heights) + "\n"
#bar(left,height, width=0.8, bottom=None, hold=None, **kwargs):
pylab.bar(t_bins,
heights,
width=hist_binwidth,
color=color_bar,
edgecolor=color_edge)
pylab.yticks([
int(a) for a in numpy.linspace(0.0,
int(max(heights) * 1.1) + 5, 4)
])
pylab.ylabel("Rate (Hz)")
pylab.xlabel("Time (ms)")
pylab.xlim(xlim)
pylab.axes(ax1)
else:
pylab.plot(ts, gids, color_marker)
pylab.xlabel("Time (ms)")
pylab.ylabel(ylabel)
pylab.title(title)
pylab.draw()
pylab.savefig(path + name + ".png", dpi=dpi_n, format='png')
pylab.close()
def plotpdf(x=None,xmin=None,alpha=None,nbins=50,dolog=True,dnds=False,**kwargs):
"""
Plots PDF and powerlaw.
"""
#if not(x): x=self.data
#if not(xmin): xmin=self._xmin
#if not(alpha): alpha=self._alpha
import numpy,pylab
import numpy.random as npr
from numpy import log,log10,sum,argmin,argmax,exp,min,max
x=numpy.sort(x)
n=len(x)
pylab.gca().set_xscale('log')
pylab.gca().set_yscale('log')
if dnds:
hb = pylab.histogram(x,bins=numpy.logspace(log10(min(x)),log10(max(x)),nbins))
h = hb[0]
b = hb[1]
db = hb[1][1:]-hb[1][:-1]
h = h/db
pylab.plot(b[:-1],h,drawstyle='steps-post',color='k',**kwargs)
#alpha -= 1
elif dolog:
hb = pylab.hist(x,bins=numpy.logspace(log10(min(x)),log10(max(x)),nbins),log=True,fill=False,edgecolor='k',**kwargs)
alpha -= 1
h,b=hb[0],hb[1]
pylab.hold(False)
pylab.loglog(b[1:],h,'o',mfc="None",mec='blue')
pylab.hold(True)
else:
hb = pylab.hist(x,bins=numpy.linspace((min(x)),(max(x)),nbins),fill=False,edgecolor='k',**kwargs)
h,b=hb[0],hb[1]
b = b[1:]
q = x[x>=xmin]
px = (alpha-1)/xmin * (q/xmin)**(-alpha)
arg = argmin(abs(b-xmin))
plotloc = (b>xmin)*(h>0)
norm = numpy.median( h[plotloc] / ((alpha-1)/xmin * (b[plotloc]/xmin)**(-alpha)) )
px = px*norm
pylab.loglog(q,px,'r',label=('$x_{min}=%.1f$, $\\alpha=%.2f$'%(xmin,alpha)),**kwargs)
pylab.legend()
#pylab.vlines(xmin,0.1,max(px),colors='r',linestyle='dashed')
pylab.gca().set_xlim(min(x),max(x))
def fitgauss(hulp, station, verschil):
y, bins = histogram(hulp, bins=np.arange(-41.25e-9, 41.25e-9, 2.5e-9), range=[-40e-9, 40e-9])
x = (bins[:-1] + bins[1:])/2.
N = max(y)
f = lambda x, N, mu, sigma: N * scipy.stats.norm.pdf(x, mu, sigma)
popt, pcov = curve_fit(gauss, x, y, [N * 1e-9, 0., 1e-9])
xx = linspace(min(x), max(x), 1000)
versch = popt[1]
waarden = 1e9*versch
print 'van station %d en verschil %s' %(station, verschil)
print 'de verschuiving is %f'% waarden
print 80*'-'
def isi_histogram(timestamps,
start_time=0,
zero_times=0,
end_time=None,
window_len=1,
range=.2,
nbins=11):
"""Given the time stamps compute the isi histogram with a jumping window.
Inputs:
timestamps - the spike timestamps
start_time - time rel to zero_time we end our windows (needs to be <= 0).
If zero, means no pre windows.
If None, means prewindows stretch to begining of data
The start_time is extended to include an integer number of windows
zero_times - reference time. Can be a zx1 array, in which case will give us an array of windows. If scalar
will only give one set of windows.
end_time - time rel to zero_time we end our windows (needs to >= 0)
If zero, means no post-windows
If None, means post-windows stretch to end of data
The end_time is extended to include an integer number of windows
window_len - length of window to look at isi (in same units as time stamps)
range - maximum isi
nbins - number of bins in the histogram
Outputs:
t - time vector
be - bin edges
isihist - the histogram matrix. Normalized for each time slice
(Can be plotted by doing pylab.pcolor(t, be, isihist.T,vmin=0,vmax=1, cmap=pylab.cm.gray_r))
"""
window_edges, windows, subwindows = window_spike_train(
timestamps, start_time, zero_times, end_time, window_len=window_len)
isi = pylab.diff(timestamps)
if windows.shape[1]:
windows[:, -1, 1] -= 1 #we have one less isi sample than timestamps
bins = pylab.linspace(0, range, nbins + 1) #We are doing bin edges
isihist = pylab.zeros((windows.shape[1], nbins))
for m in xrange(windows.shape[0]):
for n in xrange(windows.shape[1]):
hist, be = pylab.histogram(isi[windows[m, n, 0]:windows[m, n, 1]],
bins,
density=True)
isihist[n, :] += hist
t = (window_edges[1:] + window_edges[:-1]) / 2
return t, be, isihist / windows.shape[0]
def Histeq(img, nbr_bins=256):
"""
图像直方图均衡化
:param img: 图像
:param nbr_bins:像素值范围[0~255]
:return:均衡化直方图后的图像
"""
# 获取直方图p(r)
imhist, bins = pl.histogram(img.flatten(), nbr_bins, normed=True)
# 获取T(r)
cdf = imhist.cumsum() # cumulative distribution function
cdf = 255 * cdf / cdf[-1]
# 获取s，并用s替换原始图像对应的灰度值
result = pl.interp(img.flatten(), bins[:-1], cdf)
return result.reshape(img.shape)
def testCollisionsE8(n, d=24):
M = [
array([[gauss(0, 1) / (24**.5) for a in range(24)] for b in range(d)])
for k in range(12)
]
S = [0.0] * n
C = [0] * n
#generate distances and buckets
i = 0
while i < n:
p = [random() for j in xrange(d)]
q = [p[j] + (gauss(0, 1) / (d**.5)) for j in xrange(d)]
S[i] = distance(p, q, d)
j = 0
m = 3
while j < len(M) / m:
C[i] = C[i] or decodeE8gt8(p, M[j * m:(j + 1) * m], 0.0,
1.0) == decodeE8gt8(
q, M[j * m:(j + 1) * m], 0.0, 1.0)
j = j + 1
i = i + 1
ranges = histogram(S, 25)[1]
bucketsCol = [0] * len(ranges)
bucketsDis = [0] * len(ranges)
#fill buckets with counts
for i in xrange(n):
k = len(ranges) - 1
while S[i] < ranges[k]:
k = k - 1
if C[i]: bucketsCol[k] = bucketsCol[k] + 1
bucketsDis[k] = bucketsDis[k] + 1
print bucketsDis
print bucketsCol
print ranges
p = [0] * len(ranges)
for m in range(len(ranges)):
if bucketsDis[m] > 0:
p[m] = bucketsCol[m] / float(bucketsDis[m])
plot(ranges, p)
def histeq(im, nb_bins=256):
"""
This function equalises the histogram of im (numpy array), distributing
the pixels accross nbr_bins bins.
Returns the equalised image as a numpy array (same shape as input).
Largely copied from https://stackoverflow.com/a/28520445
(author: Trilarion, 17/07/2017)
"""
# get image histogram
imhist, bins = pl.histogram(im.flatten(), nb_bins, normed=True)
cdf = imhist.cumsum() #cumulative distribution function
cdf = 65535 * cdf / cdf[-1] #normalize
# use linear interpolation of cdf to find new pixel values
im2 = pl.interp(im.flatten(), bins[:-1], cdf)
return im2.reshape(im.shape)
def test_histogram1d(self):
h = histogram.Histogram1DFast(10, 0, 10)
self.assertTrue((np.abs(h.bin_edges - np.arange(11)) < 1.0e-12).all())
x = np.array([-1.0, 0.5, 3.2, 0.77, 9.99, 10.1, 8.2])
h.update(x)
xc = np.array([1.5, 2.5, 8.3])
cc = np.array([10, 5, 22])
h.update_counts(xc, cc)
self.assertTrue(
(h.bin_count == np.array([3, 10, 5, 1, 0, 0, 0, 0, 23, 2])).all())
# check compute_indices
self.assertTrue((h.compute_indices(np.arange(12) - 0.5) == np.array(
[0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9])).all())
# benchmark
x = np.random.randn(1e7)
time1 = time.time()
h = histogram.Histogram1DFast(100, -5, 5)
h.update(x)
time2 = time.time()
out = np.histogram(x, bins=100, range=[-5, 5])
time3 = time.time()
print "Time for fast = " + str(time2 - time1) + " s"
print "Time for numpy = " + str(time3 - time2) + " s"
# check sampler
t1 = time.time()
samples = h.sample(3e6)
t2 = time.time()
print "Time to sample 1D for 3e6 = " + str(t2 - t1) + " s"
# TODO: replace this "eye norm" with an actual norm
(counts, edges) = plt.histogram(samples, 50, normed=True)
centers = 0.5 * (edges[1:] + edges[0:-1])
actual_pdf = 1.0 / np.sqrt(2.0 * 3.14159) * np.exp(-centers**2 / 2.0)
fig = plt.figure(1)
fig.clf()
plt.plot(centers, counts, label="Sample")
plt.plot(centers, actual_pdf, label="Actual")
plt.legend()
fig.show()
