def doFormating(**formating):
if 'title' in formating:
pylab.title(formating['title'])
if 'xlabel' in formating:
pylab.xlabel(formating['xlabel'])
if 'ylabel' in formating:
pylab.ylabel(formating['ylabel'])
def disp_results(fig, ax1, ax2, loss_iterations, losses, accuracy_iterations, accuracies, accuracies_iteration_checkpoints_ind, fileName, color_ind=0):
modula = len(plt.rcParams['axes.color_cycle'])
acrIterations =[]
top_acrs={}
if accuracies.size:
if accuracies.size>4:
top_n = 4
else:
top_n = accuracies.size -1
temp = np.argpartition(-accuracies, top_n)
result_indexces = temp[:top_n]
temp = np.partition(-accuracies, top_n)
result = -temp[:top_n]
for acr in result_indexces:
acrIterations.append(accuracy_iterations[acr])
top_acrs[str(accuracy_iterations[acr])]=str(accuracies[acr])
sorted_top4 = sorted(top_acrs.items(), key=operator.itemgetter(1))
maxAcc = np.amax(accuracies, axis=0)
iterIndx = np.argmax(accuracies)
maxAccIter = accuracy_iterations[iterIndx]
maxIter = accuracy_iterations[-1]
consoleInfo = format('\n[%s]:maximum accuracy [from 0 to %s ] = [Iteration %s]: %s ' %(fileName,maxIter,maxAccIter ,maxAcc))
plotTitle = format('max accuracy(%s) [Iteration %s]: %s ' % (fileName,maxAccIter, maxAcc))
print (consoleInfo)
#print (str(result))
#print(acrIterations)
# print 'Top 4 accuracies:'
print ('Top 4 accuracies:'+str(sorted_top4))
plt.title(plotTitle)
ax1.plot(loss_iterations, losses, color=plt.rcParams['axes.color_cycle'][(color_ind * 2 + 0) % modula])
ax2.plot(accuracy_iterations, accuracies, plt.rcParams['axes.color_cycle'][(color_ind * 2 + 1) % modula], label=str(fileName))
ax2.plot(accuracy_iterations[accuracies_iteration_checkpoints_ind], accuracies[accuracies_iteration_checkpoints_ind], 'o', color=plt.rcParams['axes.color_cycle'][(color_ind * 2 + 1) % modula])
plt.legend(loc='lower right')
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 plot_trades(self, subset=None):
if subset is None:
subset = slice(None, None)
fr = self.trades.ix[subset]
le = fr.price[(fr.pos > 0) & (fr.vol > 0)]
se = fr.price[(fr.pos < 0) & (fr.vol < 0)]
lx = fr.price[(fr.pos.shift() > 0) & (fr.vol < 0)]
sx = fr.price[(fr.pos.shift() < 0) & (fr.vol > 0)]
import matplotlib.pylab as pylab
pylab.plot(le.index, le.values, '^', color='lime', markersize=12,
label='long enter')
pylab.plot(se.index, se.values, 'v', color='red', markersize=12,
label='short enter')
pylab.plot(lx.index, lx.values, 'o', color='lime', markersize=7,
label='long exit')
pylab.plot(sx.index, sx.values, 'o', color='red', markersize=7,
label='short exit')
eq = self.equity.ix[subset].cumsum()
ix = eq.index
(eq + self.ohlc.O[ix[0]]).plot(color='red', style='-')
# self.ohlc.O.ix[ix[0]:ix[-1]].plot(color='black', label='price')
self.ohlc.O.ix[subset].plot(color='black', label='price')
pylab.title('%s\nTrades for %s' % (self, subset))
def plot(self, title=None, **kwargs):
"""Generates a pylab plot from the result set.
``matplotlib`` must be installed, and in an
IPython Notebook, inlining must be on::
%%matplotlib inline
The first and last columns are taken as the X and Y
values. Any columns between are ignored.
Parameters
----------
title: Plot title, defaults to names of Y value columns
Any additional keyword arguments will be passsed
through to ``matplotlib.pylab.plot``.
"""
import matplotlib.pylab as plt
self.guess_plot_columns()
self.x = self.x or range(len(self.ys[0]))
coords = reduce(operator.add, [(self.x, y) for y in self.ys])
plot = plt.plot(*coords, **kwargs)
if hasattr(self.x, 'name'):
plt.xlabel(self.x.name)
ylabel = ", ".join(y.name for y in self.ys)
plt.title(title or ylabel)
plt.ylabel(ylabel)
return plot
def study_redmapper_2d():
# I just want to know the typical angular separation for RM clusters.
# I'm going to do this in a lazy way.
hemi = 'north'
rm = load_redmapper(hemi=hemi)
ra = rm['ra']
dec = rm['dec']
ncl = len(ra)
dist = np.zeros((ncl, ncl))
for i in range(ncl):
this_ra = ra[i]
this_dec = dec[i]
dra = this_ra-ra
ddec = this_dec-dec
dxdec = dra*np.cos(this_dec*np.pi/180.)
dd = np.sqrt(dxdec**2. + ddec**2.)
dist[i,:] = dd
dist[i,i] = 99999999.
d_near_arcmin = dist.min(0)*60.
pl.clf(); pl.hist(d_near_arcmin, bins=100)
pl.title('Distance to Nearest Neighbor for RM clusters')
pl.xlabel('Distance (arcmin)')
pl.ylabel('N')
fwhm_planck_217 = 5.5 # arcmin
sigma = fwhm_planck_217/2.355
frac_2sigma = 1.*len(np.where(d_near_arcmin>2.*sigma)[0])/len(d_near_arcmin)
frac_3sigma = 1.*len(np.where(d_near_arcmin>3.*sigma)[0])/len(d_near_arcmin)
print '%0.3f percent of RM clusters are separated by 2-sigma_planck_beam'%(100.*frac_2sigma)
print '%0.3f percent of RM clusters are separated by 3-sigma_planck_beam'%(100.*frac_3sigma)
ipdb.set_trace()
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 pie(self, key_word_sep=" ", title=None, **kwargs):
"""Generates a pylab pie chart from the result set.
``matplotlib`` must be installed, and in an
IPython Notebook, inlining must be on::
%%matplotlib inline
Values (pie slice sizes) are taken from the
rightmost column (numerical values required).
All other columns are used to label the pie slices.
Parameters
----------
key_word_sep: string used to separate column values
from each other in pie labels
title: Plot title, defaults to name of value column
Any additional keyword arguments will be passsed
through to ``matplotlib.pylab.pie``.
"""
self.guess_pie_columns(xlabel_sep=key_word_sep)
import matplotlib.pylab as plt
pie = plt.pie(self.ys[0], labels=self.xlabels, **kwargs)
plt.title(title or self.ys[0].name)
return pie
def plot_confusion_matrix(cm, title='', cmap=plt.cm.Blues):
#print cm
#display vehicle, idle, walking accuracy respectively
#display overall accuracy
print type(cm)
# plt.figure(index
plt.imshow(cm, interpolation='nearest', cmap=cmap)
#plt.figure("")
plt.title("Confusion Matrix")
plt.colorbar()
tick_marks = [0,1,2]
target_name = ["driving","idling","walking"]
plt.xticks(tick_marks,target_name,rotation=45)
plt.yticks(tick_marks,target_name,rotation=45)
print len(cm[0])
for i in range(0,3):
for j in range(0,3):
plt.text(i,j,str(cm[i,j]))
plt.tight_layout()
plt.ylabel("Actual Value")
plt.xlabel("Predicted Outcome")
def plot_values(self, TITLE, SAVE):
plot(self.list_of_densities, self.list_of_pressures)
title(TITLE)
xlabel("Densities")
ylabel("Pressure")
savefig(SAVE)
show()
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 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 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_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 fancy_dendrogram(*args, **kwargs):
'''
Source: https://joernhees.de/blog/2015/08/26/scipy-hierarchical-clustering-and-dendrogram-tutorial/
'''
from scipy.cluster import hierarchy
import matplotlib.pylab as plt
max_d = kwargs.pop('max_d', None)
if max_d and 'color_threshold' not in kwargs:
kwargs['color_threshold'] = max_d
annotate_above = kwargs.pop('annotate_above', 0)
ddata = hierarchy.dendrogram(*args, **kwargs)
if not kwargs.get('no_plot', False):
plt.title('Hierarchical Clustering Dendrogram (truncated)')
plt.xlabel('sample index or (cluster size)')
plt.ylabel('distance')
for i, d, c in zip(ddata['icoord'], ddata['dcoord'], ddata['color_list']):
x = 0.5 * sum(i[1:3])
y = d[1]
if y > annotate_above:
plt.plot(x, y, 'o', c=c)
plt.annotate("%.3g" % y, (x, y), xytext=(0, -5),
textcoords='offset points',
va='top', ha='center')
if max_d:
plt.axhline(y=max_d, c='k')
return ddata
def viz_birth_proposal_2D(curModel, newModel, ktarget, freshCompIDs,
title1='Before Birth',
title2='After Birth'):
''' Create before/after visualization of a birth move (in 2D)
'''
from ..viz import GaussViz, BarsViz
from matplotlib import pylab
fig = pylab.figure()
h1 = pylab.subplot(1,2,1)
if curModel.obsModel.__class__.__name__.count('Gauss'):
GaussViz.plotGauss2DFromHModel(curModel, compsToHighlight=ktarget)
else:
BarsViz.plotBarsFromHModel(curModel, compsToHighlight=ktarget, figH=h1)
pylab.title(title1)
h2 = pylab.subplot(1,2,2)
if curModel.obsModel.__class__.__name__.count('Gauss'):
GaussViz.plotGauss2DFromHModel(newModel, compsToHighlight=freshCompIDs)
else:
BarsViz.plotBarsFromHModel(newModel, compsToHighlight=freshCompIDs, figH=h2)
pylab.title(title2)
pylab.show(block=False)
try:
x = raw_input('Press any key to continue >>')
except KeyboardInterrupt:
import sys
sys.exit(-1)
pylab.close()
def plot_cell(self,cell_number=0,label='insert_label'):
current_cell = self.cell_list[cell_number]
temp = current_cell.temp
cd_signal = current_cell.cd_signal
cd_calc = current_cell.cd_calc()
ax = pylab.gca()
pylab.plot(temp,cd_signal,'o',color='black')
pylab.plot(temp,cd_calc,color='black')
pylab.xlabel(r'Temperature ($^{\circ}$C)')
pylab.ylabel('mdeg')
pylab.ylim([-25,-4])
dH = numpy.round(current_cell.dH, decimals=1)
Tm = numpy.round(current_cell.Tm-273.15, decimals=1)
nf = current_cell.nf
nu = current_cell.nu
textstr_dH = '${\Delta}H_{m}$ = %.1f kcal/mol' %dH
textstr_Tm ='$T_{m}$ = %.1f $^{\circ}$C' %Tm
textstr_nf ='$N_{folded}$ = %d' %nf
textstr_nu ='$N_{unfolded}$ = %d'%nu
ax.text(8,-6,textstr_dH, fontsize=16,ha='left',va='top')
ax.text(8,-7.5,textstr_Tm, fontsize=16,ha='left',va='top')
ax.text(8,-9,textstr_nf, fontsize=16,ha='left',va='top')
ax.text(8,-10.5,textstr_nu, fontsize=16,ha='left',va='top')
pylab.title(label)
pylab.show()
return
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 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_histogram(self, main="", numrows=1, numcols=1, fignum=1):
"""Plot a histogram of choices and probability sums. Expects probabilities as (at least) a 2D array.
"""
from matplotlib.pylab import bar, xticks, yticks, title, text, axis, figure, subplot
probabilities = self.get_probabilities()
if probabilities.ndim < 2:
raise StandardError, "probabilities must have at least 2 dimensions."
alts = probabilities.shape[1]
width_par = (1 / alts + 1) / 2.0
choice_counts = self.get_choice_histogram(0, alts)
sum_probs = self.get_probabilities_sum()
subplot(numrows, numcols, fignum)
bar(arange(alts), choice_counts, width=width_par)
bar(arange(alts) + width_par, sum_probs, width=width_par, color="g")
xticks(arange(alts))
title(main)
Axis = axis()
text(
alts + 0.5,
-0.1,
"\nchoices histogram (blue),\nprobabilities sum (green)",
horizontalalignment="right",
verticalalignment="top",
)
def ACF_PACF_plot(self):
#plot ACF and PACF to find the number of terms needed for the AR and MA in ARIMA
# ACF finds MA(q): cut off after x lags
# and PACF finds AR (p): cut off after y lags
# in ARIMA(p,d,q)
lag_acf = acf(self.ts_log_diff, nlags=20)
lag_pacf = pacf(self.ts_log_diff, nlags=20, method='ols')
#Plot ACF:
ax=plt.subplot(121)
plt.plot(lag_acf)
ax.set_xlim([0,5])
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y= -1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
plt.axhline(y= 1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
plt.title('Autocorrelation Function')
#Plot PACF:
plt.subplot(122)
plt.plot(lag_pacf)
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y= -1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
plt.title('Partial Autocorrelation Function')
plt.tight_layout()
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 EnhanceContrast(g, r=3, op_kernel=15, silence=True):
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(op_kernel,op_kernel))
opening = cv2.morphologyEx(g, cv2.MORPH_OPEN, kernel)
g_copy = np.asarray(np.copy(g), dtype=np.float)
m_f = np.mean(opening)
u_max = 245; u_min = 10; t_min = np.min(g); t_max = np.max(g)
idx_gt_mf = np.where(g_copy > m_f)
idx_lt_mf = np.where(g_copy <= m_f)
g_copy[idx_gt_mf] = -0.5 * ((u_max-u_min) / (m_f-t_max)**r) * (g_copy[idx_gt_mf]-t_max)**r + u_max
g_copy[idx_lt_mf] = 0.5 * ((u_max-u_min) / (m_f-t_min)**r) * (g_copy[idx_lt_mf]-t_min)**r + u_min
if silence == False:
plt.subplot(1,2,1)
plt.imshow(g, cmap='gray')
plt.title('Original image')
plt.subplot(1,2,2)
plt.imshow(g_copy, cmap='gray')
plt.title('Enhanced image')
plt.show()
return g_copy
def static_view(self, m=0, n=1, NS=100):
"""=============================================================
Grafica Estatica (m,n) Modo normal:
Realiza un grafico de densidad del modo de oscilación (m,n)
de la membrana circular en el tiempo t=0
ARGUMENTOS:
*Numero cuantico angular m
*Numero cuantico radial n
*Resolucion del grid (100 por defecto) NS
============================================================="""
# Grid
XM = np.linspace(-1 * self.R, 1 * self.R, NS)
YM = np.linspace(1 * self.R, -1 * self.R, NS)
# ---------------------------------------------------------------
Z = np.zeros((NS, NS))
for i in xrange(0, NS):
for j in xrange(0, NS):
xd = XM[i]
yd = YM[j]
rd = (xd ** 2 + yd ** 2) ** 0.5
thd = np.arctan(yd / xd)
if xd < 0:
thd = np.pi + thd
if rd < self.R:
Z[j, i] = self.f(rd, thd, 0, m, n)
# ---------------------------------------------------------------
Z[0, 0] = -1
Z[1, 0] = 1
plt.xlabel("X (-R,R)")
plt.ylabel("Y (-R,R)")
plt.title("Circular Membrane: (%d,%d) mode" % (m, n))
plt.imshow(Z)
plt.show()
def predict(self,train,test,w,progress=False):
'''
1-nearest neighbor classification algorithm using LB_Keogh lower
bound as similarity measure. Option to use DTW distance instead
but is much slower.
'''
for ind,i in enumerate(test):
if progress:
print str(ind+1)+' points classified'
min_dist=float('inf')
closest_seq=[]
for j in train:
if self.LB_Keogh(i,j[:-1],5)<min_dist:
dist=self.DTWDistance(i,j[:-1],w)
if dist<min_dist:
min_dist=dist
closest_seq=j
self.preds.append(closest_seq[-1])
if self.plotter:
plt.plot(i)
plt.plot(closest_seq[:-1])
plt.legend(['Test Series','Nearest Neighbor in Training Set'])
plt.title('Nearest Neighbor in Training Set - Prediction ='+str(closest_seq[-1]))
plt.show()
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 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 plot_histogram_with_capacity(self, capacity, main=""):
"""Plot histogram of choices and capacities. The number of alternatives is determined
from the second dimension of probabilities.
"""
from matplotlib.pylab import bar, xticks, yticks, title, text, axis, figure, subplot
probabilities = self.get_probabilities()
if probabilities.ndim < 2:
raise StandardError, "probabilities must have at least 2 dimensions."
alts = self.probabilities.shape[1]
width_par = (1 / alts + 1) / 2.0
choice_counts = self.get_choice_histogram(0, alts)
sum_probs = self.get_probabilities_sum()
subplot(212)
bar(arange(alts), choice_counts, width=width_par)
bar(arange(alts) + width_par, capacity, width=width_par, color="r")
xticks(arange(alts))
title(main)
Axis = axis()
text(
alts + 0.5,
-0.1,
"\nchoices histogram (blue),\ncapacities (red)",
horizontalalignment="right",
verticalalignment="top",
)
sns.set_context('poster')
plt.subplots(figsize=(20, 8))
#make 5000 noise and 1000 of each x sample
N_samples = 1000
noise = np.random.randn(5 * N_samples, noise_dim).astype('float32')
x_gen = np.repeat(xgen, 1000)
x_gen = x_gen.reshape(5000, 1)
#plug into posterior
z_samples = posterior(x_gen, noise)
z_samples = tf.reshape(z_samples, [xgen.shape[0], N_samples, 2]).eval()
for i in range(5):
plt.subplot(2, 5, i + 1)
sns.kdeplot(z_samples[i, :, 0], z_samples[i, :, 1], cmap='Greens')
plt.axis('square')
plt.title('q(z|x={})'.format(y[i]))
plt.xlim([xmin, xmax])
plt.ylim([xmin, xmax])
plt.xticks([])
plt.yticks([])
plt.subplot(2, 5, 5 + i + 1)
plt.contour(xrange,
xrange,
np.exp(logprior + llh[i]).reshape(300, 300).T,
cmap='Greens')
plt.axis('square')
plt.title('p(z|x={})'.format(y[i]))
plt.xlim([xmin, xmax])
plt.ylim([xmin, xmax])
plt.xticks([])
plt.yticks([])
myrecording = sd.rec(int(duration * fs), samplerate=fs, channels=1)
sd.wait()
sampling_period = 1 / fs
final = lenghtBits / 2
ts = pyl.arange(0, final, sampling_period)
data = cut_unused_data(myrecording)
plot_x = pyl.arange(0, len(data) * sampling_period, sampling_period)
# Demodulation of received data
originalBits = custom_demodulation(ts, data, lenghtBits)
# Plotting received data
pyl.plot(plot_x, data)
pyl.title("Senal recibida por receiver")
pyl.xlabel("Tiempo (s)")
pyl.ylabel("Nivel de senal")
pyl.show()
# delete first bit
originalBits = originalBits[1:]
# split up data
[bits1, bits2] = from_CDMA_to_bits(originalBits)
print(bits1)
print(bits2)
# converting bits to image
bits_to_imageBW(bits1, "result_1")
bits_to_imageBW(bits2, "result_2")
if (file + ".png") in outs: continue
if not file.endswith(".wav"): continue
if count >= threshold: sys.exit(0)
winsize=512
shift=256
fh=600
fl=60
filename = file
wavefile = wave.open(path + "/" + dir + "/" + filename, 'r') # open for writing
nchannels = wavefile.getnchannels()
sample_width = wavefile.getsampwidth()
framerate = wavefile.getframerate()
numframes = wavefile.getnframes()
# get wav_data
wav_data = wavefile.readframes(-1)
wav_data = np.fromstring(wav_data, 'Int16')
Time=np.linspace(0, len(wav_data)/framerate, num=len(wav_data))
pl.figure(1)
pl.title('Signal Wave...')
pl.plot(Time,wav_data)
Fs = framerate
pl.figure(2)
pl.subplots_adjust(left=0,right=1,bottom=0,top=1)
pl.specgram(wav_data, NFFT=1024, Fs=Fs, noverlap=512)
pl.axis('off')
pl.axis('tight')
pl.savefig(out + "/" + dir + '/%s.png' % filename)
count += 1
print(dir + ": " + count + " for this round")
if i == 0:
pl.text(0.5, 1.2, str(AntNos[j]), transform=ax.transAxes)
if j == Nant - 1:
pl.text(1.2, 0.5, str(AntNos[i]), transform=ax.transAxes)
#Give a sample plot
pl.subplot(337)
bl = bls[0]
i, j = np.argwhere(AntNos == bl[0]).squeeze(), np.argwhere(
AntNos == bl[1]).squeeze()
pl.vlines(D_ij[pol][bl] / bl_len[bl], 0, 1.1, color='k')
pl.vlines((Tau[pol][i] - Tau[pol][j]) / bl_len[bl], 0, 1.1, color='r')
pl.vlines((-1, 1), 0, 1.1, linestyles='dotted', color='k')
pl.plot(delays / bl_len[bl], DD[pol][bl], 'b')
pl.title('Sample baseline, %d_%d' % bl)
pl.xlim([-1.5, 1.5])
pl.ylim([0, 1.1])
pl.xlabel('Delay, baseline lenghth.')
pl.ylabel('Amplitude')
pl.subplots_adjust(wspace=0, hspace=0, top=0.95, bottom=0.05)
pl.draw()
figcnt += 1
#Plot a matrix of all delays
for pol in pols:
pl.figure(figcnt)
DDD = np.zeros((Nant, Nant))
for i, ant1 in enumerate(AntNos):
for j, ant2 in enumerate(AntNos):
sol = odeint(satelite,z0,t)
x_s = sol[:,0]
y_s = sol[:,1]
z_s = sol[:,2]
y_1=[-5e6,0,5e6]
eje_y=["-5000","0","5000"]
x_1=[0,18000,36000,54000,72000,90000]
eje_x=["0","5","10","15","20","25"]
plt.figure()
plt.subplot(3,1,1)
plt.title("Posición")
plt.ylabel("X (KM)")
plt.plot(t,x)
plt.plot(t,x_s)
plt.yticks(y_1,eje_y)
plt.xticks(x_1,eje_x)
plt.subplot(3,1,2)
plt.ylabel("Y (KM)")
plt.plot(t,y)
plt.plot(t,y_s)
plt.yticks(y_1,eje_y)
def _plot_seasonality(self, alpha: float, plot_kwargs: bool):
# two_tailed_alpha = int(alpha / 2 * 100)
periods = list(set([float(i.split("_")[1]) for i in self.seasonality]))
additive_ts, multiplicative_ts = self._fit_seasonality()
all_seasonalities = [("additive", additive_ts)]
if len(self.multiplicative_data):
all_seasonalities.append(("multiplicative", multiplicative_ts))
for sn, ts in all_seasonalities:
if (sn == "multiplicative"
and np.sum(ts) == 1) or (sn == "additive"
and np.sum(ts) == 0):
continue
ddf = pd.DataFrame(
np.vstack([
np.percentile(ts[:, :, self.skip_first:], 50, axis=-1),
np.percentile(ts[:, :, self.skip_first:],
alpha / 2 * 100,
axis=-1),
np.percentile(ts[:, :, self.skip_first:],
(1 - alpha / 2) * 100,
axis=-1),
]).T,
columns=[
"%s_%s" % (p, l) for l in ["mid", "low", "high"]
for p in periods[::-1]
],
)
ddf.loc[:, "ds"] = self.data["ds"]
for period in periods:
if int(period) == 0:
step = int(self.data["ds"].diff().mean().total_seconds() //
float(period))
else:
step = int(period)
graph = ddf.head(step)
if period == 7:
ddf.loc[:, "dow"] = [i for i in ddf["ds"].dt.weekday]
graph = (ddf[[
"dow",
"%s_low" % period,
"%s_mid" % period,
"%s_high" % period,
]].groupby("dow").mean().sort_values("dow"))
graph.loc[:, "ds"] = [[
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
][i] for i in graph.index]
graph = graph.sort_index()
plt.figure(**plot_kwargs)
graph.plot(y="%s_mid" % period,
x="ds",
color="C0",
legend=False,
ax=plt.gca())
plt.grid()
if period == 7:
plt.xticks(range(7), graph["ds"].values)
plt.fill_between(
np.arange(0, 7),
graph["%s_low" % period].values.astype(float),
graph["%s_high" % period].values.astype(float),
alpha=0.3,
)
else:
plt.fill_between(
graph["ds"].values,
graph["%s_low" % period].values.astype(float),
graph["%s_high" % period].values.astype(float),
alpha=0.3,
)
plt.title("Model Seasonality (%s) for period: %s days" %
(sn, period))
plt.axes().xaxis.label.set_visible(False)
plt.show()
print('分类精度r4:%.2f%%'%(r4*100))#
print('F1:%.2f%%'%(f1*100))
print('RMSE:', mean_squared_error(y_test, y_pred) ** 0.5) #迭代寻优后REMS更小
print('AUC:%.2f%%'%(roc_auc * 100))#
#画图roc
plt.figure()
lw = 2
plt.figure(figsize=(10,10))
plt.plot(fpr, tpr, color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc) ###假正率为横坐标，真正率为纵坐标做曲线
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
plt.figure()
lw = 2
nnn=range(1,99)
plt.plot(nnn,test_RMSE[1:99], color='darkorange',lw=lw,label = 'test') ###假正率为横坐标，真正率为纵坐标做曲线
plt.plot(nnn,train_RMSE[1:99], color='navy', lw=lw, linestyle='--',label = 'train')
plt.xlabel('Iterations')
plt.ylabel('RMSE')
plt.title('Receiver operating characteristic example')
plt.legend(loc='best')
plt.show()
from matplotlib import pylab
import matplotlib
legs = [
'esmf eval',
'esmf wgts',
]
pylab.loglog(ns, esmf_eval, 'ro', markersize=8)
pylab.loglog(ns, esmf_weights, 'rs', markersize=8)
if args.nprocs > 1:
pylab.loglog(ns, esmf_eval_par, 'co', markersize=8)
pylab.loglog(ns, esmf_weights_par, 'cs', markersize=8)
legs += [
'esmf eval {}p'.format(args.nprocs),
'esmf wgts {}p'.format(args.nprocs)
]
pylab.legend(legs, loc=4)
pylab.plot(ns, esmf_eval, 'r-')
pylab.plot(ns, esmf_weights, 'r--')
if args.nprocs > 1:
pylab.plot(ns, esmf_eval_par, 'c-')
pylab.plot(ns, esmf_weights_par, 'c--')
pylab.xlabel('num src cells * num dst cells')
pylab.ylabel('time [sec]')
pylab.title('conservative interpolation tripolar to rectilinear')
pylab.savefig('run_conserve.png')
pylab.show()
mu_p_psd_plot = BO2.model.model.likelihood.gp_link.transf(mu_psd_plot)
labels = ['X', 'Y', 'Z']
## In p space
for i in range(3):
plt.figure()
plt.plot(x_plot, y_plot[:, i], 'r')
plt.plot(x_plot, mu_p_plot[:, i], 'b--')
plt.fill_between(np.squeeze(x_plot),
mu_p_msd_plot[:, i],
mu_p_psd_plot[:, i],
alpha=0.2,
facecolor='blue')
plt.hlines(tgt_1s[i], *domain_alpha)
plt.title(labels[i] + 'pspace')
#in f space
for i in range(3):
plt.figure()
plt.plot(x_plot, fy_plot[:, i], 'r')
plt.plot(x_plot, mu_plot[:, i], 'b--')
plt.fill_between(np.squeeze(x_plot),
mu_msd_plot[:, i],
mu_psd_plot[:, i],
alpha=0.2,
facecolor='blue')
plt.hlines(f_tgt_1s[i], *domain_alpha)
plt.title(labels[i] + 'fspace')
#=======================================#
nlp.n_ineq_constraints()))
print("Total number of constraints: {:>17d}".format(nlp.n_constraints()))
print("Number of nnz in Jacobian: {:>20d}".format(nlp.nnz_jacobian()))
print("Number of nnz in hessian of Lagrange: {:>8d}".format(
nlp.nnz_hessian_lag()))
x = nlp.init_primals().copy()
y = nlp.create_new_vector('duals')
y.fill(1.0)
nlp.set_primals(x)
nlp.set_duals(y)
# Evaluate jacobian of all constraints
jac_full = nlp.evaluate_jacobian()
plt.spy(jac_full)
plt.title('Jacobian of the all constraints\n')
plt.show()
# Evaluate jacobian of the equality constraints
jac = nlp.evaluate_jacobian_eq()
plt.title('Jacobian of the equality constraints\n')
plt.spy(jac)
plt.show()
# Evaluate jacobian of the inequality constraints
jac = nlp.evaluate_jacobian_ineq()
plt.title('Jacobian of the inequality constraints\n')
plt.spy(jac)
plt.show()
# Evaluate hessian of the lagrangian
def plot_mean_relation_gp(mp, gp, Xs, Ys1, Ys2):
from examples.kllr import Plot_Fit_Split
df = pd.DataFrame({'x': Xs[0], 'm': Xs[1], 'stars': Ys1, 'gas': Ys2})
x1 = np.linspace(-1.0, 0.5, 201)
x2 = np.array([12.25, 12.75, 13.5])
X_new = pm.math.cartesian(x1[:, None], x2[:, None])
plt.figure(figsize=(12, 10))
ax = plt.subplot(2, 2, 1)
plt.scatter(Xs[0], Ys1, s=2, color='lightsteelblue', alpha=0.5)
plot_mean_profile_fit(X_new,
mp,
gp[0],
x2_dim_len=3,
ax=ax,
color=['darkmagenta', 'black', 'darkgreen'],
label=[
r'$\log_{10}(M_{200}) = 12.25$',
r'$\log_{10}(M_{200}) = 12.75$',
r'$\log_{10}(M_{200}) = 13.5$'
])
plt.xlim([-1.0, 0.5])
plt.ylim([-3.0, 3.0])
plt.xticks([-1, -0.5, 0.0, 0.5], 4 * [' '])
plt.ylabel(r'$\log(\rho_{\rm \star} / 10^{10})$', size=22)
plt.title('GP Fits', size=20)
plt.grid()
plt.legend(loc=3, prop={'size': 12})
ax = plt.subplot(2, 2, 2)
plt.scatter(Xs[0], Ys1, s=2, color='lightsteelblue', alpha=0.5)
ax = Plot_Fit_Split(df,
'x',
'stars',
'm',
split_bins=[12, 12.5, 13, 14],
show_data=False,
nbins=25,
xrange=[-1.2, 0.6],
split_mode='Data',
kernel_type='gaussian',
kernel_width=0.15,
xlog=False,
labels=[r' ', r' ', r'$\log_{10}(M_{200})$'],
color=['darkmagenta', 'black', 'darkgreen'],
ax=ax)
plt.legend(loc=3, prop={'size': 12})
plt.xlim([-1.0, 0.5])
plt.ylim([-3.0, 3.0])
plt.xticks([-1, -0.5, 0.0, 0.5], 4 * [' '])
plt.yticks([-3, -2, -1, 0, 1, 2, 3], 7 * [' '])
plt.title('KLLR Fits', size=20)
ax = plt.subplot(2, 2, 3)
plt.scatter(Xs[0], Ys2, s=2, color='lightcoral', alpha=0.5)
plot_mean_profile_fit(X_new,
mp,
gp[1],
x2_dim_len=3,
ax=ax,
color=['darkmagenta', 'black', 'darkgreen'],
label=[
r'$\log_{10}(M_{200}) = 12.25$',
r'$\log_{10}(M_{200}) = 12.75$',
r'$\log_{10}(M_{200}) = 13.5$'
])
plt.xlim([-1.0, 0.5])
plt.ylim([-2.0, 2.0])
plt.xticks([-1, -0.5, 0.0, 0.5], ['-1', '-0.5', '0', '0.5'])
plt.yticks([-2, -1, 0, 1, 2], ['-2', '-1', '0', '1', '2'])
plt.xlabel(r'$\log_{10}\left(\frac{r}{R_{200}}\right)$', size=22)
plt.ylabel(r'$\log_{10}(\rho_{\rm gas} / 10^{12})$', size=22)
plt.grid()
plt.legend(loc=3, prop={'size': 12})
ax = plt.subplot(2, 2, 4)
plt.scatter(Xs[0], Ys2, s=2, color='lightcoral', alpha=0.5)
ax = Plot_Fit_Split(df,
'x',
'gas',
'm',
split_bins=[12, 12.5, 13, 14],
show_data=False,
nbins=25,
xrange=[-1.2, 0.6],
split_mode='Data',
kernel_type='gaussian',
kernel_width=0.15,
xlog=False,
labels=[r' ', r' ', r'$\log_{10}(M_{200})$'],
color=['darkmagenta', 'black', 'darkgreen'],
ax=ax)
plt.legend(loc=3, prop={'size': 12})
plt.xlim([-1.0, 0.5])
plt.ylim([-2.0, 2.0])
plt.xticks([-1, -0.5, 0.0, 0.5], [' ', '-0.5', '0', '0.5'])
plt.yticks([-2, -1, 0, 1, 2], 5 * [' '])
plt.xlabel(r'$\log_{10}\left(\frac{r}{R_{200}}\right)$', size=22)
plt.subplots_adjust(hspace=0.05, wspace=0.05)
check_directory('./plots/')
plt.savefig('./plots/inferred_mean_relation_TNG.png', bbox_inches='tight')
plt.close()
# 修改x轴信息 并用字符串代取具体的刻度
_x = list(x)
# 实际就是三个列表的累加拼接
_xtick_labels = [
'10:{}'.format('0{}'.format(i) if i < 9 else '{}'.format(i))
for i in range(61)
]
_xtick_labels += [
'11:{}'.format('0{}'.format(i) if i < 9 else '{}'.format(i))
for i in range(61)
]
_xtick_labels += [
'12:{}'.format('0{}'.format(i) if i < 9 else '{}'.format(i))
for i in range(61)
]
# 1分钟一个刻度过于密集 写了3分钟一个刻度
# 修改y轴信息 使y轴数据更加清晰
_y = range(20, 36)
pylab.yticks(_y, ['{}℃'.format(i) for i in _y])
# 刻度尺步长为3 对应的字符串也为3 并且旋转45度
pylab.xticks(_x[::3], _xtick_labels[::3], rotation=45)
# 绘制网格 0.0 - 1.0 清晰度
pylab.grid(alpha=0.1)
pylab.title('2020-10-1号 10:00点--12:00点 三小时温度变化')
# pylab.show()
pylab.savefig('./matp.png')
pylab.close('all')
fig0 = pylab.figure(figsize=(10, 8))
pylab.subplot(2, 1, 1)
pylab.plot(stock_data['GOOG']['Close'], 'r-', label='GOOG', linewidth=1.5)
pylab.plot(stock_data['YHOO']['Close'], 'b--', label='YHOO', linewidth=1.0)
pylab.plot(stock_data['AAPL']['Close'], 'm-.', label='AAPL', linewidth=2.0)
pylab.plot(stock_data['MSFT']['Close'], 'k-', label='MSFT', linewidth=1.0)
pylab.plot(stock_data['AMZN']['Close'], 'y-', label='AMZN', linewidth=1.0)
pylab.ylabel('Close Price')
pylab.setp(pylab.gca().get_xticklabels(), FontSize=8, rotation=45)
h = pylab.legend(loc='upper left')
pylab.title('IT industry stocks')
pylab.grid('on')
pylab.subplot(2, 1, 2)
pylab.plot(stock_data['JPM']['Close'], 'r-', label='JPM', linewidth=1.5)
pylab.plot(stock_data['BAC']['Close'], 'b-', label='BAC', linewidth=1.0)
pylab.plot(stock_data['HSBC']['Close'], 'm:', label='HSBC', linewidth=2.0)
pylab.plot(stock_data['CIT']['Close'], 'k-', label='CIT', linewidth=2.5)
pylab.plot(stock_data['GS']['Close'], 'y-', label='GS', linewidth=1.0)
pylab.xlabel('Trading time')
pylab.ylabel('Close Price')
pylab.legend(loc='upper left')
pylab.setp(pylab.gca().get_xticklabels(), FontSize=8, rotation=45)
pylab.title('Bank industry stocks')
print("Function for CPU: \n", Fcpu)
print("Function for RAM: \n", Fram)
print("Function for Flash: \n", Fflash)
# Show results graphically
Fnew = np.linspace(0, 1500, 10)
Zbnew = Fbaseline(Fnew)
Zcnew = Fcpu(Fnew)
Zfnew = Fflash(Fnew)
Zrnew = Fram(Fnew)
# Plot the data points
plt.plot(Frequency, Pbaseline, '.')
plt.plot(Frequency, Pcpu, 'x')
plt.plot(Frequency, Pflash, 'o')
plt.plot(Frequency, Pram, '*')
# Plot the approximated function
plt.plot(Fnew, Zbnew, label='Baseline')
plt.plot(Fnew, Zcnew, label='CPU')
plt.plot(Fnew, Zfnew, label='Flash')
plt.plot(Fnew, Zrnew, label='RAM')
# Plot
title = "Frequenct vs Power at " + str(Tambient) + "C"
pylab.title(title)
plt.xlabel('Frequency')
plt.ylabel('Total Power')
legend = plt.legend(loc='best')
plt.show()
# Create data, which are not that well sampled
dw = np.linspace(5000,5010,200)
df = np.exp(-(dw-5004.17)**2/(2.*0.1**2))
else:
# Create the template
tw = hdu_hr_260[1].data.field('WAVELENGTH')[0]
tf = hdu_hr_260[1].data.field('FLUX')[0]
te = hdu_hr_260[1].data.field('ERROR')[0]
# Create data, which are not that well sampled
dw = hdu_hr_4521[1].data.field('WAVELENGTH')[0]
df = hdu_hr_4521[1].data.field('FLUX')[0]
de = hdu_hr_4521[1].data.field('ERROR')[0]
# Plot template and data
plt.title("Template (blue) and data (red)")
plt.plot(tw, tf, 'b.-')
plt.plot(dw, df, 'r.-')
plt.show()
"""
test = radial_velocity(dw, df, de, # spectral data on your target (uncertainty is NOT SNR)
tw, tf, te, # spectral data on a star with known RV, in the same (or at least overlapping) wavelength region
'HR_4521', 'HR_260', # their names, for the plots (see point 2 below for details)
0.3, 0.01, # the radial velocity of the standard, for the plots
1, # for the plots. Should be the same for both.
200, # set to 200 for 'default', see point 3 below for what this means
0, 0, 0) # set all to zero by default. See point 4 below for what this means
print(test)
"""
def plot_learning_curve(estimator,
title,
X,
y,
ylim=None,
n_jobs=1,
train_sizes=[100, 300, 600, 1000, 1886],
cv=10,
verbose=0,
plot=True):
"""
画出data在某模型上的learning curve.
参数解释
----------
estimator : 你用的分类器。
title : 表格的标题。
X : 输入的feature，numpy类型
y : 输入的target vector
ylim : tuple格式的(ymin, ymax), 设定图像中纵坐标的最低点和最高点
cv : 做cross-validation的时候，数据分成的份数，其中一份作为cv集，其余n-1份作为training(默认为3份)
n_jobs : 并行的的任务数(默认1)
"""
train_sizes, train_scores, test_scores = learning_curve(
estimator,
X,
y,
cv=cv,
n_jobs=n_jobs,
train_sizes=train_sizes,
verbose=verbose)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
if plot:
plt.figure()
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel(u"train_sample")
plt.ylabel(u"score")
plt.gca().invert_yaxis()
plt.grid()
plt.fill_between(train_sizes,
train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std,
alpha=0.1,
color="b")
plt.fill_between(train_sizes,
test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std,
alpha=0.1,
color="r")
plt.plot(train_sizes,
train_scores_mean,
'o-',
color="b",
label=u"train_score")
plt.plot(train_sizes,
test_scores_mean,
'o-',
color="r",
label=u"cross_validation_score")
plt.legend(loc="best")
plt.draw()
plt.show()
plt.gca().invert_yaxis()
plt.savefig("learn_curve.jpg")
midpoint = ((train_scores_mean[-1] + train_scores_std[-1]) +
(test_scores_mean[-1] - test_scores_std[-1])) / 2
diff = (train_scores_mean[-1] + train_scores_std[-1]) - (
test_scores_mean[-1] - test_scores_std[-1])
return midpoint, diff
def ecdf(a, **kwargs):
sorted=np.sort( a )
yvals=np.arange(len(sorted))/float(len(sorted))
plt.plot( sorted, yvals, **kwargs )
plt.title("$\mu=%.2f, \sigma=%.2f, max=%.2f$" % (np.mean(a), np.std(a), np.max(a)))
for V_bias in [50, 150]:
for n_eff in [1e12, 5e12]:
E_x, E_y = get_field(x=None,
y=y_1d,
V_bias=V_bias,
n_eff=n_eff,
D=thickness,
is_planar=True)
plt.plot(
y_1d,
E_y,
linewidth=2.,
label='$\mathrm{V_{bias} = %d}$ V, $\mathrm{N_{eff} = %1.2e}$'
% (V_bias, n_eff))
plt.title('Electric field between planar sensor electrodes')
plt.xlabel('Position [um]')
plt.ylabel('Electric field [V/um]')
plt.legend(loc=0)
plt.grid()
plt.savefig('Electric_field_planar_1D.pdf', layout='tight')
plt.show()
# Plot planar electric field in 2 dim, full fill factor assumed
E_x, E_y = get_field(x,
y,
V_bias=20.,
n_eff=1e12,
D=thickness,
S=None,
is_planar=True)
dtype=float,
delimiter=',')
testLabel = numpy.argmax(testLabel, axis=1)
auc = AUC_Calculation(testLabel=testLabel,
probability=probability,
figureFlag=True,
showFlag=False,
legend='Batch-%d' % appoint)
result, matrix = Result_Calculation(testLabel=testLabel,
probability=probability)
result.append(auc)
totalResult.append(result)
matrixList.append(matrix)
plt.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6), label='Luck')
plt.legend()
plt.title(savename)
plt.xlabel('fpr (%)')
plt.ylabel('tpr (%)')
plt.savefig(savepath + savename + '.png')
plt.clf()
plt.close()
# plt.show()
# print(totalResult)
book = xlwt.Workbook(encoding='utf-8', style_compression=0)
sheet = book.add_sheet('test', cell_overwrite_ok=True)
sheet.write_merge(0, 0, 0, 4, savename)
sheet.write(1, 1, 'Precision')
sheet.write(1, 2, 'Sensitivity')
sheet.write(1, 3, 'Specificity')
straighten_worm_intensity = fid.get_node(
'/straighten_worm_intensity')[:]
if straighten_worm_intensity.shape[0] < 1000:
continue
except:
bad_f.append(fname)
s_int = np.median(straighten_worm_intensity,
axis=0).astype(np.uint8)
if row['ventral_orientation'] == 'CCW':
s_int = s_int[:, ::-1]
save_name = os.path.join(save_dir, row['base_name'] + '_map.png')
cv2.imwrite(save_name, s_int)
s_intensities.append((row['day'], s_int))
tot = len(s_intensities)
plt.figure(figsize=(1 * tot, 7))
for ii, (f, s_int) in enumerate(s_intensities):
ax = plt.subplot(1, tot, ii + 1)
plt.imshow(s_int)
plt.title(f)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
strT = 'S{}_R{}_W{}'.format(row['strain'], row['replicated_n'],
row['worm_id'])
plt.suptitle(strT)
plt.savefig(os.path.join(save_dir_s, strT + '.png'))
import matplotlib.pylab as plt
plt.figure()
sol = odeint(satelite, z_0, T)
x = sol[:, 0]
y = sol[:, 1]
z = sol[:, 2]
r_atmosfera = (6371 + 80) * 1000
tetha = np.linspace(0, 2 * 3.14, 100)
X = r_atmosfera * np.cos(tetha)
Y = r_atmosfera * np.sin(tetha)
plt.plot(T, y)
plt.hlines(y=radio_tierra, xmin=0, xmax=14000, color="green")
plt.hlines(y=radio_orbita, xmin=0, xmax=14000, color="orange")
plt.hlines(y=-radio_tierra, xmin=0, xmax=14000, color="green")
plt.hlines(y=-radio_orbita, xmin=0, xmax=14000, color="orange")
plt.title("Distancia satelite, tierra y orbita respecto al tiempo.")
plt.ylabel("Posicion (m)")
plt.xlabel("tiempo (s)")
plt.grid(True)
plt.legend(["r(t)", "Radio tierra", "Radio orbita"])
plt.savefig("Distancia satelite, tierra y orbita respecto al tiempo.png")
plt.show()
def testVisilibity():
# Define an epsilon value (should be != 0.0)
epsilon = 0.0000001
# Define the points which will be the outer boundary of the environment
# Must be COUNTER-CLOCK-WISE(ccw)
p1 = vis.Point(0, 0)
p2 = vis.Point(700, 0)
p3 = vis.Point(700, 900)
p4 = vis.Point(0, 900)
# Load the values of the outer boundary polygon in order to draw it later
wall_x = [p1.x(), p2.x(), p3.x(), p4.x(), p1.x()]
wall_y = [p1.y(), p2.y(), p3.y(), p4.y(), p1.y()]
# Outer boundary polygon must be COUNTER-CLOCK-WISE(ccw)
# Create the outer boundary polygon
walls = vis.Polygon([p1, p2, p3, p4])
# Define the point of the "observer"
observer = vis.Point(235, 400)
# Uncomment the following line in order to create a cone polygon
# walls = create_cone((observer.x(), observer.y()), 500, 270, 30, quality= 3)
# Walls should be in standard form
print('Walls in standard form : ', walls.is_in_standard_form())
# Now we define some holes for our environment. The holes must be inside
# our outer boundary polygon. A hole blocks the observer vision, it works as
# an obstacle in his vision sensor.
# We define some point for a hole. You can add more points in order to get
# the shape you want.
# The smalles point should be first
p2 = vis.Point(100, 300)
p3 = vis.Point(100, 500)
p4 = vis.Point(150, 500)
p1 = vis.Point(150, 300)
# Load the values of the hole polygon in order to draw it later
hole_x = [p1.x(), p2.x(), p3.x(), p4.x(), p1.x()]
hole_y = [p1.y(), p2.y(), p3.y(), p4.y(), p1.y()]
# Note: The point of a hole must be in CLOCK-WISE(cw) order.
# Create the hole polygon
hole = vis.Polygon([p2, p3, p4, p1])
# Check if the hole is in standard form
print('Hole in standard form: ', hole.is_in_standard_form())
# Define another point of a hole polygon
# Remember: the list of points must be CLOCK-WISE(cw)
p1 = vis.Point(300, 300)
p2 = vis.Point(300, 500)
p3 = vis.Point(400, 550)
p4 = vis.Point(400, 300)
# Load the values of the hole polygon in order to draw it later
hole1_x = [p1.x(), p2.x(), p3.x(), p4.x(), p1.x()]
hole1_y = [p1.y(), p2.y(), p3.y(), p4.y(), p1.y()]
# Create the hole polygon
hole1 = vis.Polygon([p1, p2, p3, p4])
# Check if the hole is in standard form
print('Hole in standard form: ', hole1.is_in_standard_form())
# Define another point of a hole polygon
# Remember: the list of points must be CLOCK-WISE(cw)
p2 = vis.Point(90, 700)
p3 = vis.Point(250, 750)
p4 = vis.Point(220, 600)
p1 = vis.Point(150, 600)
# Load the values of the hole polygon in order to draw it later
hole2_x = [p1.x(), p2.x(), p3.x(), p4.x(), p1.x()]
hole2_y = [p1.y(), p2.y(), p3.y(), p4.y(), p1.y()]
# Create the hole polygon
hole2 = vis.Polygon([p2, p3, p4, p1])
# Check if the hole is in standard form
print('Hole in standard form: ', hole2.is_in_standard_form())
# Define another point of a hole polygon
# Remember: the list of points must be CLOCK-WISE(cw)
p1 = vis.Point(330, 700)
p2 = vis.Point(330, 800)
p3 = vis.Point(530, 850)
p4 = vis.Point(530, 790)
# Load the values of the hole polygon in order to draw it later
hole3_x = [p1.x(), p2.x(), p3.x(), p4.x(), p1.x()]
hole3_y = [p1.y(), p2.y(), p3.y(), p4.y(), p1.y()]
# Create the hole polygon
hole3 = vis.Polygon([p1, p2, p3, p4])
# Check if the hole is in standard form
print('Hole in standard form: ', hole3.is_in_standard_form())
# Define another point of a hole polygon
# Remember: the list of points must be CLOCK-WISE(cw)
p1 = vis.Point(230, 50)
p2 = vis.Point(250, 90)
p3 = vis.Point(390, 90)
p4 = vis.Point(390, 50)
# Load the values of the hole polygon in order to draw it later
hole4_x = [p1.x(), p2.x(), p3.x(), p4.x(), p1.x()]
hole4_y = [p1.y(), p2.y(), p3.y(), p4.y(), p1.y()]
# Create the hole polygon
hole4 = vis.Polygon([p1, p2, p3, p4])
# Check if the hole is in standard form
print('Hole in standard form: ', hole4.is_in_standard_form())
# Create environment, wall will be the outer boundary because
# is the first polygon in the list. The other polygons will be holes
env = vis.Environment([walls, hole, hole2, hole1, hole3, hole4])
# Check if the environment is valid
print('Environment is valid : ', env.is_valid(epsilon))
# Define another point, could be used to check if the observer see it, to
# check the shortest path from one point to the other, etc.
end = vis.Point(330, 525)
# Define another point that the 'observer' will see
end_visible = vis.Point(415, 45)
# Necessary to generate the visibility polygon
observer.snap_to_boundary_of(env, epsilon)
observer.snap_to_vertices_of(env, epsilon)
# Obtain the visibility polygon of the 'observer' in the environmente
# previously define
isovist = vis.Visibility_Polygon(observer, env, epsilon)
# Uncomment the following line to obtein the visibility polygon
# of 'end' in the environmente previously define
# polygon_vis = vis.Visibility_Polygon(end, env, epsilon)
# Obtein the shortest path from 'observer' to 'end' and 'end_visible'
# in the environment previously define
shortest_path = env.shortest_path(observer, end, epsilon)
shortest_path1 = env.shortest_path(observer, end_visible, epsilon)
# Print the length of the path
print("Shortest Path length from observer to end: ", shortest_path.length())
print("Shortest Path length from observer to end_visible: ", shortest_path1.length())
# Check if 'observer' can see 'end', i.e., check if 'end' point is in
# the visibility polygon of 'observer'
print("Can observer see end? ", end._in(isovist, epsilon))
print("Can observer see end_visible? ", end_visible._in(isovist, epsilon))
# Print the point of the visibility polygon of 'observer' and save them
# in two arrays in order to draw the polygon later
point_x, point_y = save_print(isovist)
# Add the first point again because the function to draw, draw a line from
# one point to the next one and to close the figure we need the last line
# from the last point to the first one
point_x.append(isovist[0].x())
point_y.append(isovist[0].y())
# Set the title
p.title('VisiLibity Test')
# Set the labels for the axis
p.xlabel('X Position')
p.ylabel('Y Position')
# Plot the outer boundary with black color
p.plot(wall_x, wall_y, 'black')
# Plot the position of the observer with a green dot ('go')
p.plot([observer.x()], [observer.y()], 'go')
# Plot the position of 'end' with a green dot ('go')
p.plot([end.x()], [end.y()], 'go')
# Plot the position of 'end_visible' with a green dot ('go')
p.plot([end_visible.x()], [end_visible.y()], 'go')
# Plot the visibility polygon of 'observer'
p.plot(point_x, point_y)
# Plot the hole polygon with red color
p.plot(hole_x, hole_y, 'r')
# Plot the hole polygon with red color
p.plot(hole1_x, hole1_y, 'r')
# Plot the hole polygon with red color
p.plot(hole2_x, hole2_y, 'r')
# Plot the hole polygon with red color
p.plot(hole3_x, hole3_y, 'r')
# Plot the hole polygon with red color
p.plot(hole4_x, hole4_y, 'r')
# Example of a cone-shape polygon
cone_point = vis.Point(440, 420)
cone = create_cone([cone_point.x(), cone_point.y()], 150, 0, 45, 3)
cone_x, cone_y = save_print(cone)
cone_x.append(cone_x[0])
cone_y.append(cone_y[0])
p.plot([cone_point.x()], [cone_point.y()], 'go')
p.plot(cone_x, cone_y)
# Show the plot
p.show()
# 來看看 mnist 的型態
print(mnist.train.num_examples)
print(mnist.validation.num_examples)
print(mnist.test.num_examples)
train_img = mnist.train.images
train_label = mnist.train.labels
test_img = mnist.test.images
test_label = mnist.test.labels
print
print(" train_img 的 type : %s" % (type(train_img)))
print(" train_img 的 dimension : %s" % (train_img.shape, ))
print(" train_label 的 type : %s" % (type(train_label)))
print(" train_label 的 dimension : %s" % (train_label.shape, ))
print(" test_img 的 type : %s" % (type(test_img)))
print(" test_img 的 dimension : %s" % (test_img.shape, ))
print(" test_label 的 type : %s" % (type(test_label)))
print(" test_label 的 dimension : %s" % (test_label.shape, ))
nsample = 1
randidx = np.random.randint(train_img.shape[0], size=nsample)
for i in [0, 1, 2]:
curr_img = np.reshape(train_img[i, :], (28, 28)) # 28 by 28 matrix
curr_label = np.argmax(train_label[i, :]) # Label
plt.matshow(curr_img, cmap=plt.get_cmap('gray'))
plt.title("" + str(i + 1) + "th Training Data " + "Label is " +
str(curr_label))
plt.show()
def sigmoid(x):
return 1 / (np.exp(-x) + 1) # 既可以对数值变量计算，还可以对向量进行计算
x = np.random.randn(1000, 100) # 1000组数据
node_num = 100
hidden_layer_size = 5
activations = dict() # 在数字索引时和列表一样
# 开始逐层迭代运算，主要是我对绘图函数还是不熟悉
for i in range(hidden_layer_size):
if i != 0:
x = activations[i - 1]
# w = np.random.randn(node_num,node_num) *1
w = np.random.randn(node_num, node_num) * 0.01
z = np.dot(x, w)
z = sigmoid(z)
activations[i] = z
# 开始根据activations绘图
plt.rcParams['figure.figsize'] = (10, 5)
#plt.rcParams['figure.dpi'] = 300
for i, a in activations.items():
plt.subplot(1, len(activations), i + 1)
plt.title(str(i + 1) + "layer")
plt.hist(a.flatten(), 30, range=(0, 1))
plt.show()
import numpy as np
import matplotlib.pylab as plt
from scipy.fftpack import *
##Almacenamiento de los datos##
data1 = np.genfromtxt("signalSuma.dat")
data2 = np.genfromtxt("signal.dat")
#print len(data1[:,1])
N = 2048
dt = abs(data1[1, 0] - data1[2, 0])
##subplots con el grafico para cada senal##
plt.figure()
plt.subplot(2, 1, 1)
plt.title("signalSuma")
plt.xlabel("Tiempo(s)")
plt.ylabel("Amplitud")
plt.plot(data1[:, 0], data1[:, 1])
plt.subplot(2, 1, 2)
plt.title("signal")
plt.xlabel("Tiempo(s)")
plt.ylabel("Amplitud")
plt.plot(data2[:, 0], data2[:, 1])
plt.savefig("signal_subplots.pdf")
##implementacion de la transformada discreta de fourier##
def Fourier(N, data):
amplitudes = []
for n in range(N):
suma = 0
def cob_health(args):
log = coblog()
log(f'\n'
f'-----------------------------\n'
f' Network Health:{args.cob} \n'
f'-----------------------------\n'
)
log(f"\nCreating reports in {os.getcwd()}\n\n")
cob = co.COB(args.cob)
if args.out is None:
args.out = '{}_Health'.format(cob.name)
log(f'Output prefix: {args.out}')
if args.edge_zscore_cutoff is not None:
log("Changing Z-Score cutoff to {}",args.edge_zscore_cutoff)
cob.set_sig_edge_zscore(args.edge_zscore_cutoff)
log('Printing Summary ---------------------------------------------------')
if not path.exists('{}.summary.txt'.format(args.out)):
with open('{}.summary.txt'.format(args.out),'w') as OUT:
# Print out the network summary
cob.summary(file=OUT)
else:
log('Skipped summary.')
log('Plotting Scores ----------------------------------------------------')
if not path.exists('{}_CoexPCC_raw.png'.format(args.out)):
cob.plot_scores(
'{}_CoexPCC_raw.png'.format(args.out),
pcc=True
)
else:
log('Skipped Raw.')
if not path.exists('{}_CoexScore_zscore.png'.format(args.out)):
cob.plot_scores(
'{}_CoexScore_zscore.png'.format(args.out),
pcc=False
)
else:
log('Skipped Norm.')
log('Plotting Expression ------------------------------------------------')
#if not path.exists('{}_Expr_raw.png'.format(args.out)):
# cob.plot(
# '{}_Expr_raw.png'.format(args.out),
# include_accession_labels=True,
# raw=True,
# cluster_method=None
# )
#else:
# log('Skipped raw.')
if not path.exists('{}_Expr_norm.png'.format(args.out)):
cob.plot_heatmap(
'{}_Expr_norm.png'.format(args.out),
include_accession_labels=True,
raw=False,
cluster_method='ward',
cluster_accessions=True
)
else:
log('Skipped norm.')
#log('Plotting Cluster Expression-----------------------------------------')
#if not path.exists('{}_Expr_cluster.png'.format(args.out)):
# cob.plot(
# '{}_Expr_cluster.png'.format(args.out),
# include_accession_labels=True,
# raw=False,
# cluster_accessions=True,
# avg_by_cluster=True
# )
#else:
# log('Skipped norm.')
log('Printing QC Statistics ---------------------------------------------')
if args.refgen is not None:
if not path.exists('{}_qc_gene.txt'.format(args.out)):
# Print out the breakdown of QC Values
refgen = co.RefGen(args.refgen)
gene_qc = cob._bcolz('qc_gene')
gene_qc = gene_qc[gene_qc.pass_membership]
gene_qc['chrom'] = ['chr'+str(refgen[x].chrom) for x in gene_qc.index]
gene_qc = gene_qc.groupby('chrom').agg(sum,axis=0)
# Add totals at the bottom
totals = gene_qc.ix[:,slice(1,None)].apply(sum)
totals.name = 'TOTAL'
gene_qc = gene_qc.append(totals)
gene_qc.to_csv('{}_qc_gene.txt'.format(args.out),sep='\t')
else:
log('Skipped QC summary.')
log('Plotting Degree Distribution ---------------------------------------')
if not path.exists('{}_DegreeDist.png'.format(args.out)):
degree = cob.degree['Degree'].values
# Using powerlaw makes run-time warning the first time you use it.
# This is still an open issue on the creators github.
# The creator recommends removing this warning as long as there is a fit.
np.seterr(divide='ignore', invalid='ignore')
fit = powerlaw.Fit(degree,discrete=True,xmin=1)
# get an axis
ax = plt.subplot()
# Calculate log ratios
t2p = fit.distribution_compare('truncated_power_law', 'power_law')
t2e = fit.distribution_compare('truncated_power_law', 'exponential')
p2e = fit.distribution_compare('power_law','exponential')
# Plot!
emp = fit.plot_ccdf(ax=ax,color='r',linewidth=3, label='Empirical Data')
pwr = fit.power_law.plot_ccdf(ax=ax,linewidth=2, color='b', linestyle=':', label='Power law')
tpw = fit.truncated_power_law.plot_ccdf(ax=ax,linewidth=2, color='k', linestyle='-.', label='Truncated Power')
exp = fit.exponential.plot_ccdf(ax=ax,linewidth=2, color='g', linestyle='--', label='Exponential')
####
ax.set_ylabel("p(Degree≥x)")
ax.set_xlabel("Degree Frequency")
ax.legend(
loc='best'
)
plt.title('{} Degree Distribution'.format(cob.name))
# Save Fig
try:
plt.savefig('{}_DegreeDist.png'.format(args.out))
except FutureWarning as e:
# This is a matplotlib bug
pass
else:
log('Skipping Degree Dist.')
if args.go is not None:
log('Plotting GO --------------------------------------------------------')
# Set the alpha based on the tails
if args.two_tailed == True:
alpha = 0.05 /2
else:
alpha = 0.05
# Generate the GO Table
if not path.exists('{}_GO.csv'.format(args.out)):
go = co.GOnt(args.go)
term_ids = []
density_emp = []
density_pvals = []
locality_emp = []
locality_pvals = []
term_sizes = []
term_desc = []
terms_tested = 0
# max_terms limits the number of GO terms tested (sub-sampling)
if args.max_terms is not None:
log('Limiting to {} GO Terms',args.max_terms)
terms = go.rand(
n=args.max_terms,
min_term_size=args.min_term_size,
max_term_size=args.max_term_size
)
else:
# Else do the whole set (default is terms between 10 and 300 genes)
terms = go.iter_terms(
min_term_size=args.min_term_size,
max_term_size=args.max_term_size
)
for term in terms:
# Some terms will lose genes that are not in networks
term.loci = list(filter(lambda x: x in cob, term.loci))
# Skip terms that are not an adequate size
if len(term) < args.min_term_size or len(term) > args.max_term_size:
continue
# set density value for two tailed go so we only test it once
density = cob.density(term.loci)
# one tailed vs two tailed test
density_emp.append(density)
#
term_ids.append(term.id)
term_sizes.append(len(term))
term_desc.append(str(term.desc))
# ------ Density
# Calculate PVals
density_bs = np.array([
cob.density(cob.refgen.random_genes(n=len(term.loci))) \
for x in range(args.num_bootstraps)
])
if density > 0:
pval = sum(density_bs >= density)/args.num_bootstraps
else:
pval = sum(density_bs <= density)/args.num_bootstraps
density_pvals.append(pval)
# ------- Locality
locality = cob.locality(
term.loci,include_regression=True
).resid.mean()
locality_emp.append(locality)
# Calculate PVals
locality_bs = np.array([
cob.locality(
cob.refgen.random_genes(n=len(term.loci)),
include_regression=True
).resid.mean() \
for x in range(args.num_bootstraps)
])
if locality > 0:
pval = sum(locality_bs >= locality)/args.num_bootstraps
else:
pval = sum(locality_bs <= locality)/args.num_bootstraps
locality_pvals.append(pval)
# -------------
terms_tested += 1
if terms_tested % 100 == 0 and terms_tested > 0:
log('Processed {} terms'.format(terms_tested))
go_enrichment = pd.DataFrame({
'GOTerm' : term_ids,
'desc' : term_desc,
'size' : term_sizes,
'density' : density_emp,
'density_pval' : density_pvals,
'locality' : locality_emp,
'locality_pval' : locality_pvals
})
# Calculate significance
go_enrichment['density_significant'] = go_enrichment.density_pval < alpha
go_enrichment['locality_significant'] = go_enrichment.locality_pval < alpha
# Calculate bonferonni
go_enrichment['density_bonferroni'] = go_enrichment.density_pval < (alpha / len(go_enrichment))
go_enrichment['locality_bonferroni'] = go_enrichment.locality_pval < (alpha / len(go_enrichment))
# Store the GO results in a CSV
go_enrichment\
.sort_values(by='density_pval',ascending=True)\
.to_csv('{}_GO.csv'.format(args.out),index=False)
if terms_tested == 0:
log.warn('No GO terms met your min/max gene criteria!')
else:
go_enrichment = pd.read_table('{}_GO.csv'.format(args.out),sep=',')
if not path.exists('{}_GO.png'.format(args.out)):
# Convert pvals to log10
with np.errstate(divide='ignore'):
# When no bootstraps are more extreme than the term, the minus log pval yields an infinite
go_enrichment['density_pval'] = -1*np.log10(go_enrichment['density_pval'])
go_enrichment['locality_pval'] = -1*np.log10(go_enrichment['locality_pval'])
# Fix the infinites so they are plotted
max_density = np.max(go_enrichment['density_pval'][np.isfinite(go_enrichment['density_pval'])])
max_locality = np.max(go_enrichment['locality_pval'][np.isfinite(go_enrichment['locality_pval'])])
go_enrichment.loc[np.logical_not(np.isfinite(go_enrichment['density_pval'])),'density_pval'] = max_density + 1
go_enrichment.loc[np.logical_not(np.isfinite(go_enrichment['locality_pval'])),'locality_pval'] = max_locality + 1
plt.clf()
# Calculate the transparency based on the number of terms
if len(go_enrichment) > 20:
transparency_alpha = 0.05
else:
transparency_alpha = 1
# --------------------------------------------------------------------
# Start Plotting
figure,axes = plt.subplots(3,2,figsize=(12,12))
# -----------
# Density
# ----------
log_alpha = -1 *np.log10(alpha)
axes[0,0].scatter(
go_enrichment['density'],
go_enrichment['density_pval'],
alpha=transparency_alpha,
color='blue'
)
axes[0,0].set_xlabel('Empirical Density (Z-Score)')
axes[0,0].set_ylabel('Bootstraped -log10(p-value)')
fold = sum(np.array(go_enrichment['density_pval'])> log_alpha )/(alpha * len(go_enrichment))
axes[0,0].axhline(y=-1*np.log10(0.05),color='red')
axes[0,0].text(
min(axes[0,0].get_xlim()),
-1*np.log10(alpha) + 0.1,
'{:.3g} Fold Enrichement'.format(fold),
color='red'
)
axes[0,0].set_title('Density Health')
# Plot pvalue by term size
axes[1,0].scatter(
go_enrichment['size'],
go_enrichment['density_pval'],
alpha=transparency_alpha,
color='blue'
)
axes[1,0].set_ylabel('Bootstrapped -log10(p-value)')
axes[1,0].set_xlabel('Term Size')
axes[1,0].axhline(y=-1*np.log10(alpha),color='red')
axes[2,0].scatter(
go_enrichment['size'],
go_enrichment['density'],
alpha=transparency_alpha,
color='blue'
)
# Plot raw density by term size
axes[2,0].scatter(
go_enrichment.query(f'density_pval>{log_alpha}')['size'],
go_enrichment.query(f'density_pval>{log_alpha}')['density'],
alpha=transparency_alpha,
color='r'
)
axes[2,0].set_ylabel('Density')
axes[2,0].set_xlabel('Term Size')
# ------------
# Do Locality
# ------------
axes[0,1].scatter(
go_enrichment['locality'],
go_enrichment['locality_pval'],
alpha=transparency_alpha,
color='blue'
)
axes[0,1].set_xlabel('Empirical Locality (Residual)')
axes[0,1].set_ylabel('Bootstraped -log10(p-value)')
fold = sum(np.array(go_enrichment['locality_pval'])>log_alpha)/(0.05 * len(go_enrichment))
axes[0,1].axhline(y=-1*np.log10(0.05),color='red')
axes[0,1].text(
min(axes[0,1].get_xlim()),
-1*np.log10(alpha),
'{:.3g} Fold Enrichement'.format(fold),
color='red'
)
axes[0,1].set_title('Locality Health')
axes[1,1].scatter(
go_enrichment['size'],
go_enrichment['locality_pval'],
alpha=transparency_alpha,
color='blue'
)
axes[1,1].set_xlabel('Term Size')
axes[1,1].set_ylabel('Bootstrapped -log10(p-value)')
axes[1,1].axhline(y=-1*np.log10(0.05),color='red')
axes[2,1].scatter(
go_enrichment['size'],
go_enrichment['locality'],
alpha=transparency_alpha,
color='blue'
)
axes[2,1].scatter(
go_enrichment.query(f'locality_pval>{log_alpha}')['size'],
go_enrichment.query(f'locality_pval>{log_alpha}')['locality'],
alpha=transparency_alpha,
color='r'
)
axes[2,1].set_ylabel('Locality')
axes[2,1].set_xlabel('Term Size')
# Save Figure
plt.tight_layout()
try:
plt.savefig('{}_GO.png'.format(args.out))
except FutureWarning as e:
pass
else:
log('Skipping GO Volcano.')
index_col=0,
parse_dates=True,
squeeze=True)
venda_carros = venda_carros[:-1]
plt.plot(venda_carros)
#Teste de estacionariedade na série temporal
y = venda_carros
kpss_teste(y)
'''H0 (p >= 0.05) = A série é estacionária.
H1 (p < 0.05) = A série não é estacionária (apresenta raiz unitária).'''
#Aplicando a diferenciação de 1ª Ordem
y_diff = diff(y)
#Comparação entre a série antes e depois da diferenciação de 1 Ordem
plt.figure(figsize=(15, 5))
plt.subplot(2, 1, 1)
plt.title('Antes da diferenciação de 1ª Ordem')
plt.plot(venda_carros)
plt.subplot(2, 1, 2)
plt.title('Depois da diferenciação de 1ª Ordem')
plt.plot(y_diff)
plt.tight_layout()
plt.show()
#Teste de estacionariedade após a diferenciação
kpss_teste(y_diff)
'''Com apenas a diferenciação de 1 ordem, o valor de p é maior do que 0.05,
então a hipótese nula está mantida, só que diferente do Dickey Fuller
a hipótese nula significa que a série é estacionária'''
import numpy as np
import matplotlib as mpl
import matplotlib.pylab as plt
X = np.linspace(-np.pi, np.pi, 256)
C, S = np.cos(X), np.sin(X)
plt.title("legend를 표시한 플롯")
plt.plot(X, C, ls="--", label="cosine")
plt.plot(X, S, ls=":", label="sine")
plt.legend(loc=2)
plt.show()
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from CALPHAD_energies import *
labels = [r'$\gamma$', r'$\delta$', 'Laves']
colors = ['red', 'green', 'blue']
tmax = 5625 # 3750
pmax = 0.35
dt = 7.5e-5 * 1000
area = 320. * 192. * (5e-9)**2
# Plot difference in size between delta and Laves precipitates
plt.figure(1, figsize=(10, 7.5)) # inches
plt.title("Cr-Nb-Ni at %.0f K" % temp, fontsize=18)
plt.xlabel(r'$t$ / s', fontsize=18)
plt.ylabel(
r'Relative Phase Fraction $\frac{\phi_{\delta}-\phi_{\mathrm{L}}}{\phi_{\delta}+\phi_{\mathrm{L}}}$',
fontsize=18)
plt.ylim([-1, 1])
plt.plot((0, tmax), (0, 0), color='black', zorder=1)
# Generate combined plots (ternary and trajectories); store individual data
datasets = []
fmax = 0.
for datdir in tqdm(
glob.glob('/data/tnk10/phase-field/alloy625/TKR4p149/run*/')):
if path.isdir(datdir) and len(glob.glob("{0}/c.log".format(datdir))) > 0:
base = path.basename(datdir)
try:
show_features = [
'delinq_2yrs', 'fico_range_low', 'fico_range_high', 'inq_last_6mths',
'mths_since_last_record'
]
pylab.figure(figsize=[8, 5])
for feature in show_features:
pylab.plot(range(2, month_max + 1),
PSI_df.loc[feature],
'-o',
label=feature)
pylab.legend(loc='upper left')
pylab.ylabel("PSI")
pylab.xlabel("Month")
pylab.ylim([0, 0.01])
pylab.title('Stability of Different Features: Compared with Jan')
pylab.savefig('../output/Stability_compare_with_Jan.png')
print '\n计算各月同上月比较的PSI值:'
PSI_list2 = []
for after_time in range(2, month_max + 1):
before_time = after_time - 1
cur_df = df[df['issue_d'].isin([before_time, after_time])]
PSI_list2.append(get_PSI_features(cur_df['issue_d'], cur_df[feature_cols]))
print '完成所有特征在' + str(before_time) + '月和' + str(after_time) + '月的比较'
index_names = [
'PSI_' + str(i - 1) + '_' + str(i) for i in range(2, month_max + 1)
]
PSI_df2 = pd.DataFrame(PSI_list2, columns=feature_cols, index=index_names).T
pylab.figure(figsize=[8, 5])
for feature in show_features:
