def compareTwoUsers(data1, data2, outdir):
"""Compares data for two users. Currently plots difference in peaks for
the users on presslengths for different keycodes."""
def computePeakDifference(d1, d2):
edges = findCommonEdges(d1, d2)
h1, e = np.histogram(d1, bins=edges, normed=True)
h2, e = np.histogram(d2, bins=edges, normed=True)
a1, a2 = np.argmax(h1), np.argmax(h2)
diff = (edges[a1] + edges[a1 + 1] - edges[a2] - edges[a2 + 1]) / 2.0
return diff
commonKeys = set(data1.keystrokePLs_key.keys()) & set(data2.keystrokePLs_key.keys())
peakDiffs = []
for key in commonKeys:
dat1 = data1.keystrokePLs_key[key]
dat2 = data2.keystrokePLs_key[key]
peakDiffs.append(computePeakDifference(dat1, dat2))
peakDiffs.append(computePeakDifference(data1.keystrokePLs, data2.keystrokePLs))
edges = findCommonEdges(peakDiffs)
plt.figure()
plt.hist(peakDiffs, bins=edges)
plt.title("Peak Differences for Keystroke PL for %s and %s" % (data1.user, data2.user))
plt.xlabel("Time (seconds)")
plt.savefig("%s/%s_%s_kPLpeakDiff.pdf" % (outdir, data1.user, data2.user))
plt.close()
def plot_field(self,x,y,u=None,v=None,F=None,contour=False,outdir=None,plot='quiver',figname='_field',format='eps'):
outdir = self.set_dir(outdir)
p = 64
if F is None: F=self.calc_F(u,v)
plt.close('all')
plt.figure()
#fig, axes = plt.subplots(nrows=1)
if contour:
plt.hold(True)
plt.contourf(x,y,F)
if plot=='quiver':
plt.quiver(x[::p],y[::p],u[::p],v[::p],scale=0.1)
if plot=='pcolor':
plt.pcolormesh(x[::4],y[::4],F[::4],cmap=plt.cm.Pastel1)
plt.colorbar()
if plot=='stream':
speed = F[::16]
plt.streamplot(x[::16], y[::16], u[::16], v[::16], density=(1,1),color='k')
plt.xlabel('$x$ (a.u.)')
plt.ylabel('$y$ (a.u.)')
plt.savefig(os.path.join(outdir,figname+'.'+format),format=format,dpi=320,bbox_inches='tight')
plt.close()
def plot_feat_hist(data_name_list, filename=None):
if len(data_name_list)>1:
assert filename is not None
pylab.figure(num=None, figsize=(8, 6))
num_rows = 1 + (len(data_name_list) - 1) / 2
num_cols = 1 if len(data_name_list) == 1 else 2
pylab.figure(figsize=(5 * num_cols, 4 * num_rows))
for i in range(num_rows):
for j in range(num_cols):
pylab.subplot(num_rows, num_cols, 1 + i * num_cols + j)
x, name = data_name_list[i * num_cols + j]
pylab.title(name)
pylab.xlabel('Value')
pylab.ylabel('Fraction')
# the histogram of the data
max_val = np.max(x)
if max_val <= 1.0:
bins = 50
elif max_val > 50:
bins = 50
else:
bins = max_val
n, bins, patches = pylab.hist(
x, bins=bins, normed=1, facecolor='blue', alpha=0.75)
pylab.grid(True)
if not filename:
filename = "feat_hist_%s.png" % name.replace(" ", "_")
pylab.savefig(os.path.join(CHART_DIR, filename), bbox_inches="tight")
def plot_experiment_stats(e):
sample_data = np.where(e.num_test_genotypes(SAMPLE) > 0)[0]
c_sample = (100.0 * e.called(SAMPLE)[sample_data]) / e.num_test_genotypes(SAMPLE)[sample_data] + 1e-15
fill = 100.*e.fill[sample_data]
snp_data = np.where(e.num_test_genotypes(SNP) > 0)[0]
c_snp = (100.0 * e.called(SNP)[snp_data]) / e.num_test_genotypes(SNP)[snp_data]
# Call % vs. fill %
P.figure(1);
P.clf();
P.plot(fill, c_sample, 'o')
P.xlabel('Fill %')
P.ylabel('Call %')
P.title('Validation Breakdown by Sample, %.2f%% Deleted. r = %.2f' %
(100.0 * e.fraction, np.corrcoef(fill + SMALL_FLOAT, c_sample + SMALL_FLOAT)[0, 1],))
# Call % vs. SNP
P.figure(2);
P.clf();
P.plot(snp_data, c_snp, 'o')
P.xlabel('SNP #')
P.ylabel('Call %')
P.title('Validation Breakdown by SNP, %.2f%% Deleted' % (100.0 * e.fraction,))
return (np.array([snp_data, c_snp]).transpose(),
np.array([sample_data, c_sample, fill]).transpose())
def analyze_categorical_feature(self, data_frame, feature_name):
data = FeatureAnalyzer.convert_into_one_hot_representation(data_frame, feature_name)
data.is_copy = False
data['label'] = data['label'].astype(int).apply(lambda x: 0 if x == -1 else 1)
result_dict = {'category': [], 'correlation': [], 'abs_correlation': [], 'fraction': [], 'rate': []}
for key in data.keys():
if key != 'label':
result_dict['category'].append(key)
key_data = data[['label', key]][data[key] == 1]
num_engagements = len(key_data[key_data['label'] == 1])
if len(key_data) > 0:
result_dict['correlation'].append(data[[key, 'label']].corr().values[0, 1])
result_dict['abs_correlation'].append(abs(result_dict['correlation'][-1]))
result_dict['fraction'].append(len(key_data)/float(len(data)))
result_dict['rate'].append(num_engagements/float(len(key_data)))
else:
result_dict['correlation'].append(0.0)
result_dict['abs_correlation'].append(0.0)
result_dict['fraction'].append(0.0)
result_dict['rate'].append(0.0)
plt.figure()
result = pandas.DataFrame(data=result_dict).sort(columns='abs_correlation', ascending=False)
fig = result.plot(x='category', y=['correlation', 'fraction', 'rate'], kind='bar', stacked=True, figsize=(len(data)/200, 10)).get_figure()
fig.set_tight_layout(True)
png_path = 'Data/' + self.experiment_name + '_' + feature_name + '.png'
fig.savefig(png_path, dpi=fig.dpi)
def ROC(self, x):
"""
ROC curve for seperating positive Gamma distribution
from two other modes, predicted by current parameter values
-x: vector of observations
Output: P
P[0]: False positive rates
P[1]: True positive rates
"""
import matplotlib.pylab as mp
p = len(x)
P = np.zeros((2,p))
#False positives
P[0] = (self.mixt[0]*st.gamma.cdf(-x,self.shape_n,scale=self.scale_n)
+ self.mixt[1]*st.norm.sf(x,0,np.sqrt(self.var)))/\
(self.mixt[0] + self.mixt[1])
#True positives
P[1] = st.gamma.sf(x,self.shape_p,scale=self.scale_p)
mp.figure()
I = P[0].argsort()
mp.plot(P[0,I],P[0,I],'r-')
mp.plot(P[0,I],P[1,I],'g-')
mp.legend(('False positive rate','True positive rate'))
return P
def make_corr1d_fig(dosave=False):
corr = make_corr_both_hemi()
lw=2; fs=16
pl.figure(1)#, figsize=(8, 7))
pl.clf()
pl.xlim(4,300)
pl.ylim(-400,+500)
lambda_titles = [r'$20 < \lambda < 30$',
r'$30 < \lambda < 40$',
r'$\lambda > 40$']
colors = ['blue','green','red']
for i in range(3):
corr1d, rcen = corr_1d_from_2d(corr[i])
ipdb.set_trace()
pl.semilogx(rcen, corr1d*rcen**2, lw=lw, color=colors[i])
#pl.semilogx(rcen, corr1d*rcen**2, 'o', lw=lw, color=colors[i])
pl.xlabel(r'$s (Mpc)$',fontsize=fs)
pl.ylabel(r'$s^2 \xi_0(s)$', fontsize=fs)
pl.legend(lambda_titles, 'lower left', fontsize=fs+3)
pl.plot([.1,10000],[0,0],'k--')
s_bao = 149.28
pl.plot([s_bao, s_bao],[-9e9,+9e9],'k--')
pl.text(s_bao*1.03, 420, 'BAO scale')
pl.text(s_bao*1.03, 370, '%0.1f Mpc'%s_bao)
if dosave: pl.savefig('xi1d_3bin.pdf')
def check_models(self):
'''
Displays a plot of the models against that taken from a
respected website (https://www.pvlighthouse.com.au/)
'''
plt.figure('Intrinsic bandgap')
t = np.linspace(1, 500)
for author in self.available_models():
Eg = self.update(temp=t, author=author, multiplier=1.0)
plt.plot(t, Eg, label=author)
test_file = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'Si', 'check data', 'iBg.csv')
data = np.genfromtxt(test_file, delimiter=',', names=True)
for temp, name in zip(data.dtype.names[0::2], data.dtype.names[1::2]):
plt.plot(
data[temp], data[name], '--', label=name)
plt.xlabel('Temperature (K)')
plt.ylabel('Intrinsic Bandgap (eV)')
plt.legend(loc=0)
self.update(temp=0, author=author, multiplier=1.01)
def show(self, x):
"""
vizualisation of the mm based on the empirical histogram of x
Parameters
----------
x: array of shape(nbitems): the data to be processed
"""
step = 3.5*np.std(x)/np.exp(np.log(np.size(x))/3)
bins = max(10,int((x.max()-x.min())/step))
h,c = np.histogram(x, bins)
h = h.astype(np.float)/np.size(x)
p = self.mixt
dc = c[1]-c[0]
y = (1-p)*_gaus_dens(self.mean,self.var,c)*dc
z = np.zeros(np.size(c))
i = np.ravel(np.nonzero(c>0))
z = _gam_dens(self.shape,self.scale,c)*p*dc
import matplotlib.pylab as mp
mp.figure()
mp.plot(0.5 *(c[1:] + c[:-1]),h)
mp.plot(c,y,'r')
mp.plot(c,z,'g')
mp.plot(c,z+y,'k')
mp.title('Fit of the density with a Gamma-Gaussians mixture')
mp.legend(('data','gaussian acomponent','gamma component',
'mixture distribution'))
def show(self, rescale=True, ax=None):
"""Visualization of a design matrix
Parameters
----------
rescale: bool, optional
rescale columns magnitude for visualization or not
ax: figure handle, optional
Returns
-------
ax, figure handle
"""
x = self.matrix.copy()
if rescale:
x = x / np.sqrt(np.sum(x ** 2, 0))
import matplotlib.pylab as mp
if ax is None:
mp.figure()
ax = mp.subplot(1, 1, 1)
ax.imshow(x, interpolation='Nearest', aspect='auto')
ax.set_label('conditions')
ax.set_ylabel('scan number')
if self.names is not None:
ax.set_xticks(range(len(self.names)))
ax.set_xticklabels(self.names, rotation=60, ha='right')
return ax
def test1():
x = [0.5]*3
xbounds = [(-5, 5) for y in x]
GA = GenAlg(fitcalc1, x, xbounds, popMult=100, bitsPerGene=9, mutation=(1./9.), crossover=0.65, crossN=2, direction='min', maxGens=60, hammingDist=False)
results = GA.run()
print "*** DONE ***"
#print results
plt.ioff()
#generate pareto frontier numerically
x1_ = np.arange(-5., 0., 0.05)
x2_ = np.arange(-5., 0., 0.05)
x3_ = np.arange(-5., 0., 0.05)
pfn = []
for x1 in x1_:
for x2 in x2_:
for x3 in x3_:
pfn.append(fitcalc1([x1,x2,x3]))
pfn.sort(key=lambda x:x[0])
plt.figure()
i = 0
for x in results:
plt.scatter(x[1][0], x[1][1], 20, c='r')
plt.scatter([x[0] for x in pfn], [x[1] for x in pfn], 1.0, c='b', alpha=0.1)
plt.xlim([-20,-1])
plt.ylim([-12, 2])
plt.draw()
def viz_docwordfreq_sidebyside(P1, P2, title1='', title2='',
vmax=None, aspect=None, block=False):
from matplotlib import pylab
pylab.figure()
if vmax is None:
vmax = 1.0
P1limit = np.percentile(P1.flatten(), 97)
if P2 is not None:
P2limit = np.percentile(P2.flatten(), 97)
else:
P2limit = P1limit
while vmax > P1limit and vmax > P2limit:
vmax = 0.8 * vmax
if aspect is None:
aspect = float(P1.shape[1])/P1.shape[0]
pylab.subplot(1, 2, 1)
pylab.imshow(P1, aspect=aspect, interpolation='nearest', vmin=0, vmax=vmax)
if len(title1) > 0:
pylab.title(title1)
if P2 is not None:
pylab.subplot(1, 2, 2)
pylab.imshow(P2, aspect=aspect, interpolation='nearest', vmin=0, vmax=vmax)
if len(title2) > 0:
pylab.title(title2)
pylab.show(block=block)
def test_flux(self):
tol = 150.
inputcat = catalog.read(os.path.join(self.args.tmp_path, 'ccd_1.cat'))
pixradius = 3*self.target["psf"]/self.instrument["PIXEL_SCALE"]
positions = list(zip(inputcat["X_IMAGE"]-1, inputcat["Y_IMAGE"]-1))
fluxes = image.simple_aper_phot(self.im[1], positions, pixradius)
sky_background = image.annulus_photometry(self.im[1], positions,
pixradius+5, pixradius+8)
total_bg_pixels = np.shape(image.build_annulus_mask(pixradius+5, pixradius+8, positions[0]))[1]
total_source_pixels = np.shape(image.build_circle_mask(pixradius,
positions[0]))[1]
estimated_fluxes = fluxes - sky_background*1./total_bg_pixels*total_source_pixels
estimated_magnitude = image.flux2mag(estimated_fluxes,
self.im[1].header['SIMMAGZP'], self.target["exptime"])
expected_flux = image.mag2adu(17.5, self.target["zeropoint"][0],
exptime=self.target["exptime"])
p.figure()
p.hist(fluxes, bins=50)
p.title('Expected flux: {:0.2f}, mean flux: {:1.2f}'.format(expected_flux, np.mean(estimated_fluxes)))
p.savefig(os.path.join(self.figdir,'Fluxes.png'))
assert np.all(np.abs(fluxes-expected_flux) < tol)
def test_2d_esmf_conserv(self):
print 'running test_2d_esmf_conserv...'
f = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = f('so')[0, 0, :, :]
clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt')[0, :, :]
tic = time.time()
soInterp = so.regrid(clt.getGrid(), regridTool='ESMF', regridMethod='Conservative')
soInterpInterp = soInterp.regrid(so.getGrid(), regridTool='ESMF',
regridMethod='Conservative')
toc = time.time()
print 'time to interpolate (ESMF conservative) forward/backward: ', toc - tic
ntot = reduce(operator.mul, so.shape)
avgdiff = numpy.sum(so - soInterpInterp) / float(ntot)
print 'avgdiff = ', avgdiff
if PLOT:
pylab.figure(2)
pylab.subplot(2, 2, 1)
pylab.pcolor(so, vmin=20.0, vmax=40.0)
pylab.colorbar()
pylab.title('ESMF conserve regrid: so')
pylab.subplot(2, 2, 2)
pylab.pcolor(soInterp, vmin=20.0, vmax=40.0)
pylab.colorbar()
pylab.title('ESMF conserve regrid: soInterp')
pylab.subplot(2, 2, 3)
pylab.pcolor(soInterpInterp, vmin=20.0, vmax=40.0)
pylab.colorbar()
pylab.title('ESMF conserve regrid: soInterpInterp')
pylab.subplot(2, 2, 4)
pylab.pcolor(so - soInterpInterp, vmin=-0.5, vmax=0.5)
pylab.colorbar()
pylab.title('ESMF conserve regrid: error')
def plot_grid_experiment_results(grid_results, params, metrics):
global plt
params = sorted(params)
grid_params = grid_results.grid_params
plt.figure(figsize=(8, 6))
for metric in metrics:
grid_params_shape = [len(grid_params[k]) for k in sorted(grid_params.keys())]
params_max_out = [(1 if k in params else 0) for k in sorted(grid_params.keys())]
results = np.array([e.results.get(metric, 0) for e in grid_results.experiments])
results = results.reshape(*grid_params_shape)
for axis, included_in_params in enumerate(params_max_out):
if not included_in_params:
results = np.apply_along_axis(np.max, axis, results)
print results
params_shape = [len(grid_params[k]) for k in sorted(params)]
results = results.reshape(*params_shape)
if len(results.shape) == 1:
results = results.reshape(-1,1)
import matplotlib.pylab as plt
#f.subplots_adjust(left=.2, right=0.95, bottom=0.15, top=0.95)
plt.imshow(results, interpolation='nearest', cmap=plt.cm.hot)
plt.title(str(grid_results.name) + " " + metric)
if len(params) == 2:
plt.xticks(np.arange(len(grid_params[params[1]])), grid_params[params[1]], rotation=45)
plt.yticks(np.arange(len(grid_params[params[0]])), grid_params[params[0]])
plt.colorbar()
plt.show()
def plot_feat_hist(data_name_list, filename=None):
pylab.clf()
# import pdb;pdb.set_trace()
num_rows = 1 + (len(data_name_list) - 1) / 2
num_cols = 1 if len(data_name_list) == 1 else 2
pylab.figure(figsize=(5 * num_cols, 4 * num_rows))
for i in range(num_rows):
for j in range(num_cols):
pylab.subplot(num_rows, num_cols, 1 + i * num_cols + j)
x, name = data_name_list[i * num_cols + j]
pylab.title(name)
pylab.xlabel('Value')
pylab.ylabel('Density')
# the histogram of the data
max_val = np.max(x)
if max_val <= 1.0:
bins = 50
elif max_val > 50:
bins = 50
else:
bins = max_val
n, bins, patches = pylab.hist(
x, bins=bins, normed=1, facecolor='green', alpha=0.75)
pylab.grid(True)
if not filename:
filename = "feat_hist_%s.png" % name
pylab.savefig(os.path.join(CHART_DIR, filename), bbox_inches="tight")
def visualization2(self, sp_to_vis=None):
if sp_to_vis:
species_ready = list(set(sp_to_vis).intersection(self.all_sp_signatures.keys()))
else:
raise Exception('list of driver species must be defined')
if not species_ready:
raise Exception('None of the input species is a driver')
for sp in species_ready:
# Setting up figure
plt.figure()
plt.subplot(313)
mon_val = OrderedDict()
signature = self.all_sp_signatures[sp]
for idx, mon in enumerate(list(set(signature))):
if mon[0] == 'C':
mon_val[self.all_comb[sp][mon] + (-1,)] = idx
else:
mon_val[self.all_comb[sp][mon]] = idx
mon_rep = [0] * len(signature)
for i, m in enumerate(signature):
if m[0] == 'C':
mon_rep[i] = mon_val[self.all_comb[sp][m] + (-1,)]
else:
mon_rep[i] = mon_val[self.all_comb[sp][m]]
# mon_rep = [mon_val[self.all_comb[sp][m]] for m in signature]
y_pos = numpy.arange(len(mon_val.keys()))
plt.scatter(self.tspan[1:], mon_rep)
plt.yticks(y_pos, mon_val.keys())
plt.ylabel('Monomials', fontsize=16)
plt.xlabel('Time(s)', fontsize=16)
plt.xlim(0, self.tspan[-1])
plt.ylim(0, max(y_pos))
plt.subplot(312)
for name in self.model.odes[sp].as_coefficients_dict():
mon = name
mon = mon.subs(self.param_values)
var_to_study = [atom for atom in mon.atoms(sympy.Symbol)]
arg_f1 = [numpy.maximum(self.mach_eps, self.y[str(va)][1:]) for va in var_to_study]
f1 = sympy.lambdify(var_to_study, mon)
mon_values = f1(*arg_f1)
mon_name = str(name).partition('__')[2]
plt.plot(self.tspan[1:], mon_values, label=mon_name)
plt.ylabel('Rate(m/sec)', fontsize=16)
plt.legend(bbox_to_anchor=(-0.1, 0.85), loc='upper right', ncol=1)
plt.subplot(311)
plt.plot(self.tspan[1:], self.y['__s%d' % sp][1:], label=parse_name(self.model.species[sp]))
plt.ylabel('Molecules', fontsize=16)
plt.legend(bbox_to_anchor=(-0.15, 0.85), loc='upper right', ncol=1)
plt.suptitle('Tropicalization' + ' ' + str(self.model.species[sp]))
# plt.show()
plt.savefig('s%d' % sp + '.png', bbox_inches='tight', dpi=400)
def plot_corner_posteriors(self, savefile=None, labels=["T1", "R1", "Av", "T2", "R2"]):
'''
Plots the corner plot of the MCMC results.
'''
ndim = len(self.sampler.flatchain[0,:])
chain = self.sampler
samples = chain.flatchain
samples = samples[:,0:ndim]
plt.figure(figsize=(8,8))
fig = corner.corner(samples, labels=labels[0:ndim])
plt.title("MJD: %.2f"%self.mjd)
name = self._get_save_path(savefile, "mcmc_posteriors")
plt.savefig(name)
plt.close("all")
plt.figure(figsize=(8,ndim*3))
for n in range(ndim):
plt.subplot(ndim,1,n+1)
chain = self.sampler.chain[:,:,n]
nwalk, nit = chain.shape
for i in np.arange(nwalk):
plt.plot(chain[i], lw=0.1)
plt.ylabel(labels[n])
plt.xlabel("Iteration")
name_walkers = self._get_save_path(savefile, "mcmc_walkers")
plt.tight_layout()
plt.savefig(name_walkers)
plt.close("all")
def plot_peaks(spectra, ref, zl, pl, filename=''):
plt.figure();
plt.title("Debug: Peak fitting for '%s'" % filename);
plt.xlabel("y-position [px]");
plt.ylabel("Intensity");
Nspectra, Npx = spectra.shape;
for s in xrange(Nspectra):
scale = 1./spectra.max();
offset= -s*0.1;
# plot data
plt.plot(spectra[s]*scale + offset,'k',linewidth=2);
# plot first peak
p,A,w = zl[s];
x = np.arange(-2*w, 2*w) + p;
plt.plot(x,gauss(x,*zl[s])*scale + offset,'r');
# plot second peak
if ref is not None:
p,A = pl[s];
x = np.arange(len(ref)) - len(ref)/2 + p;
plt.plot(x,ref/ref.max()*A*scale + offset,'g');
def check_isometry(G, chart, nseeds=100, verbose = 0):
"""
A simple check of the Isometry:
look whether the output distance match the intput distances
for nseeds points
Returns
-------
a scaling factor between the proposed and the true metrics
"""
nseeds = np.minimum(nseeds, G.V)
aux = np.argsort(nr.rand(nseeds))
seeds = aux[:nseeds]
dY = Euclidian_distance(chart[seeds],chart)
dx = G.floyd(seeds)
dY = np.reshape(dY,np.size(dY))
dx = np.reshape(dx,np.size(dx))
if verbose:
import matplotlib.pylab as mp
mp.figure()
mp.plot(dx,dY,'.')
mp.show()
scale = np.dot(dx,dY)/np.dot(dx,dx)
return scale
def infer_latent_dim(X, verbose=0, maxr=-1):
"""
r = infer_latent_dim(X, verbose=0)
Infer the latent dimension of an aray assuming data+gaussian noise mixture
Parameters
----------
array X, data whose deimsnionhas to be inferred
verbose=0, int, verbosity level
maxr=-1, int, maximum dimension that can be achieved
if maxr = -1, this is equal to rank(X)
Returns
-------
r, int, the inferred dimension
"""
if maxr ==-1:
maxr = np.minimum(X.shape[0],X.shape[1])
U,S,V = nl.svd(X,0)
if verbose>1:
print "Singular Values", S
L = []
for k in range(maxr):
L.append(_linear_dim_criterion_(S,k,X.shape[1],X.shape[0])/X.shape[0])
L = np.array(L)
rank = np.argmax(L)
if verbose:
import matplotlib.pylab as mp
mp.figure()
mp.bar(np.arange(maxr),L-L.mean())
return rank
def _fig_density(sweight, surweight, pval, nlm):
"""
Plot the histogram of sweight across the image
and the thresholds implied by the surrogate model (surweight)
"""
import matplotlib.pylab as mp
# compute some thresholds
nlm = nlm.astype('d')
srweight = np.sum(surweight,1)
srw = np.sort(srweight)
nitem = np.size(srweight)
thf = srw[int((1-min(pval,1))*nitem)]
mnlm = max(1,nlm.mean())
imin = min(nitem-1,int((1.-pval/mnlm)*nitem))
thcf = srw[imin]
h,c = np.histogram(sweight,100)
I = h.sum()*(c[1]-c[0])
h = h/I
h0,c0 = np.histogram(srweight,100)
I0 = h0.sum()*(c0[1]-c0[0])
h0 = h0/I0
mp.figure(1)
mp.plot(c,h)
mp.plot(c0,h0)
mp.legend(('true histogram','surrogate histogram'))
mp.plot([thf,thf],[0,0.8*h0.max()])
mp.text(thf,0.8*h0.max(),'p<0.2, uncorrected')
mp.plot([thcf,thcf],[0,0.5*h0.max()])
mp.text(thcf,0.5*h0.max(),'p<0.05, corrected')
mp.savefig('/tmp/histo_density.eps')
mp.show()
def item_nbr_tendency_finely(store_nbr, year, month_start=-1, month_end=-1, graph=True):
'''
input
1. store_nbr = 스토어 번호
2. year = 연도
3. month_start = 시작달
4. month_start = 끝달
5. graph = 위의 정보에 대한 item_nbr 그래프 출력여부
output
1. store_nbr, year, month로 filtering한 item_nbr의 pivot 테이블
'''
store = df_1[(df_1['store_nbr'] == store_nbr) &
(df_1['year'] == year)]
if month_start != -1:
if month_end == -1:
month_end = month_start + 1
store = store[(month_start <= store['month']) & (store['month'] < month_end)]
pivot = store.pivot_table(index='item_nbr',
columns='date',
values='units',
aggfunc=np.sum)
zero_index = pivot == 0
pivot = pivot[pivot != 0].dropna(axis=0, how='all')
pivot[zero_index] = 0
if graph:
plt.figure(figsize=(12, 8))
sns.heatmap(pivot, cmap="YlGnBu", annot=True, fmt='.0f')
plt.show()
return pivot
def flipPlot(minExp, maxExp):
"""假定minEXPy和maxExp是正整数且minExp<maxExp
绘制出2**minExp到2**maxExp次抛硬币的结果
"""
ratios = []
diffs = []
aAxis = []
for i in range(minExp, maxExp+1):
aAxis.append(2**i)
for numFlips in aAxis:
numHeads = 0
for n in range(numFlips):
if random.random() < 0.5:
numHeads += 1
numTails = numFlips - numHeads
ratios.append(numHeads/numFlips)
diffs.append(abs(numHeads-numTails))
plt.figure()
ax1 = plt.subplot(121)
plt.title("Difference Between Heads and Tails")
plt.xlabel('Number of Flips')
plt.ylabel('Abs(#Heads - #Tails)')
ax1.semilogx(aAxis, diffs, 'bo')
ax2 = plt.subplot(122)
plt.title("Heads/Tails Ratios")
plt.xlabel('Number of Flips')
plt.ylabel("#Heads/#Tails")
ax2.semilogx(aAxis, ratios, 'bo')
plt.show()
def handle(self, *args, **options):
try:
from matplotlib import pylab as pl
import numpy as np
except ImportError:
raise Exception('Be sure to install requirements_scipy.txt before running this.')
all_names_and_counts = RawCommitteeTransactions.objects.all().values('attest_by_name').annotate(total=Count('attest_by_name')).order_by('-total')
all_names_and_counts_as_tuple_and_sorted = sorted([(row['attest_by_name'], row['total']) for row in all_names_and_counts], key=lambda row: row[1])
print "top ten attestors: (name, number of transactions they attest for)"
for row in all_names_and_counts_as_tuple_and_sorted[-10:]:
print row
n_bins = 100
filename = 'attestor_participation_distribution.png'
x_max = all_names_and_counts_as_tuple_and_sorted[-31][1] # eliminate top outliers from hist
x_min = all_names_and_counts_as_tuple_and_sorted[0][1]
counts = [row['total'] for row in all_names_and_counts]
pl.figure(1, figsize=(18, 6))
pl.hist(counts, bins=np.arange(x_min, x_max, (float(x_max)-x_min)/100) )
pl.title('Histogram of Attestor Participation in RawCommitteeTransactions')
pl.xlabel('Number of transactions a person attested for')
pl.ylabel('Number of people')
pl.savefig(filename)
def XXtest5_regrid(self):
srcF = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = srcF('so')[0, 0, ...]
clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt')
dstData = so.regrid(clt.getGrid(),
regridTool = 'esmf',
regridMethod='conserve')
if self.pe == 0:
dstDataMask = (dstData == so.missing_value)
dstDataFltd = dstData * (1 - dstDataMask)
zeroValCnt = (dstData == 0).sum()
if so.missing_value > 0:
dstDataMin = dstData.min()
dstDataMax = dstDataFltd.max()
else:
dstDataMin = dstDataFltd.min()
dstDataMax = dstData.max()
zeroValCnt = (dstData == 0).sum()
print 'Number of zero valued cells', zeroValCnt
print 'min/max value of dstData: %f %f' % (dstDataMin, dstDataMax)
self.assertLess(dstDataMax, so.max())
if False:
pylab.figure(1)
pylab.pcolor(so, vmin=20, vmax=40)
pylab.colorbar()
pylab.title('so')
pylab.figure(2)
pylab.pcolor(dstData, vmin=20, vmax=40)
pylab.colorbar()
pylab.title('dstData')
def check_models(self):
plt.figure('Bandgap narrowing')
Na = np.logspace(12, 20)
Nd = 0.
dn = 1e14
temp = 300.
for author in self.available_models():
BGN = self.update(Na=Na, Nd=Nd, nxc=dn,
author=author,
temp=temp)
if not np.all(BGN == 0):
plt.plot(Na, BGN, label=author)
test_file = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'Si', 'check data', 'Bgn.csv')
data = np.genfromtxt(test_file, delimiter=',', names=True)
for name in data.dtype.names[1:]:
plt.plot(
data['N'], data[name], 'r--',
label='PV-lighthouse\'s: ' + name)
plt.semilogx()
plt.xlabel('Doping (cm$^{-3}$)')
plt.ylabel('Bandgap narrowing (K)')
plt.legend(loc=0)
def item_nbr_tendency(store_nbr):
'''
input : store_nbr
output : graph representing units groupped by each year, each month
'''
store = df_1[df_1['store_nbr'] == store_nbr]
pivot = store.pivot_table(index=['year','month'],columns='item_nbr',values='units',aggfunc=np.sum)
zero_index = pivot==0
pivot = pivot[pivot!=0].dropna(axis=1,how='all')
pivot[zero_index]=0
pivot_2012 = pivot.loc[2012]
pivot_2013 = pivot.loc[2013]
pivot_2014 = pivot.loc[2014]
plt.figure(figsize=(12,8))
plt.subplot(131)
sns.heatmap(pivot_2012,cmap="YlGnBu", annot = True, fmt = '.0f')
plt.subplot(132)
sns.heatmap(pivot_2013,cmap="YlGnBu", annot = True, fmt = '.0f')
plt.subplot(133)
sns.heatmap(pivot_2014,cmap="YlGnBu", annot = True, fmt = '.0f')
plt.show()
def plot_waveforms(time,voltage,APTimes,titlestr):
"""
plot_waveforms takes four arguments - the recording time array, the voltage
array, the time of the detected action potentials, and the title of your
plot. The function creates a labeled plot showing the waveforms for each
detected action potential
"""
plt.figure()
## Your Code Here
indices = []
for x in range(len(APTimes)):
for i in range(len(time)):
if(time[i]==APTimes[x]):
indices.append(i)
##print indices
Xval = np.linspace(-.003,.003,200)
print len(Xval)
for x in range(len(APTimes)):
plt.plot(Xval, voltage[indices[x]-100:indices[x]+100])
plt.title(titlestr)
plt.xlabel('Time (s)')
plt.ylabel('Voltage (uV)')
plt.hold(True)
plt.show()
def fdr(p_values=None, verbose=0):
"""Returns the FDR associated with each p value
Parameters
-----------
p_values : ndarray of shape (n)
The samples p-value
Returns
-------
q : array of shape(n)
The corresponding fdr values
"""
p_values = check_p_values(p_values)
n_samples = p_values.size
order = p_values.argsort()
sp_values = p_values[order]
# compute q while in ascending order
q = np.minimum(1, n_samples * sp_values / np.arange(1, n_samples + 1))
for i in range(n_samples - 1, 0, - 1):
q[i - 1] = min(q[i], q[i - 1])
# reorder the results
inverse_order = np.arange(n_samples)
inverse_order[order] = np.arange(n_samples)
q = q[inverse_order]
if verbose:
import matplotlib.pylab as mp
mp.figure()
mp.xlabel('Input p-value')
mp.plot(p_values, q, '.')
mp.ylabel('Associated fdr')
return q
if ffmol is None:
raise Exception("Could not find any of the FF molecules in the reference structure")
nbonds = len(ffmol.bonds)
nangles = len(ffmol.angles)
# Now we can read data, assume it was created by md_bondang.py
anglist = []
bondlist = []
for filename in args.file:
bd, ad = _read_series(filename, nbonds)
# This transforms that numpy arrays into TimeSeries objects and thereby estimate densities etc
bondlist.append([TimeSeries(bd[:, i]) for i in range(nbonds)])
anglist.append([TimeSeries(ad[:, i], _trans_ang) for i in range(nangles)])
# Create one plot for bonds and one for angles
f = plt.figure(1)
_plot_dists(bondlist, args.labels, ffmol.bonds, f)
f.savefig(args.out + "_bonddist.png", format="png",dpi=300)
f = plt.figure(2)
_plot_dists(anglist, args.labels, ffmol.angles, f)
f.savefig(args.out + "_angdist.png", format="png",dpi=300)
# Estimate ff parameters
try :
wb = xl.load_workbook(filename = args.excel)
except :
print "Could not open the XLSX file. Will create one from scratch"
wb = xl.Workbook()
try :
Z = hierarchy.linkage(kojacc, method=method, optimal_ordering=True)
maxdist = np.max(Z[:, 2])
# clustering (segmentación)
clust = hierarchy.fcluster(Z, maxdist*args.cutoff, criterion='distance')
n_clusts = len(np.unique(clust)) # number of clusters
# dendograms
# colors for clusters
# TODO: Add an option for selecting colormap
dend_colors = cm.jet(np.linspace(0, 1, n_clusts))
hexcolors = [mpl.colors.rgb2hex(rgb[:3]) for rgb in dend_colors]
hierarchy.set_link_color_palette(hexcolors)
# Plot
plt.figure(figsize=(15, 7))
dend = hierarchy.dendrogram(Z, color_threshold=maxdist*args.cutoff,
no_labels=True)
plt.axhline(maxdist*args.cutoff, ls='--', alpha=0.3, c='k')
plt.tight_layout()
# legend and colors
if legend:
legend_elements = []
for i, rgb in enumerate(dend_colors):
label = f"Cluster {i+1}"
element = Line2D([0], [0], color=rgb, label=label, lw=3)
legend_elements.append(element)
plt.legend(handles=legend_elements, loc=1)
print(f'[INFO] Output path: {outpath}')
'alpha': 0.2,
'width': 1,
'node_shape': 'X',
}
temp = []
for i in list(G):
try:
temp.append(float(i[1]))
except:
pass
# temp.sort()
h = enumerate(range(0, len(temp)))
print(temp)
x1 = np.array(temp) # random data, normal distribution
xs = np.linspace(x1.min() - 1, x1.max() + 1, len(x1))
print(x1)
kde1 = stats.gaussian_kde(x1)
kde2 = stats.gaussian_kde(x1, bw_method='silverman')
fig = plt.figure(figsize=(8, 6))
plt.plot(xs, kde2(xs), 'b-', label="Happiness line")
plt.legend(loc=1)
plt.xlabel("Exercise hours per week")
plt.ylabel("happiness density distribution")
plt.title("Probability density function for exercise versus happiness ")
plt.savefig("m silverman log non ranged estimation.png", dpi=500)
plt.show()
line = lines[i]
info = re.findall(patternKey, line)
if len(info):
actualKey = key.replace(" ", "")
if info[0][0].replace(" ", "").upper().startswith(actualKey):
continue
else:
return False
return True
except:
return False
if __name__ == "__main__":
filename = None
if len(sys.argv) > 1:
filename = sys.argv[1]
print("is JCAMP-DX File?", isJcampFile(filename))
instance = JcampReader(filename)
print(instance.info)
x, y = instance.data
try:
import matplotlib.pylab as plt
plt.figure(0)
plt.plot(x, y)
plt.xlabel(instance.info.get('XUNITS', 'X'))
plt.ylabel(instance.info.get('YUNITS', 'Y'))
plt.show()
except:
pass
welist.append(wecashdic[uid])
fpr_grd_lm, tpr_grd_lm, _ = roc_curve(uy, ufen)
fpr_grd_lmw, tpr_grd_lmw, _ = roc_curve(uy, welist, pos_label=0)
print 'call权重', wei
print "AUC Score (Train): %f" % metrics.roc_auc_score(uy, ufen)
# plt.figure(1)
# plt.plot([0, 1], [0, 1], 'k--')
# # plt.plot(fpr_grd_lm, tpr_grd_lm, label='GBT + LR')
# plt.plot(fpr_grd_lm, tpr_grd_lm, label='GBT')
# plt.plot(fpr_grd_lmw, tpr_grd_lmw, label='wecash')
# plt.xlabel('False positive rate')
# plt.ylabel('True positive rate')
# plt.legend(loc='best')
# plt.show()
# plt.figure(1)
# n, bins, patches = plt.hist(welist, 100, normed=1, facecolor='g', alpha=0.75)
# plt.xlabel('hist')
# plt.ylabel('Probability')
# plt.title('Histogram')
# # plt.text(60,.025, r'$\mu=100,\ \sigma=15$')
# plt.grid(True)
# plt.show()
plt.figure(2)
n, bins, patches = plt.hist(ufen, 100, normed=1, facecolor='g', alpha=0.75)
plt.xlabel('hist')
plt.ylabel('Probability')
plt.title('Histogram')
#plt.text(60,.025, r'$\mu=100,\ \sigma=15$')
plt.grid(True)
plt.show()
import matplotlib.pylab as plt
import numpy as np
import pandas as pd
from matplotlib import cm
from scipy.stats import norm,chi2,binom,gamma
import seaborn as sns
from math import cos, sin,log,tan,pi,exp,sqrt,cosh,sinh,tanh,atan,atan2,e
from cmath import exp as cexp, log as clog
from mpl_toolkits.mplot3d import Axes3D
for i,t in enumerate(np.linspace(0,2*pi,360)):
fig = plt.figure(figsize=(16,16))
ax = fig.add_subplot(111, projection='3d',facecolor='black')
p = plt.axis('off')
x = np.linspace(-2*pi,2*pi,1000)
y = np.linspace(-2*pi,2*pi,1000)
xx, yy = np.meshgrid(x, y, sparse=True)
z = np.cos(xx*yy +6*t+pi)
ax.view_init(t*180/(pi),t*180/(4*pi))
ax.set_zlim(-3,3)
ax.plot_surface(xx, yy, z, antialiased=True, shade=True,cmap=cm.winter,alpha=0.8)
p = plt.savefig(f'C:/Users/Alejandro/Pictures/RandomPlots/15052020/plot{i}.PNG',facecolor='black')
history = simple_model.fit(
train_data_gen,
epochs=30,
steps_per_epoch=5,
verbose=1,
validation_data=val_data_gen
)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1])
plt.title('Training and Validation Accuracy')
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
# plt.ylim([0,1.5])
plt.title('Training and Validation Loss')
logis.fit(x_train, y_train)
xop = []
yop = []
xpe = []
ype = []
i = 0
while i <= x_train.shape[0] - 1:
if y_train[i] == 1:
xop.append(x_train[i][0])
yop.append(x_train[i][1])
else:
xpe.append(x_train[i][0])
ype.append(x_train[i][1])
i += 1
fig = plot.figure()
plot.scatter(xop, yop, color="red")
plot.scatter(xpe, ype, color="blue")
plot.xlim((-10, 20))
plot.ylim((-10, 20))
X = np.linspace(-10, 10, 30)
Y = -X * logis.theta[0][1] / logis.theta[0][2] - logis.theta[0][
0] / logis.theta[0][2]
plot.plot(X, Y)
plot.show()
fig.savefig('lr.jpg')
'''由于ARMA拟合的是经过相关预处理后的数据，故其
预测值需要通过相关逆变换进行还原'''
# 一阶差分还原
diff_shift_ts = ts_diff_1.shift(1)
diff_recover_1 = predict_ts.add(diff_shift_ts)
# 再次一阶差分还原
rol_shift_ts = rol_mean.shift(1)
diff_recover = diff_recover_1.add(rol_shift_ts)
# 移动平均还原
rol_sum = ts_log.rolling(window=11).sum()
rol_recover = diff_recover * 12 - rol_sum.shift(1)
# 对数还原
log_recover = np.exp(rol_recover)
log_recover.dropna(inplace=True)
# 使用均方根误差（RMSE）来评估模型样本内拟合的好坏
ts = ts[log_recover.index] # 过滤没有预测的记录
plt.figure(facecolor='white')
log_recover.plot(color='blue', label='Predict')
ts.plot(color='red', label='Original')
plt.legend(loc='best')
plt.title('RMSE: %.4f' % np.sqrt(sum((log_recover - ts)**2) / ts.size))
plt.show()
turb_predictions.append(yhat)
obs = test[t]
turb_history.append(obs)
diff = obs - yhat
turb_diff.append(diff)
print(
'TurbParameter Index= %d, predicted=%f, expected=%f, difference = %f' %
(k, yhat, obs, diff))
k = k + 1
if (k == 3000):
break
#test1, test2 = tts(test,test_size = 337, random_state=0, shuffle=False)
error = mean_squared_error(test1, predictions)
print('Test MSE: %.3f' % error)
# plot
plt.figure(figsize=(12, 8))
pyplot.plot(test1, label="Original")
pyplot.plot(predictions, color='red', label='Predicted')
plt.xlabel("Datatime Index ")
plt.ylabel("Turbidity Values")
plt.title('Turbidity Forecast')
plt.legend()
plt.show()
#%%
# SARIMA example
from statsmodels.tsa.statespace.sarimax import SARIMAX
from random import random
# fit model
model = SARIMAX(turb_test, order=(1, 1, 1), seasonal_order=(1, 1, 1, 1))
model_fit = model.fit(disp=False)
# Gaussian distributions
a = gauss(n, m=20, s=5) # m= mean, s= std
B = np.zeros((n, n_target))
for i, m in enumerate(lst_m):
B[:, i] = gauss(n, m=m, s=5)
# loss matrix and normalization
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)), 'euclidean')
M /= M.max()
M2 = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)), 'sqeuclidean')
M2 /= M2.max()
#%% plot the distributions
pl.figure(1)
pl.subplot(2, 1, 1)
pl.plot(x, a, 'b', label='Source distribution')
pl.title('Source distribution')
pl.subplot(2, 1, 2)
pl.plot(x, B, label='Target distributions')
pl.title('Target distributions')
pl.tight_layout()
#%% Compute and plot distributions and loss matrix
d_emd = ot.emd2(a, B, M) # direct computation of EMD
d_emd2 = ot.emd2(a, B, M2) # direct computation of EMD with loss M3
pl.figure(2)
pl.plot(d_emd, label='Euclidean EMD')
def draw_trend(timeSeries, size=12): '''移动平均图''' f = plt.figure(facecolor='white')
import matplotlib.pylab as plt
import numpy as np
import pandas as pd
from math import cos, sin, log, tan, gamma, pi, exp, sqrt
m = 0
for y in np.linspace(0, 18, 390):
p = plt.figure(figsize=(12, 12), facecolor='black')
p = plt.axis('off')
p = plt.xlim(-2.1, 2.1)
p = plt.ylim(-2.1, 2.1)
plt.plot([
cos(t) * (1 - cos(t * y) * sin(y * t))
for t in np.linspace(0, 2 * pi, 500)
], [
sin(t) * (1 - cos(t * y) * sin(y * t))
for t in np.linspace(0, 2 * pi, 500)
],
lw=7,
color=plt.cm.PiYG(y / 18))
plt.savefig(
f'C:/Users/Alejandro/Pictures/RandomPlots/19122019/plot{m}.png',
facecolor='black')
m += 1
r = 1.
a = 0.1
z = 1.5
e = 0.75
t = sc.linspace(0, 15, 1000)
R0 = 10
C0 = 5
RC0 = sc.array([R0, C0])
pops, infodict = integrate.odeint(dCR_dt, RC0, t, full_output=True)
f1 = p.figure()
p.plot(t, pops[:, 0], 'g-', label='Resource density') # Plot
p.plot(t, pops[:, 1], 'b-', label='Consumer density')
p.grid()
p.legend(loc='best')
p.xlabel('Time')
p.ylabel('Population density')
p.title('Consumer-Resource population dynamics')
f1.savefig('../Results/LV1_model.pdf')
# Phase Plot script
f2 = p.figure()
p.plot(pops[:, 0], pops[:, 1], 'r-') # Plot
p.grid()
p.xlabel('Resource density')
d = {
'training accuracy': '/*dbg_acc_train*.npy',
'accuracy val': '/*dbg_acc_val_*.npy',
'accuracy other ds': '/*dbg_acc_other_ds_*.npy',
# 'loss ae': '/*dbg_ae_cost_*.npy',
# 'loss lr': '/*dbg_lr_cost_*.npy',
# 'loss combined': '/*dbg_combined_cost_*.npy'
}
path_main = 'nips3mm_scarcity'
for k, v in d.iteritems():
pkgs = glob.glob(RES_NAME + v)
for n_comp in n_comps:
plt.figure()
for p in pkgs:
lambda_param = np.float(re.search('lambda=(.{4})', p).group(1))
# n_hidden = int(re.search('comp=(?P<comp>.{1,2,3})_', p).group('comp'))
n_hidden = int(re.search('comp=(.{1,3})_', p).group(1))
max_samples = int(re.search('max(.{1,4})_', p).group(1))
rest_samples = int(re.search('_r(.{2,4})_', p).group(1))
task_samples = int(re.search('_t(.{2,4})dbg', p).group(1))
if n_comp != n_hidden:
continue
if (task_samples == 1000):
continue
cur_values = np.load(p)
qpoases_stats = pd.read_csv('qpoases_stats.csv')
# Get mean number of iterations and runtime for each number of parameters
osqp_mean = osqp_stats.groupby('n').mean()
gurobi_mean = gurobi_stats.groupby('n').mean()
qpoases_mean = qpoases_stats.groupby('n').mean()
# Save mean stats in a CSV file
osqp_mean.columns = ['osqp_iter', 'osqp_runtime']
gurobi_mean.columns = ['gurobi_iter', 'gurobi_runtime']
qpoases_mean.columns = ['qpoases_iter', 'qpoases_runtime']
mean_stats = pd.concat([osqp_mean, gurobi_mean, qpoases_mean], axis=1)
mean_stats.to_csv('lasso_mean_stats.csv')
# Plot mean runtime
plt.figure()
ax = plt.gca()
plt.semilogy(mean_stats.index.values,
mean_stats['osqp_runtime'].get_values(),
color='C0',
label='OSQP')
plt.semilogy(mean_stats.index.values,
mean_stats['qpoases_runtime'].get_values(),
color='C1',
label='qpOASES')
plt.semilogy(mean_stats.index.values,
mean_stats['gurobi_runtime'].get_values(),
color='C5',
label='GUROBI')
plt.legend()
plt.grid()
rows = []
file_to_open = sys.argv[1] if len(sys.argv) > 1 else "attention_data.jsonl"
with open(file_to_open) as fr:
lines = fr.readlines()
for epoch_index, l in enumerate(lines, 1):
data = json.loads(l.strip())
x = data["source"]
y = data["target"]
if x_axis:
assert x == x_axis
assert y == y_axis
x_axis = x
y_axis = y
row = np.array(data['attention'])
x = x[0]
y = y[0]
sub_title = " ".join(x.split()[1:-1]) + " ->\n" + " ".join(y.split()[1:-1])
plt.figure(epoch_index)
full_title = "attention based alignment epoch " + str(
epoch_index) + ":\n" + sub_title
# ax.set_title(full_title)
plt.title(full_title, fontsize=8)
ax = sns.heatmap(row,
xticklabels=x.split(),
yticklabels=y.split()[1:],
cmap="Blues",
annot=True,
fmt='.2f')
# ax = sns.heatmap(row, linewidth=0.5,yticklabels=y)
# ax.set_yticks(y[0].split()[1:])
plt.savefig("heat_map_epoch_" + str(epoch_index) + ".png")
recgen_u_col.params['recordings']['noise_color'] = True
recgen_u_col.params['recordings']['seed'] = 1
recgen_u_col.generate_recordings()
recgen_dc_col = deepcopy(recgen_u)
recgen_dc_col.params['recordings']['noise_mode'] = 'distance-correlated'
recgen_dc_col.params['recordings']['noise_color'] = True
recgen_dc_col.params['recordings']['seed'] = 2
recgen_dc_col.generate_recordings()
recgen_far = deepcopy(recgen_u)
recgen_far.params['recordings']['noise_mode'] = 'far-neurons'
recgen_far.params['recordings']['seed'] = 3
recgen_far.generate_recordings()
fig1 = plt.figure(figsize=(9, 9))
gs = gridspec.GridSpec(16, 19)
ax_u = fig1.add_subplot(gs[:4, :3])
ax_dc = fig1.add_subplot(gs[:4, 4:7])
ax_ucol = fig1.add_subplot(gs[:4, 8:11])
ax_dccol = fig1.add_subplot(gs[:4, 12:15])
ax_far = fig1.add_subplot(gs[:4, 16:19])
max_rec = 0
for rec in [recgen_u, recgen_dc, recgen_dc_col, recgen_u_col, recgen_far]:
max_v = np.max(rec.recordings)
if max_v > max_rec:
max_rec = max_v
rho = np.zeros((Nx, Ny))
rho[20:Nx-20, Ny//2:Ny//2+20] = 0.7
rho[Nx//2:Nx//2+5, 20:Ny-20] = 1
# plt.imshow(rho)
# plt.show()
design_region = np.ones((Nx, Ny))
W = get_W(Nx, Ny, design_region, NPML, R=R)
rhot = rho2rhot(rho, W)
rhob = rhot2rhob(rhot, eta=eta, beta=beta)
eps = rhob2eps(rhob, eps_m=eps_m)
f = plt.figure(figsize=(8, 4))
RTs = np.linspace(0,1,1000)
plt.plot(RTs, rhot2rhob(RTs, eta=0.5, beta=0.1))
plt.plot(RTs, rhot2rhob(RTs, eta=0.5, beta=10))
plt.plot(RTs, rhot2rhob(RTs, eta=0.5, beta=1000))
plt.legend((r"$\beta = .1$", r"$\beta = 10$", r"$\beta = 1000$"))
plt.xlabel(r"$\tilde{\rho}_i$")
plt.ylabel(r"$\bar{\rho}_i$")
plt.title(r"projection with varying $\beta$ ($\eta=0.5$)")
# plt.savefig('data/figs/img/project.pdf', dpi=300)
plt.show()
# # change in projected density with respect to filtered density
def circle(Nx, Ny, R=10):
BINS = np.linspace(0, 1.0, BIN_N + 1)
ROW_N = len(data)
hist_view = np.zeros((ROW_N, BIN_N))
for row_i, row in enumerate(data):
x, _ = np.histogram(row, bins=BINS)
hist_view[row_i] = x
# sort hist by original permutation
hist_view = hist_view[r['order_permutation']]
truths = truth[r['order_permutation']]
a = assignments[-1]
ai = np.argsort(a).flatten()
f = pylab.figure(figsize=(4, 12))
ax = f.add_subplot(1, 3, 1)
ax.imshow(hist_view, interpolation='nearest')
ax = f.add_subplot(1, 3, 2)
ax.imshow(hist_view[ai], interpolation='nearest')
for i in np.argwhere(np.diff(a[ai]) > 0).flatten():
ax.axhline(i + 0.5, c='w')
ax = f.add_subplot(1, 3, 3)
ax.imshow(hist_view[np.argsort(truths).flatten()], interpolation='nearest')
for i in np.argwhere(np.diff(np.sort(truths)) > 0).flatten():
ax.axhline(i + 0.5, c='w')
f.savefig(clusters_plot)
def plot_mass_function(self, units='Msol h**-1', kern='ST', ax=None,\
plot_Tvir=False, label_z=False, nbins=100, label=None, show=False, **kwargs):
'''
Plot the Halo mass function and (optionally) Tvir on twinx axis
Params:
kern: The analytical kernal to use
plot_Tvir: Calculates the Virial temperature in Kelvin for a halo of a given mass using equation 26 of Barkana & Loeb.
'''
import matplotlib.pylab as plt
from seren3.analysis.plots import fit_scatter
snapshot = self.base
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
if label_z:
label = "%s z=%1.3f" % (label, self.base.z)
c = kwargs.pop("color", "b")
mbinmps, y, mbinsize = self.mass_function(units=units,
nbins=nbins,
**kwargs)
# ax.semilogy(mbinmps, y, 'o', label=label, color=c)
bin_centers, mean, std = fit_scatter(mbinmps, y)
# ax.errorbar(bin_centers, mean, yerr=std, color=c)
e = ax.errorbar(bin_centers, mean, yerr=std, color=c,\
fmt="o", markerfacecolor=c, mec='k', capsize=2, capthick=2, elinewidth=2, linestyle="-", linewidth=2., label=label)
if plot_Tvir:
import cosmolopy.perturbation as cp
cosmo = snapshot.cosmo
M_ticks = np.array(ax.get_xticks())
mass = self.base.array(10**M_ticks, units)
Tvir = [
float("%1.3f" % np.log10(v))
for v in cp.virial_temp(mass, **cosmo)
]
ax2 = ax.twiny()
ax2.set_xticks(M_ticks - M_ticks.min())
ax2.set_xticklabels(Tvir)
ax2.set_xlabel(r"log$_{10}$(T$_{\mathrm{vir}}$ [K])")
if kern is not None:
import pynbody
# We only need to load one CPU to setup the params dict
s = pynbody.snapshot.ramses.RamsesSnap(
"%s/output_%05d" % (snapshot.path, snapshot.ioutput), cpus=[1])
M_kern, sigma_kern, N_kern = pynbody.analysis.halo_mass_function(
s, kern=kern, log_M_min=mbinmps.min(), log_M_max=mbinmps.max())
# Convert to correct units
M_kern.convert_units(mbinmps.units)
N_kern.convert_units(y.units)
# ax.semilogy(np.log10(M_kern*(snapshot.info['H0']/100)), N_kern, label=kern)
ax.semilogy(np.log10(M_kern),
N_kern,
label=kern,
color="grey",
linestyle="--")
ax.set_xlabel(r'log$_{10}$(M [$%s$])' % mbinmps.units.latex())
ax.set_ylabel('dN / dlog$_{10}$(M [$%s$])' % y.units.latex())
if "title" in kwargs:
ax.set_title(kwargs.get("title"))
if show:
ax.legend()
plt.show()
def get_data():
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
GPIO.output(18, False)
try:
ser = serial.Serial('/dev/ttyUSB0', 9600)
except:
print 'could not find arduino'
try:
my_file = open("flowers.txt", 'a')
count = 0
while count < 25:
line = ser.readline()
my_file.write(line)
print(line)
count = count + 1
my_file.close()
except:
print 'couldnt write data to file'
ifile = open('flowers.txt', 'r')
temp = []
water = []
humidity = []
for line in ifile.readlines():
line = line.strip()
print line
if line[:5] == 'Water':
try:
water.append(float(line.split(':')[-1]))
except:
print 'serial error'
elif line[:5] == 'Curre':
try:
humidity.append(float(line.split('=')[-1][:-1]))
except:
print 'serial error'
elif line[:5] == 'tempe':
try:
temp.append(float(line.split('=')[-1][:-1]))
except:
print 'serial error'
print temp
print water
print humidity
pylab.figure(1)
fig, ax1 = plt.subplots()
pylab.plot(range(len(temp)), temp, 'ro-')
pylab.xlabel('Time')
pylab.ylabel('Temp')
pylab.ylim(0, 100)
ax2 = ax1.twinx()
ax2.plot(range(len(humidity)), humidity, 'go-')
ax2.set_ylabel('Humidity')
ax2.set_ylim(0, 100)
pylab.savefig('temperature.png')
pylab.close()
pylab.figure(2)
pylab.plot(range(len(water)), water, 'bo-')
pylab.xlabel('Time')
pylab.ylabel('Water')
pylab.ylim(0, 1024)
pylab.savefig('water.png')
ifile.close()
return template("plot")
# lists
categories = [
'house', 'visage', 'animal', 'scene', 'tool', 'pseudoword', 'characters',
'scrambled'
]
scores_spc = np.load('%s/../scores_sid_pid_cat.npy' % INDIR).item()
# aggregate how many probes are predictive of how many categories
counts = np.zeros(9, dtype=np.int32)
for sid in scores_spc.keys():
for pid in scores_spc[sid].keys():
counts[len(scores_spc[sid][pid])] += 1
# plot the histogram
fig = plt.figure(figsize=(4, 8), dpi=300)
plt.barh(range(8), counts[1:], color="green")
plt.xlabel('Number of probes', size=16)
plt.ylabel('Number of categories a probe predicts', size=16)
plt.yticks(range(8), np.arange(1, 9), size=14)
plt.xticks([0, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400],
[0, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400],
size=12,
rotation=90)
for i, v in enumerate(counts[1:]):
if i == 0:
plt.gca().text(v - 65,
i + 0.1,
str(counts[1:][i]),
color='black',
def fluxExtract(science,bias,dark,flats,hdr,plotap=False,rad=18,plotname=None):
' Returns final flux of source '
# Calibrate Image. Flatten? add bias and flat to input
flagg = 0
# Defaul shape of sbig 2x2 binning
xsize,ysize = 1266,1676
if xsize != np.shape(bias)[0]:
print 'WARNING: check that size of science file matches assumptions'
if flats == 0:
flat = np.ones((xsize,ysize))
else:
flat = flats[hdr['FILTER']]
if dark == 0:
dark = np.ones((xsize,ysize))
else:
dark = dark[str(hdr['EXPTIME'])]
if np.mean(bias) == 0:
bias = np.zeros((xsize,ysize))
else:
bias = bias
# Size of science to trim calib frames (which are always full)
# Science frames either full or sub: 400x400 around center ()
centx, centy = int(1663/2), int(1252/2) # use config file in future, x and y are switched from thesky vs pyfits???
subframe_size = np.shape(science)
dx,dy = subframe_size[0]/2,subframe_size[0]/2
l,b,r,t = centx - dx, centy+dy, centx+dx, centy-dy # top and bottom switched
data = (science - bias[t:b,l:r] - dark[t:b,l:r])/flat[t:b,l:r]
if np.mean(data) < 0:
flagg += 1
# Get source x,y position
x,y = sourceFinder(science)
positions = (x,y)
if x==0:
flagg += 1
if y==0:
flagg += 1
# Define Apertures
apertures = CircularAperture(positions, r=rad)
annulus_apertures = CircularAnnulus(positions, r_in=rad+5, r_out=rad+20)
# Get fluxes
rawflux_table = aperture_photometry(data, apertures)
bkgflux_table = aperture_photometry(data, annulus_apertures)
bkg_mean = bkgflux_table['aperture_sum'] / annulus_apertures.area()
bkg_sum = bkg_mean * apertures.area()
final_sum = rawflux_table['aperture_sum'] - bkg_sum
# Plot
if plotap == True:
plt.ioff()
plt.figure(-999)
plt.clf()
plt.imshow(np.log(data), origin='lower')
apertures.plot(color='red', lw=1.5, alpha=0.5)
annulus_apertures.plot(color='orange', lw=1.5, alpha=0.5)
plt.savefig(plotname)
return final_sum[0],flagg,x,y,bkg_mean[0]
ax = pl.subplot(gs[r, 1]) # row 0, col 0
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
pl.imshow(np.fliplr(d))
dataset = h5py.File(
'/hpf/largeprojects/ccm/devin/plastics-data/general/create_2d_array/2D_data_color_1_ds8_uni_split.h5',
'r')
data = dataset.get('train_data_im')[:5]
d = data
d2 = np.fliplr(d)
print d.shape
print d2.shape
# Create 2x2 sub plots
gs = gridspec.GridSpec(5, 2)
pl.figure()
add_plot(pl, data[0], 0)
add_plot(pl, data[1], 1)
add_plot(pl, data[2], 2)
add_plot(pl, data[3], 3)
add_plot(pl, data[4], 4)
#plt.show()
plt.savefig("2d_demo_flip.png")
allcontactpairs[h] = True
for h in histo2.keys():
if not h in allcontactpairs:
allcontactpairs[h] = True
print "num. contacts in histogram:", len(histo1), len(histo2)
datafile = open(
mergeStrings(inpdb1, inpdb2).replace("/", "_") + "_contactDiff.csv", 'w')
#print "pos1,pos2,co,p1,p2,dp,nat1?,nat2?"
datafile.write("pos1,pos2,co,p1,p2,dp,nat1?,nat2?\n")
rows = []
p.figure(dpi=100)
for c in allcontactpairs:
if c in histo1:
p1 = histo1[c]
else:
p1 = 0.0
if c in histo2:
p2 = histo2[c]
else:
p2 = 0.0
res1 = c[0]
res2 = c[1]
co = abs(c[0] - c[1])
dp = p2 - p1
maxp = max(p1, p2)
''' Plot Roll noise along track (no location coordinate) '''
import matplotlib.pylab as plt
import numpy
import matplotlib as mpl
import swotsimulator.rw_data as rw_data
import numpy
import params as p
filegrid = p.indatadir + 'OREGON_grd.nc'
fileswot = p.outdatadir + 'OREGON_swot292_c01_p024.nc'
vmin = -0.10
vmax = 0.10
fig = plt.figure(figsize=(30, 10))
tloc = 0.11
tfont = 24
data = rw_data.Sat_SWOT(file=fileswot)
data.load_swath(phase_err=[], x_ac=[], x_al=[])
x_al, x_ac = numpy.meshgrid(data.x_al, data.x_ac)
x_al = x_al - numpy.min(numpy.min(x_al))
SSH = data.phase_err
stitle = 'Phase error along swath'
nac = numpy.shape(data.lon)[1]
SSH[abs(SSH) > 1000] = numpy.nan
norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
SSH[SSH == 0] = numpy.nan
SSH = numpy.ma.array(SSH, mask=numpy.isnan(SSH))
print(numpy.shape(x_al), numpy.shape(x_ac), numpy.shape(SSH))
col = plt.pcolormesh(x_al[(nac / 2), :],
x_ac[:int(nac / 2), 0],
numpy.transpose(SSH[:, :int(nac / 2)]),
norm=norm)
##popt, pcov = curve_fit(func, size[0:3], energy[0:3])
popt, pcov = curve_fit(func, size, energy, maxfev=10000)
pre = popt[0]
exponent = popt[1]
const = popt[2]
x=[i for i in np.arange(0.5*np.min(size),2.0*np.max(size),0.05)]
x = np.array(x)
yvals=func(x, pre, exponent, const)
#print('cell size equal 80', func(80, pre, exponent, const) )
#print('The denominator = ', pre*exponent )
#print('formation energy = ', func(2000, pre, exponent, const) )
#print('formation energy = ', const )
'''
plt.figure(figsize=(18.5, 10.5))
ax = plt.subplot(1, 1, 1)
#--------------------------------------------------------------------
ax.tick_params(axis='x', pad=15) # distance between axis and text
ax.tick_params(axis='y', pad=15)
#--------------------------------------------------------------------
ax.spines['left'].set_linewidth(3.0)
ax.spines['right'].set_linewidth(3.0)
ax.spines['top'].set_linewidth(3.0)
ax.spines['bottom'].set_linewidth(3.0)
#===================================================================================
plt.minorticks_on()
plt.tick_params(which='major', direction='in', width=3.0, length=12) #
plt.tick_params(which='minor', direction='in', width=3.0, length=5)
plt.xticks(fontsize=36)
result_std.to_csv('result_std.csv',encoding='utf-8', index=False)
result_var.to_csv('result_var.csv',encoding='utf-8', index=False)
#plotando os resultados
import pandas as pd
import numpy as np
import matplotlib.pylab as plt
import seaborn as sns
Result = pd.read_csv('RESULT.csv')
Result = Result.iloc[:,1:]
#Result= pd.read_csv('result_mean.csv' )
plt.figure(1)
sns.set(rc={'figure.figsize':(7,5)})
sns.set_style("whitegrid")
ylen = 0.5
#sns.set_style("darkgrid", {"axes.facecolor": ".9"})
sns.regplot(data=Result, x="SMAPE1", y="MF1", fit_reg=False, marker="+", color="skyblue")
p1=sns.regplot(data=Result, x="SMAPE1", y="MF1", fit_reg=False, marker="o", color="skyblue", scatter_kws={'s':200})
for i in range(5):
p1.text(Result.iloc[i,1], Result.iloc[i,7]+ylen, Result.iloc[i,0], horizontalalignment='center', size='larger', color='black', weight='semibold')
sns.regplot(data=Result, x="SMAPE2", y="MF2", fit_reg=False, marker="+", color="red")
p1=sns.regplot(data=Result, x="SMAPE2", y="MF2", fit_reg=False, marker="o", color="red", scatter_kws={'s':200})
for i in range(5):
p1.text(Result.iloc[i,2], Result.iloc[i,8]+ylen, Result.iloc[i,0], horizontalalignment='center', size='larger', color='black', weight='semibold')
sns.regplot(data=Result, x="SMAPE(%)", y="MF(%)", fit_reg=False, marker="+", color="yellow")
import matplotlib.pylab as plt
import numpy as np
import pandas as pd
import seaborn as sns
from math import cos, sin, log, tan, gamma, pi, exp, sqrt
p = plt.figure(figsize=(14, 14), facecolor='black', dpi=400)
p = plt.axis('off')
for z in range(200):
rango = range(z * 10, (z + 1) * 10)
plt.scatter([z * sin(z) * cos(z) * cos(z) for z in rango],
[cos(z) * sin(z) * z**2 for z in rango],
lw=4.5,
alpha=0.7,
color=plt.cm.Wistia(np.random.uniform(0, 1)))
plt.savefig(f'C:/Users/Alejandro/Pictures/RandomPlots/27012020.png',
facecolor='black')