def test():
import datasource
import model
import dataset
f = Fitter()
# define source of "experimental data"
function = lambda s, i: (10.0*s/1.0)/(1.0 + s/1.0 + i/5.0)
data_source = datasource.Generated_ScanDataSource(
function,
['s', 'i'],
'v',
[scipy.logspace(-2, 2, 50), scipy.logspace(-2, 2, 10)],
noise=0.3
)
# define model
model = model.Equation_Model("Vmax*s/Ks/(1 + s/Ks + i/Ki)", ['s', 'i'])
dataset.ScanDataSet('name', f, data_source, model)
# specify the optimization algorithm, defaults to scipy_leastsq
#~ alg = algorithm.scipy_leastsq()
alg = algorithm.robust_biweight()
f.setAlgorithm(alg)
# specify the parameters to be fitted
f.addParameter('Vmax', init=1.0, min=0, max=100)
f.addParameter('Ks', init=1.0, min=0, max=10)
f.addParameter('Ki', init=1.0, min=0, max=10)
r = f.solve()
r.writeOutput()
def generate_responses(isos,
flux,
struct='wims69',
lower=1e-5,
upper=2e7,
name='response.p',
overwrite=False):
"""This generates response functions for given isotopes,
a given spectrum, and a desired group structure."""
if os.path.isfile(name) and not overwrite:
return pickle.load(open(directory + '/code/' + name, 'rb'))
responses = {}
eb = energy_groups(struct, lower, upper)
responses['eb'] = eb
responses['phi'] = sp.zeros(len(eb) - 1)
for i in range(len(eb) - 1):
E = sp.logspace(sp.log10(eb[i + 1]), sp.log10(eb[i]), 1e4)
x = trapz(flux(E), E)
print("->", i, eb[i + 1], eb[i], x)
responses['phi'][i] = trapz(flux(E), E)
interps = get_cross_section_interps(isos)
responses['response'] = {}
for iso in isos:
print("...response for iso ", iso)
responses['response'][iso] = sp.zeros(len(eb) - 1)
fun = lambda x: flux(x) * interps[iso](x)
for i in range(len(eb) - 1):
E = sp.logspace(sp.log10(eb[i + 1]), sp.log10(eb[i]), 1e4)
top = trapz(fun(E), E)
responses['response'][iso][i] = top / responses['phi'][i]
pickle.dump(responses, open(directory + '/code/' + name, 'wb'))
return responses
def plot(nmin=-2, nmax=1, tmin=0, tmax=2, num=301, B=5.4, npar=1.8):
Taxis = scipy.logspace(tmin, tmax, num) * 1e-3
naxis = scipy.logspace(nmin, nmax, num) * 1e20
n, T = scipy.meshgrid(naxis, Taxis)
om = scipy.pi * 2 * 4.6e9
#wpe = n*pow(ec,2)/(e0*mes)
print(nu(n, T))
Ains = As(n, T, B, om, npar)
Bins = Bs(n, T, B, om, npar)
Cins = Cs(n, T, B, om, npar)
Q = (-Bins + scipy.sqrt(pow(Bins, 2) - 4 * Ains * Cins)) / 2 / Ains
output = scipy.sqrt(
scipy.sqrt(pow(scipy.real(Q), 2) + pow(scipy.imag(Q), 2)) -
scipy.real(Q)) / pow(2, .5)
CS = plt.contour(naxis,
Taxis * 1e3,
om * output / 299792458.,
locator=ticker.LogLocator(),
linewidths=2.,
colors=colors['b']) #om*output/299792458.
plt.clabel(CS, inline=1, fontsize=16, fmt=ticker.LogFormatterMathtext()) #
#CS2 = plt.contour(naxis,Taxis*1e3,pow(2,-1)*abs(scipy.imag(Q)/abs(scipy.sqrt(scipy.real(Q))))*om/299792458.,locator=ticker.LogLocator(),linewidths=2.,colors=colors['g'])#om*output/299792458.
#plt.clabel(CS2, inline=1, fontsize=16,fmt=ticker.LogFormatterMathtext())#
wpe = n * pow(ec, 2) / (e0 * mes)
wce = ec * B / mes
wci = ec * B / mi
output2 = nu(n, T) * pow(wpe, .5) / (2 * pow(om, 2)) * scipy.sqrt(
abs((npar**2 - 1) / (1 - wpe / (pow(wce, 2) * (npar**2 - 1)))))
#CS3 = plt.contour(naxis,Taxis*1e3,output2*om/299792458.,locator=ticker.LogLocator(),linewidths=2.,colors=colors['r'])#om*output/299792458.
output3 = nu(n, T) * pow(wpe, .5) / (2 * pow(om, 2)) * npar
# CS2 = plt.contour(naxis,Taxis*1e3,output3*om/299792458.,locator=ticker.LogLocator(),linewidths=2.,colors=colors['g'])#om*output/299792458.
#plt.clabel(CS2, inline=1, fontsize=16,fmt=ticker.LogFormatterMathtext())#
#plt.clabel(CS3, inline=1, fontsize=16,fmt=ticker.LogFormatterMathtext())#
A2 = pow(ec, 2) / (e0 * mi) / pow(om, 2)
B2 = -2 * pow(e0 * mes, -.5) * ec / wce * npar
C2 = npar**2 - 1
temp = pow((-B2 - pow(B2**2 - 4 * A2 * C2, .5)) / (2 * A2), 2)
plt.fill_between(naxis,
Taxis[0] * 1e3,
Taxis[-1] * 1e3,
naxis > temp,
color='k',
alpha=.3,
linewidth=2.)
plt.gca().set_yscale("log")
plt.gca().set_xscale("log")
plt.ylabel(r'Electron Temperature [eV]')
plt.xlabel(r'$n_e$ [m$^{-3}$]')
plt.show()
def gridSearch(maxT, sumM, name,loc='svmcrossvalid.p',reduction=50,k=2.2e35,gamma=[-3,3], C=[0,6], nozero=False, conc='c_w_l', lims=[2.2e3,9e3]):
val, c_w_l, idx = conditionVal(name=name, nozero=nozero, conc=conc)
idx1 = sample(val,len(val)/reduction)
idx2 = sample(val,len(val)/reduction) #very small subsamples started for testing algos
index0 = scipy.logspace(gamma[0],gamma[1],int(abs(gamma[0]-gamma[1])+1))
index1 = scipy.logspace(C[0],C[1],int(abs(C[0]-C[1])+1))
data = scipy.io.readsav('W_Abundances_grid_puestu_adpak_fitscaling_74_0.00000_5.00000_1000_idlsave')
te = data['en']
idx2 = scipy.logical_and(te > lims[0], te < lims[1])
temp = val[idx2]/c_w_l[idx2]/sumM[idx2]*k
output = scipy.zeros((len(index0),len(index1)))
output2 = scipy.zeros((len(index0),len(index1),len(te[idx2])))
for i in xrange(len(index0)):
for j in xrange(len(index1)):
print(i,j)
pipe = SVMtest(maxT, sumM, val, c_w_l, reduced=idx1, gamma=index0[i], C=index1[j],k=k)
output[i,j] = pipe.score(scipy.log(scipy.atleast_2d(maxT[idx2]).T),scipy.log(temp))
output2[i,j] = scipy.exp(pipe.predict(scipy.log(scipy.atleast_2d(te[idx2]).T)))
pickle.dump([output,output2],open(loc,'wb'))
return output,output2
def test():
import datasource
import model
import dataset
f = Fitter()
# define source of "experimental data"
function = lambda s, i: (10.0 * s / 1.0) / (1.0 + s / 1.0 + i / 5.0)
data_source = datasource.Generated_ScanDataSource(
function, ['s', 'i'],
'v', [scipy.logspace(-2, 2, 50),
scipy.logspace(-2, 2, 10)],
noise=0.3)
# define model
model = model.Equation_Model("Vmax*s/Ks/(1 + s/Ks + i/Ki)", ['s', 'i'])
dataset.ScanDataSet('name', f, data_source, model)
# specify the optimization algorithm, defaults to scipy_leastsq
#~ alg = algorithm.scipy_leastsq()
alg = algorithm.robust_biweight()
f.setAlgorithm(alg)
# specify the parameters to be fitted
f.addParameter('Vmax', init=1.0, min=0, max=100)
f.addParameter('Ks', init=1.0, min=0, max=10)
f.addParameter('Ki', init=1.0, min=0, max=10)
r = f.solve()
r.writeOutput()
def _getParamGridFixedEffectModel(self, G0, G1, link):
if link == 'linear':
param_grid = dict(alpha=0.5*sp.logspace(-5, 5, 20))
elif link == 'logistic':
param_grid = dict(C=sp.logspace(-5, 5, 20))
else:
assert False
return param_grid
def D2_setup_scan(self,min1,max1,step1,min2,max2,step2):
self.P1min = min1
self.P1max = max1
self.P1steps = step1
self.P2min = min2
self.P2max = max2
self.P2steps = step2
self.P1range = scipy.logspace(scipy.log10(min1),scipy.log10(max1),step1)
self.P2range = scipy.logspace(scipy.log10(min2),scipy.log10(max2),step2)
def _getParamGridFixedEffectModel(self, G0, G1, link):
if link == 'linear':
param_grid = dict(alpha=0.5 * sp.logspace(-5, 5, 20))
elif link == 'logistic':
param_grid = dict(C=sp.logspace(-5, 5, 20))
else:
assert False
return param_grid
def D2_setup_scan(self, min1, max1, step1, min2, max2, step2):
self.P1min = min1
self.P1max = max1
self.P1steps = step1
self.P2min = min2
self.P2max = max2
self.P2steps = step2
self.P1range = scipy.logspace(scipy.log10(min1), scipy.log10(max1),
step1)
self.P2range = scipy.logspace(scipy.log10(min2), scipy.log10(max2),
step2)
def betweenness_distrib(graph,
use_weights=True,
nodes=None,
num_nbins=None,
num_ebins=None,
log=False):
'''
Betweenness distribution of a graph.
Parameters
----------
graph : :class:`~nngt.Graph` or subclass
the graph to analyze.
use_weights : bool, optional (default: True)
use weighted degrees (do not take the sign into account : all weights
are positive).
nodes : list or numpy.array of ints, optional (default: all nodes)
Restrict the distribution to a set of nodes (only impacts the node
attribute).
log : bool, optional (default: False)
use log-spaced bins.
Returns
-------
ncounts : :class:`numpy.array`
number of nodes in each bin
nbetw : :class:`numpy.array`
bins for node betweenness
ecounts : :class:`numpy.array`
number of edges in each bin
ebetw : :class:`numpy.array`
bins for edge betweenness
'''
ia_nbetw, ia_ebetw = graph.get_betweenness(use_weights)
if nodes is not None:
ia_nbetw = ia_nbetw[nodes]
if num_nbins is None:
num_nbins = max(10, int(len(ia_nbetw) / 50))
if num_ebins is None:
num_ebins = max(10, int(len(ia_ebetw) / 50))
ra_nbins = sp.linspace(ia_nbetw.min(), ia_nbetw.max(), num_nbins)
ra_ebins = sp.linspace(ia_ebetw.min(), ia_ebetw.max(), num_ebins)
if log:
ra_nbins = sp.logspace(sp.log10(sp.maximum(ia_nbetw.min(), 10**-8)),
sp.log10(ia_nbetw.max()), num_nbins)
ra_ebins = sp.logspace(sp.log10(sp.maximum(ia_ebetw.min(), 10**-8)),
sp.log10(ia_ebetw.max()), num_ebins)
ncounts, nbetw = sp.histogram(ia_nbetw, ra_nbins)
ecounts, ebetw = sp.histogram(ia_ebetw, ra_ebins)
nbetw = nbetw[:-1] + 0.5 * sp.diff(nbetw)
ebetw = ebetw[:-1] + 0.5 * sp.diff(ebetw)
return ncounts, nbetw, ecounts, ebetw
def D3_setup_scan(self,min1,max1,step1,min2,max2,step2,min3,max3,step3):
self.P1min = min1
self.P1max = max1
self.P1steps = step1
self.P2min = min2
self.P2max = max2
self.P2steps = step2
self.P3min = min3
self.P3max = max3
self.P3steps = step3
self.P1range = scipy.logspace(scipy.log10(min1),scipy.log10(max1),step1)
self.P2range = scipy.logspace(scipy.log10(min2),scipy.log10(max2),step2)
self.P3range = scipy.logspace(scipy.log10(min3),scipy.log10(max3),step3)
def plotquarts(a, data1, data2, col, line, lab, log=False):
n = len(data1)
mx = -sp.Inf
mn = sp.Inf
for i in xrange(n):
mn = min(mn, min(data1[i]))
mx = max(mx, max(data1[i]))
if not log:
xaxis = sp.linspace(mn, mx, 200)
else:
xaxis = sp.logspace(sp.log10(mn), sp.log10(mx), 200) + 1e-9
## print( data1)
# print( data2)
# print( xaxis)
low0, med0, upp0 = gpbo.core.ESutils.quartsirregular(data1, data2, xaxis)
# a.fill_between(xaxis, low0, upp0, facecolor='lightblue', edgecolor='lightblue', alpha=0.5)
a.plot(xaxis, med0, color=col, linestyle=line, label=lab)
a.fill_between(xaxis,
upp0,
low0,
edgecolor=col,
linestyle=line,
facecolor=col,
lw=0.0,
alpha=0.1)
return
def default_frequency_range(syslist):
"""Compute a reasonable default frequency range for frequency
domain plots.
Finds a reasonable default frequency range by examining the features
(poles and zeros) of the systems in syslist.
Parameters
----------
syslist : list of Lti
List of linear input/output systems (single system is OK)
Returns
-------
omega : array
Range of frequencies in rad/sec
Examples
--------
>>> from matlab import ss
>>> sys = ss("1. -2; 3. -4", "5.; 7", "6. 8", "9.")
>>> omega = default_frequency_range(sys)
"""
# This code looks at the poles and zeros of all of the systems that
# we are plotting and sets the frequency range to be one decade above
# and below the min and max feature frequencies, rounded to the nearest
# integer. It excludes poles and zeros at the origin. If no features
# are found, it turns logspace(-1, 1)
# Find the list of all poles and zeros in the systems
features = np.array(())
# detect if single sys passed by checking if it is sequence-like
if (not getattr(syslist, '__iter__', False)):
syslist = (syslist,)
for sys in syslist:
try:
# Add new features to the list
features = np.concatenate((features, np.abs(sys.pole())))
features = np.concatenate((features, np.abs(sys.zero())))
except:
pass
# Get rid of poles and zeros at the origin
features = features[features != 0];
# Make sure there is at least one point in the range
if (features.shape[0] == 0): features = [1];
# Take the log of the features
features = np.log10(features)
#! TODO: Add a check in discrete case to make sure we don't get aliasing
# Set the range to be an order of magnitude beyond any features
omega = sp.logspace(np.floor(np.min(features))-1,
np.ceil(np.max(features))+1)
return omega
def run(self, npts=25, inv_points=None, access_limited=True, **kwargs):
r"""
Parameters
----------
npts : int (default = 25)
The number of pressure points to apply. The list of pressures
is logarithmically spaced between the lowest and highest throat
entry pressures in the network.
inv_points : array_like, optional
A list of specific pressure point(s) to apply.
"""
if 'inlets' in kwargs.keys():
logger.info('Inlets recieved, passing to set_inlets')
self.set_inlets(pores=kwargs['inlets'])
if 'outlets' in kwargs.keys():
logger.info('Outlets recieved, passing to set_outlets')
self.set_outlets(pores=kwargs['outlets'])
self._AL = access_limited
if inv_points is None:
logger.info('Generating list of invasion pressures')
min_p = sp.amin(self['throat.entry_pressure']) * 0.98 # nudge down
max_p = sp.amax(self['throat.entry_pressure']) * 1.02 # bump up
inv_points = sp.logspace(sp.log10(min_p), sp.log10(max_p), npts)
self._npts = sp.size(inv_points)
# Execute calculation
self._do_outer_iteration_stage(inv_points)
def add_axis(self, param, start, stop, steps, logspace=False): """Add a parameter discretization axis to the the grid Arguments --------- param : string The name of the model parameter. start : float The starting value of the model parameter. stop : float The ending value of the model parameter. steps : integer The number of steps to insert between the start and stop. logspace : boolean Space the steps logarithmically? Returns ------- None """ assert param in self.sim.get_model_params().keys() if logspace: self._grid_pts.append( scipy.logspace(start,stop,steps) ) else: self._grid_pts.append( scipy.linspace(start,stop,steps) ) self._grid_size *= len(self._grid_pts[-1]) self._grid_order.append(param)
def create_grid(r_in, r_out, nshell, space = 'powerlaw1', end = True):
# function to create grid
if space == 'log10':
from scipy import log10, logspace
# get the exponent of the start- and
# stop-radius in input units
start = [log10(r_in), 0][r_in == 0]
stop = log10(r_out)
radii = logspace(start, stop, num=nshell, endpoint=end)
elif space == "powerlaw1":
from scipy import arange
radii = r_in * (r_out/r_in)**(arange(nshell)/(nshell - 1.0))
elif space == 'linear':
from scipy import linspace
# linearly spaced grid
radii = linspace(r_in, r_out, num=nshell, endpoint=end)
elif space == 'powerlaw2':
from scipy import linspace
# first check if coefficients to the power-law was given
#~ if 'exp' in kwargs:
#~ p_exp = kwargs['exp']
#~ else: # if not, set it to 2, i.e. r^2
#~ p_exp = 2
radii = r_in + (r_out - r_in)*(linspace(r_in, r_out, num=nshell, endpoint=end)/(r_out))**2
#pr_int('Not implemented yet.')
#raise ParError(spaced)
else:
raise Exception(space)
return radii
def compute_rls(data_file, output_filename, rls_type=DEFAULT_RLS, save_out=DEFAULT_SAVE):
"""
data file contains sampels and labels saved as a mat file
with respective keywords. Make your own data wrapper if needed
"""
if path.splitext(output_filename)[-1] != ".mat":
output_filename += ".mat"
if path.splitext(data_file)[-1] != ".mat":
raise ValueError, "mat file needed"
data = loadmat(data_file)
X = data["samples"]
Y = data["labels"]
lambdas = sp.logspace(-6, 6, 30)
if rls_type.lower() == "linear":
w, loos = lrlsloo(X, Y, lambdas)
elif rls_type.lower() == "nonlinear":
w, loos = rlsloo(X, Y, lambdas)
else:
print "ERROR: specify linear or nonlinear"
if save_out:
out_data = {"weights": w, "loos": loos}
savemat(out_fname, out_data)
def run(self, npts=25, inv_points=None, access_limited=True, **kwargs):
r"""
Parameters
----------
npts : int (default = 25)
The number of pressure points to apply. The list of pressures
is logarithmically spaced between the lowest and highest throat
entry pressures in the network.
inv_points : array_like, optional
A list of specific pressure point(s) to apply.
"""
if 'inlets' in kwargs.keys():
logger.info('Inlets recieved, passing to set_inlets')
self.set_inlets(pores=kwargs['inlets'])
if 'outlets' in kwargs.keys():
logger.info('Outlets recieved, passing to set_outlets')
self.set_outlets(pores=kwargs['outlets'])
self._AL = access_limited
if inv_points is None:
logger.info('Generating list of invasion pressures')
min_p = sp.amin(self['throat.entry_pressure']) * 0.98 # nudge down
max_p = sp.amax(self['throat.entry_pressure']) * 1.02 # bump up
inv_points = sp.logspace(sp.log10(min_p),
sp.log10(max_p),
npts)
self._npts = sp.size(inv_points)
# Execute calculation
self._do_outer_iteration_stage(inv_points)
def plotprofile(confs,nreps,path,tol=0.9,target=1e-6):
f=[]
a=[]
pmax=1
for i in range(pmax):
f_,a_ = plt.subplots(1)
for item in ([a_.title, a_.xaxis.label, a_.yaxis.label] + a_.get_xticklabels() + a_.get_yticklabels()):
item.set_fontsize(10)
f.append(f_)
a.append(a_)
colorlist = ['b','r','g','purple','k','grey','orange','c','lightgreen','lightblue','pink','b','r','g','purple','k','grey','orange','c','lightgreen','lightblue','pink']
lslist = ['solid' , 'dashed', 'dashdot', 'dotted','solid' , 'dashed', 'dashdot', 'dotted','solid' , 'dashed', 'dashdot', 'dotted','solid' , 'dashed', 'dashdot', 'dotted','solid' , 'dashed', 'dashdot', 'dotted']
ci=-1
for C in confs:
print('plotting {}...'.format(C[0]))
ci+=1
col = colorlist[ci]
line = lslist[ci]
#collect the data
data=[]
xoverheads = sp.empty(nreps)
xntotarget = sp.zeros(nreps)
overheads = sp.empty(nreps)
noverheads = [sp.empty(nreps) for i in range(len(C[1]['N']))]
ninrun = sp.zeros(nreps)
support = sp.logspace(-2,5,200)
success = sp.zeros(nreps)
for ii in range(nreps):
D = gpbo.optimize.readoptdata(os.path.join(path,'{}_{}.csv'.format(C[0],ii)))
A = sp.array(D['trueyatxrecc'].values)
if A.min()>=target:
xoverheads[ii]=sum(D['taq'])
overheads[ii]=sum(D['taq'])
for k,n in enumerate(C[1]['N']):
noverheads[k][ii] = sum(D['taq'][:n])
else:
success[ii]=1
i = sp.argmax(A<=target)#while A[i]>=target:
xoverheads[ii] = sum(D['taq'][:i+1])
overheads[ii] = sum(D['taq'])
xntotarget[ii] = i
ninrun[ii]=len(D['taq'])
for k,n in enumerate(C[1]['N']):
noverheads[k][ii] = sum(D['taq'].values[:n])
if sp.mean(success)>=tol:
if C[1]['oracle']:
a[0].plot(support,sp.mean(xoverheads)+sp.mean(xntotarget)*support,col,label=C[0]+'oracle',linestyle='dashdot')
if C[1]['full']:
a[0].plot(support,sp.mean(overheads)+sp.mean(ninrun)*support,col,label=C[0]+'_all',linestyle='dashed')
for k,n in enumerate(C[1]['N']):
if sp.percentile(xntotarget,int(tol*100))<n:
a[0].plot(support,sp.mean(noverheads[k])+n*support,col,label=C[0]+str(n),linestyle='solid')
else:
print('{} only acchived target on {}'.format(C[0],sp.mean(success)))
a[0].set_xscale('log')
a[0].set_yscale('log')
a[0].legend()
f[0].savefig(os.path.join(path,'profile_{}.png'.format(sp.log10(target))),bbox_inches='tight', pad_inches=0.1)
def fit(self, kk=None):
"""
Fit Fourier spectrum with the function set at class instantination
==> NB: fitting is done in logarithmic coordinates
and fills plotting arrays with data
--------
Options:
--------
kk
(k1,k2) <None> spectral interval for function fitting
by default interval [ kk[1], kk[imax__kk] ] will be fitted
==> i.e. k=0 is excluded
"""
# fitting interval
if kk:
ik_min=(self.fft_data.kk[1:self.fft_data.imax__kk]<=kk[0]).nonzero()[0][-1]
ik_max=(self.fft_data.kk[1:self.fft_data.imax__kk]<=kk[1]).nonzero()[0][-1]
else:
ik_min=1;
ik_max=self.fft_data.imax__kk
# do fitting
self.__popt,self.__pcov = scipy.optimize.curve_fit(self.__func_fit,
scipy.log(self.fft_data.kk[ik_min:ik_max]),
scipy.log(self.fft_data.Ik[ik_min:ik_max]) )
# boundaries of fitted interval
self.kmin = self.fft_data.kk[ik_min]
self.kmax = self.fft_data.kk[ik_max]
# fill plot arrays <===============
self.kk_plot=scipy.logspace( scipy.log10(self.kmin),
scipy.log10(self.kmax),
self.nk_plot )
self.Ik_plot=self.fitting_function(self.kk_plot)
def _neutdata(self, samplename, ic50_in_name,
nfitpoints, cextend):
"""Gets data for plotting neutralization curve.
Returns a `pandas.DataFrame` appropriate for passing
to :func:`dms_tools2.plot.plotFacetedNeutCurves`. The
arguments have the meanings explained in :meth:`plot`.
"""
concentrations = scipy.concatenate(
[self.cs,
scipy.logspace(math.log10(self.cs.min() / cextend),
math.log10(self.cs.max() * cextend),
num=nfitpoints)
])
n = len(concentrations)
points = scipy.concatenate(
[self.fs,
scipy.full(n - len(self.fs), scipy.nan)])
fit = scipy.array([self.fracsurvive(c) for c in concentrations])
if ic50_in_name:
samplename += ' (IC50 = {0})'.format(self.ic50_str())
return pandas.DataFrame.from_dict(collections.OrderedDict([
('concentration', concentrations),
('sample', [samplename] * n),
('points', points),
('fit', fit),
]))
def add_axis(self, param, start, stop, steps, logspace=False):
"""Add a parameter discretization axis to the the grid
Arguments
---------
param : string
The name of the model parameter.
start : float
The starting value of the model parameter.
stop : float
The ending value of the model parameter.
steps : integer
The number of steps to insert between the start and stop.
logspace : boolean
Space the steps logarithmically?
Returns
-------
None
"""
assert param in self.sim.get_model_params().keys()
if logspace:
self._grid_pts.append(scipy.logspace(start, stop, steps))
else:
self._grid_pts.append(scipy.linspace(start, stop, steps))
self._grid_size *= len(self._grid_pts[-1])
self._grid_order.append(param)
def degree_distrib(net, deg_type="total", node_list=None, use_weights=True,
log=False, num_bins=30):
'''
Computing the degree distribution of a network.
Parameters
----------
net : :class:`~nngt.Graph` or subclass
the network to analyze.
deg_type : string, optional (default: "total")
type of degree to consider ("in", "out", or "total").
node_list : list or numpy.array of ints, optional (default: None)
Restrict the distribution to a set of nodes (default: all nodes).
use_weights : bool, optional (default: True)
use weighted degrees (do not take the sign into account: all weights
are positive).
log : bool, optional (default: False)
use log-spaced bins.
Returns
-------
counts : :class:`numpy.array`
number of nodes in each bin
deg : :class:`numpy.array`
bins
'''
ia_node_deg = net.get_degrees(node_list, deg_type, use_weights)
ra_bins = sp.linspace(ia_node_deg.min(), ia_node_deg.max(), num_bins)
if log:
ra_bins = sp.logspace(sp.log10(sp.maximum(ia_node_deg.min(),1)),
sp.log10(ia_node_deg.max()), num_bins)
counts,deg = sp.histogram(ia_node_deg, ra_bins)
ia_indices = sp.argwhere(counts)
return counts[ia_indices], deg[ia_indices]
def default_frequency_range(syslist):
"""Compute a reasonable default frequency range for frequency
domain plots.
Finds a reasonable default frequency range by examining the features
(poles and zeros) of the systems in syslist.
Parameters
----------
syslist : list of Lti
List of linear input/output systems (single system is OK)
Returns
-------
omega : array
Range of frequencies in rad/sec
Examples
--------
>>> from matlab import ss
>>> sys = ss("1. -2; 3. -4", "5.; 7", "6. 8", "9.")
>>> omega = default_frequency_range(sys)
"""
# This code looks at the poles and zeros of all of the systems that
# we are plotting and sets the frequency range to be one decade above
# and below the min and max feature frequencies, rounded to the nearest
# integer. It excludes poles and zeros at the origin. If no features
# are found, it turns logspace(-1, 1)
# Find the list of all poles and zeros in the systems
features = np.array(())
# detect if single sys passed by checking if it is sequence-like
if (not getattr(syslist, '__iter__', False)):
syslist = (syslist,)
for sys in syslist:
try:
# Add new features to the list
features = np.concatenate((features, np.abs(sys.pole())))
features = np.concatenate((features, np.abs(sys.zero())))
except:
pass
# Get rid of poles and zeros at the origin
features = features[features != 0];
# Make sure there is at least one point in the range
if (features.shape[0] == 0): features = [1];
# Take the log of the features
features = np.log10(features)
#! TODO: Add a check in discrete case to make sure we don't get aliasing
# Set the range to be an order of magnitude beyond any features
omega = sp.logspace(np.floor(np.min(features))-1,
np.ceil(np.max(features))+1)
return omega
def D3_setup_scan(self, min1, max1, step1, min2, max2, step2, min3, max3,
step3):
self.P1min = min1
self.P1max = max1
self.P1steps = step1
self.P2min = min2
self.P2max = max2
self.P2steps = step2
self.P3min = min3
self.P3max = max3
self.P3steps = step3
self.P1range = scipy.logspace(scipy.log10(min1), scipy.log10(max1),
step1)
self.P2range = scipy.logspace(scipy.log10(min2), scipy.log10(max2),
step2)
self.P3range = scipy.logspace(scipy.log10(min3), scipy.log10(max3),
step3)
def visualize2SVM(maxT, sumM, name, nozero=False, k=2.2e35, useall=False, lims=[2.2e3,9e3], minval=[2,5], conc='c_w_l',loc='svmcrossvalid.p',idx2=None):
""" log plot of the data with only PEC data"""
val, c_w_l, idx = conditionVal(name=name, nozero=nozero, conc=conc)
data = scipy.io.readsav('W_Abundances_grid_puestu_adpak_fitscaling_74_0.00000_5.00000_1000_idlsave')
y = time.time()
xax = scipy.logspace(2,5,201)
yax = scipy.logspace(-5,1,101)
xtemp = xax[1:]/2.+xax[:-1]/2.
ytemp = yax[1:]/2.+yax[:-1]/2.
Y,X = scipy.meshgrid(xtemp, ytemp)
if idx2 is None:
histdata, xed, yed = scipy.histogram2d(maxT,val/c_w_l/sumM*k,bins=[xax,yax])
else:
histdata, xed, yed = scipy.histogram2d(maxT[idx2],(val/c_w_l/sumM*k)[idx2],bins=[xax,yax])
extent = [xed[0], xed[-1], yed[0], yed[-1]]
plt.pcolormesh(xax,yax,histdata.T, cmap='viridis', rasterized=True,vmin=1.,norm=LogNorm())
plt.gca().set_yscale('log')
plt.gca().set_xscale('log')
plt.gca().set_ylim(1e-4,1e1)
plt.gca().set_xlim(1e3,2e4)
cmap = plt.cm.get_cmap('viridis')
cmap.set_under('white')
idx3 = scipy.logical_and(data['en'] > lims[0], data['en'] < lims[1])
data2 = pickle.load(open(loc,'rb'))
fz = data2[1][minval[0]][minval[1]]
print(len(fz))
print(data['en'][idx3].shape)
plt.loglog(data['en'][idx3],fz/fz.max(),lw=3.5,color='darkorange',linestyle='-',label='SVM fit')
plt.xlabel(r'$T_e$ [eV]')
plt.ylabel(r'const$\cdot I_{CSXR} / c_W \sum M$')
colorbar = plt.colorbar()
colorbar.ax.set_ylabel('datapoint density (a.u.)')
leg = plt.legend(loc=4,fontsize=20,title=r'\underline{\hspace{1em} C=10$^4$, $\gamma=.1$ \hspace{1em}}')
plt.setp(leg.get_title(),fontsize=14)
plt.subplots_adjust(bottom=.12,right=1.)
def plotFigureSingVals(FigFolder, s, plotStylei, subfigIndx):
font = {'family': 'sans-serif', 'weight': 'normal', 'size': 14}
matplotlib.rc('font', **font)
# set tick width
matplotlib.rcParams['xtick.major.size'] = 7
matplotlib.rcParams['xtick.major.width'] = 1.0
matplotlib.rcParams['xtick.minor.size'] = 3
matplotlib.rcParams['xtick.minor.width'] = 1.0
matplotlib.rcParams['ytick.major.size'] = 7
matplotlib.rcParams['ytick.major.width'] = 1.0
matplotlib.rcParams['ytick.minor.size'] = 3
matplotlib.rcParams['ytick.minor.width'] = 1.0
matplotlib.rcParams['axes.linewidth'] = 1.0
# Make LATEX font the same as text font:
matplotlib.rcParams['mathtext.fontset'] = 'custom'
matplotlib.rcParams['mathtext.rm'] = 'Bitstream Vera Sans'
matplotlib.rcParams['mathtext.it'] = 'Bitstream Vera Sans:italic'
matplotlib.rcParams['mathtext.bf'] = 'Bitstream Vera Sans:bold'
fig = plt.figure(1, figsize=(10, 4))
ax = plt.subplot(subfigIndx)
plt.plot(range(1, len(s) + 1), s, plotStylei, linewidth=2.0)
plt.yscale('log')
plt.xscale('log')
ax.set_yticks(sp.logspace(-8, 0, num=5, base=10))
plt.xlabel('Singular Value Index, $i$', labelpad=10)
plt.ylabel('Scaled Singular Value, $\lambda_i/\lambda_1$', labelpad=10)
# Set axis limits:
plt.ylim(1.e-8, 3.)
plt.xlim(0, 1000)
ax.minorticks_off()
ax.tick_params(axis='both',
bottom=True,
top=True,
left=True,
right=True,
direction='in')
if subfigIndx == 121:
ax.legend(['LowRankMedNoise', 'LowRankHiNoise', '$S_\mathrm{D}$'],
numpoints=1,
loc="lower left",
prop={'size': 12})
if subfigIndx == 122:
ax.legend(['PolySlow', 'PolyFast', 'ExpSlow', 'ExpFast'],
numpoints=1,
loc="lower left",
prop={'size': 12})
fig.subplots_adjust(left=0.01,
bottom=0.01,
right=0.99,
top=0.99,
wspace=0.4,
hspace=0.4)
fig.savefig(FigFolder + '/Figure1.pdf', format='pdf', bbox_inches='tight')
def run():
# parameter dictionary
p = {}
p['number_batches'] = 3
p['leakage_penalty'] = 0.04
p['assembly_width'] = 21.5036
p['assembly_power'] = 3.4 / 193
p['active_height'] = 366.0
p['fuel_radius'] = 0.4096
p['cladding_inner_radius'] = 0.4180
p['cladding_outer_radius'] = 0.4750
p['number_pins'] = 264
p['power_share'] = 'reactivity'
T_F = 900 * sp.ones(p['number_batches']) # batch fuel temperatures (K)
T_C = 580 * sp.ones(
p['number_batches']) # batch moderator temperatures (K)
num_thick = 20
#thick = sp.linspace(0.0, 500, num_thick)
thick = sp.logspace(-1, sp.log10(5 * 10**2), num_thick)
T_F_FeCrAl = sp.zeros((3, num_thick))
T_C_FeCrAl = sp.zeros((3, num_thick))
T_F_SiC = sp.zeros((3, num_thick))
T_C_SiC = sp.zeros((3, num_thick))
PPF_FeCrAl = sp.zeros((3, num_thick))
PPF_SiC = sp.zeros((3, num_thick))
solver = NRM(p, rho=rho, m2=m2, k_cladding=k_cladding)
for i in range(num_thick):
p['t_fecral'] = thick[i]
p['t_sic'] = 0.0
B, ppf, T_F, T_C = solver.solve(T_F, T_C)
T_F_FeCrAl[:, i] = T_F[:]
T_C_FeCrAl[:, i] = T_C[:]
PPF_FeCrAl[:, i] = ppf[:]
p['t_fecral'] = 0.0
p['t_sic'] = thick[i]
B, ppf, T_F, T_C = solver.solve(T_F, T_C)
T_F_SiC[:, i] = T_F[:]
T_C_SiC[:, i] = T_C[:]
PPF_SiC[:, i] = ppf[:]
pickle.dump(
{
'thick': thick,
'T_F_FeCrAl': T_F_FeCrAl,
'T_C_FeCrAl': T_C_FeCrAl,
'PPF_FeCrAl': PPF_FeCrAl,
'T_F_SiC': T_F_SiC,
'T_C_SiC': T_C_SiC,
'PPF_SiC': PPF_SiC
}, open('example_3.p', 'wb'))
def plot(self, indice):
self.diagrama.ax.clear()
self.diagrama.ax.set_xlim(0.1, 10)
self.diagrama.ax.set_ylim(0, 1)
self.diagrama.ax.set_xscale("log")
self.diagrama.ax.set_title(QtWidgets.QApplication.translate(
"pychemqt", "Heat Transfer Temperature Effectiveness"), size='12')
self.diagrama.ax.set_xlabel("NTU", size='12')
self.diagrama.ax.set_ylabel("P", size='14')
self.diagrama.ax.set_xticklabels(["0.1", "1.0", "10"])
xticklabels = ["0.2", "0.3", "", "0.5", "", "0.7", "", "", "2.0",
"3.0", "", "5.0", "", "7.0", "", ""]
self.diagrama.ax.set_xticklabels(xticklabels, minor=True)
flujo = self.flujo[indice][1]
self.mixed.setVisible(flujo == "CrFSMix")
kwargs = {}
if flujo == "CrFSMix":
kwargs["mixed"] = str(self.mixed.currentText())
R = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.2, 1.4, 1.6, 1.8,
2., 2.5, 3., 4., 6., 8., 10., 15.]
NTU = logspace(-1.5, 1, 100)
for ri in R:
e = [0]+[TemperatureEffectiveness(N, ri, flujo, **kwargs) for N in NTU[1:]]
self.diagrama.plot(NTU, e, "k")
self.diagrama.ax.annotate(" R=%0.1f" % ri, (NTU[-1], e[-1]),
size="medium", ha="left", va="center")
# F=[0.3]
# for f in F:
# p=[]
# NTU=[]
# for r in R:
# func=lambda P: CorrectionFactor(P, r, flujo)-f
# print func(0.)
# pi=fsolve(func, 0.2)
# p.append(pi)
# NTU.append(NTU_fPR(p, r, flujo))
# p=[fsolve(lambda P: CorrectionFactor(P, r, flujo)-f, 0.5)[0] for r in R]
# NTU=[NTU_fPR(pi, ri) for pi, ni in zip(p, R)]
# self.diagrama.plot(NTU, p, "--")
self.diagrama.draw()
if flujo == "CrFSMix" and self.mixed.currentIndex():
img = image.imread('images/equation/%s2.png' % flujo)
else:
img = image.imread('images/equation/%s.png' % flujo)
self.image.set_data(img)
self.refixImage()
def _make_forces(self, extreme_forces, num):
a = extreme_forces[0]
b = extreme_forces[1]
c = extreme_forces[2]
#print a, b, c, num
forces = numpy.append(
b -( scipy.logspace(scipy.log10(a), scipy.log10(b),
num=num/2+1) - a),
scipy.logspace(scipy.log10(b), scipy.log10(c),
num=num-num/2)[1:]
)
forces = numpy.array( sorted(list(set(forces))) )
if len(forces) != num:
Exception("problem with forces: length ", len(forces))
#print forces
#for i in range(len(forces)):
# f = forces[i]
# rand = random.uniform( 0.99*f, 1.01*f)
# forces[i] = rand
return forces
def run() :
# parameter dictionary
p = {}
p['number_batches'] = 3
p['leakage_penalty'] = 0.04
p['assembly_width'] = 21.5036
p['assembly_power'] = 3.4/193
p['active_height'] = 366.0
p['fuel_radius'] = 0.4096
p['cladding_inner_radius'] = 0.4180
p['cladding_outer_radius'] = 0.4750
p['number_pins'] = 264
p['power_share'] = 'reactivity'
T_F = 900*sp.ones(p['number_batches']) # batch fuel temperatures (K)
T_C = 580*sp.ones(p['number_batches']) # batch moderator temperatures (K)
num_thick = 20
#thick = sp.linspace(0.0, 500, num_thick)
thick = sp.logspace(-1, sp.log10(5*10**2), num_thick)
T_F_FeCrAl = sp.zeros((3, num_thick))
T_C_FeCrAl = sp.zeros((3, num_thick))
T_F_SiC = sp.zeros((3, num_thick))
T_C_SiC = sp.zeros((3, num_thick))
PPF_FeCrAl = sp.zeros((3, num_thick))
PPF_SiC = sp.zeros((3, num_thick))
solver = NRM(p, rho=rho, m2=m2, k_cladding=k_cladding)
for i in range(num_thick) :
p['t_fecral'] = thick[i]
p['t_sic'] = 0.0
B, ppf, T_F, T_C = solver.solve(T_F, T_C)
T_F_FeCrAl[:, i] = T_F[:]
T_C_FeCrAl[:, i] = T_C[:]
PPF_FeCrAl[:, i] = ppf[:]
p['t_fecral'] = 0.0
p['t_sic'] = thick[i]
B, ppf, T_F, T_C = solver.solve(T_F, T_C)
T_F_SiC[:, i] = T_F[:]
T_C_SiC[:, i] = T_C[:]
PPF_SiC[:, i] = ppf[:]
pickle.dump({'thick': thick,
'T_F_FeCrAl': T_F_FeCrAl,
'T_C_FeCrAl': T_C_FeCrAl,
'PPF_FeCrAl': PPF_FeCrAl,
'T_F_SiC': T_F_SiC,
'T_C_SiC': T_C_SiC,
'PPF_SiC': PPF_SiC}, open('example_3.p', 'w'))
def run(self, npts=25, inv_pressures=None):
r"""
Run the algorithm for specified number of points or at given capillary
pressures.
Parameters
----------
npts : scalar
The number of points to obtain on the curve. The points are
automatically selected to span the range of capillary pressures
using a logarithmic spacing (more points are lower capillary
pressure values).
inv_pressures : array_like
A list of capillary pressures to apply. List should contain
increasing and unique values.
"""
# If no invasion points are given then generate some
if inv_pressures is None:
logger.info('Generating list of invasion pressures')
min_p = sp.amin(self['throat.entry_pressure']) * 0.98 # nudge down
max_p = sp.amax(self['throat.entry_pressure']) * 1.02 # bump up
inv_points = sp.logspace(sp.log10(min_p),
sp.log10(max_p),
npts)
else:
# Make sure the given invastion points are sensible
inv_points = sp.unique(inv_pressures)
self._inv_points = inv_points
# Ensure inlets are set
if sp.sum(self['pore.inlets']) == 0:
raise Exception('Inlet pores have not been specified')
# Ensure outlet pores are set if trapping is enabled
if self._trapping:
if sp.sum(self['pore.outlets']) == 0:
raise Exception('Outlet pores have not been specified')
# Generate curve from points
for inv_val in self._inv_points:
# Apply one applied pressure and determine invaded pores
logger.info('Applying capillary pressure: ' + str(inv_val))
self._apply_percolation(inv_val)
if self._trapping:
logger.info('Checking for trapping')
self._check_trapping(inv_val)
# Find invasion sequence values (to correspond with IP algorithm)
Pinv = self['pore.inv_Pc']
self['pore.inv_seq'] = sp.searchsorted(sp.unique(Pinv), Pinv)
Tinv = self['throat.inv_Pc']
self['throat.inv_seq'] = sp.searchsorted(sp.unique(Tinv), Tinv)
def bin_flux(flux, struct):
lower = 1e-5
upper = 2e7
eb = energy_groups(struct, lower, upper)
phi = sp.zeros(len(eb) - 1)
for i in range(len(eb) - 1):
E = sp.logspace(sp.log10(eb[i + 1]), sp.log10(eb[i]), 1e4)
x = trapz(flux(E), E)
print("->", i, eb[i + 1], eb[i], x)
phi[i] = trapz(flux(E), E)
phi = phi[::-1] / np.sum(phi)
return phi
def runContinuation(self,parameter,low,high,density,par3d=None,logrange=True,runQuiet=True):
"""
Run the continuation using the following parameters:
Args:
- parameter = str(the parameter to be scanned)
- low = float(lower bound)
- high = float(upper bound)
- density = int(the number of initial points)
- par3d = float(extra 3d parameter to insert into the output array) this parameter is not set ONLY used in output
- logrange = boolean [default = True], if True generate the result using logspace(log10(low), log10(high), density) otherwise use a linear range
- runQuiet = boolean [default = True], if True do not display intermediate results to screen, disable for debugging
After running the continuation the results are stored in numpy arrays
- mod.res_idx = scan parameter values (and optionally par3d)
- mod.res_metab = steady-state species concentrations
- mod.res_flux = steady-state flux values
"""
self.pitcon_scan_density = density
self.pitcon_scan_parameter = parameter
self.pitcon_scan_parameter_3d = par3d
if logrange:
self.pitcon_range_low = scipy.log10(low)
self.pitcon_range_high = scipy.log10(high)
self.model.pitcon_par_space = scipy.logspace(self.pitcon_range_low,self.pitcon_range_high,self.pitcon_scan_density)
else:
self.pitcon_range_low = low
self.pitcon_range_high = high
self.model.pitcon_par_space = scipy.linspace(self.pitcon_range_low,self.pitcon_range_high,self.pitcon_scan_density)
self.model.pitcon_flux_gen = 1
if runQuiet:
self.model.SetQuiet()
else:
self.model.SetLoud()
if self.pitcon_scan_parameter_3d != None:
self.pitcon_res = self.model.PITCON(self.pitcon_scan_parameter, self.pitcon_scan_parameter_3d)
self.res_idx = self.pitcon_res[:,:2]
self.res_metab = self.pitcon_res[:,2:len(self.model.species)+2:]
self.res_flux = self.pitcon_res[:,len(self.model.species)+2:]
else:
self.pitcon_res = self.model.PITCON(self.pitcon_scan_parameter)
self.res_idx = self.pitcon_res[:,0]
self.res_idx = self.res_idx.reshape(self.res_idx.shape[0],1)
self.res_metab = self.pitcon_res[:,1:len(self.model.species)+1]
self.res_flux = self.pitcon_res[:,len(self.model.species)+1:]
print '\n\tContinuation complete\n'
def plot_pk_lin(): from matplotlib import pyplot k,pklin = load_pklin() pyregpt = PyRegPT() pyregpt.set_pk_lin(k,pklin) kout = scipy.logspace(scipy.log10(k[0])-2,scipy.log10(k[-1])+1,1000,base=10) for interpol in ['lin','poly']: pyplot.loglog(kout,pyregpt.find_pk_lin(kout,interpol=interpol),label=interpol) pyplot.axvline(x=k[0],ymin=0.,ymax=1.) pyplot.axvline(x=k[-1],ymin=0.,ymax=1.) pyplot.legend() pyplot.show()
def define_bins(self, **kwargs):
r"""
This defines the bins for a logscaled histogram
"""
self.data_vector.sort()
sf = self.args['scale_fact']
num_bins = int(sp.logn(sf, self.data_vector[-1]) + 1)
#
# generating initial bins from 1 - sf**num_bins
low = list(sp.logspace(0, num_bins, num_bins + 1, base=sf))[:-1]
high = list(sp.logspace(0, num_bins, num_bins + 1, base=sf))[1:]
#
# Adding "catch all" bins for anything between 0 - 1 and less than 0
if self.data_vector[0] < 1.0:
low.insert(0, 0.0)
high.insert(0, 1.0)
if self.data_vector[0] < 0.0:
low.insert(0, self.data_vector[0])
high.insert(0, 0.0)
#
self.bins = [bin_ for bin_ in zip(low, high)]
def setScanJobs(self, start, end, intervals, job, log=False):
"""Splits a range into a number of jobs with intervals"""
assert intervals >= 1, '\n* Minimum of 1 interval'
if log:
kpoints = scipy.logspace(scipy.log10(start), scipy.log10(end), intervals+1)
else:
kpoints = scipy.linspace(start, end, intervals+1)
self.job_list = []
for p in range(len(kpoints)-1):
job2 = job % (kpoints[p], kpoints[p+1])
self.job_list.append(job2)
print(job2)
def runContinuation(self,parameter,low,high,density,par3d=None,logrange=True,runQuiet=True):
"""
Run the continuation using the following parameters:
Args:
- parameter = str(the parameter to be scanned)
- low = float(lower bound)
- high = float(upper bound)
- density = int(the number of initial points)
- par3d = float(extra 3d parameter to insert into the output array) this parameter is not set ONLY used in output
- logrange = boolean [default = True], if True generate the result using logspace(log10(low), log10(high), density) otherwise use a linear range
- runQuiet = boolean [default = True], if True do not display intermediate results to screen, disable for debugging
After running the continuation the results are stored in numpy arrays
- mod.res_idx = scan parameter values (and optionally par3d)
- mod.res_metab = steady-state species concentrations
- mod.res_flux = steady-state flux values
"""
self.pitcon_scan_density = density
self.pitcon_scan_parameter = parameter
self.pitcon_scan_parameter_3d = par3d
if logrange:
self.pitcon_range_low = scipy.log10(low)
self.pitcon_range_high = scipy.log10(high)
self.model.pitcon_par_space = scipy.logspace(self.pitcon_range_low,self.pitcon_range_high,self.pitcon_scan_density)
else:
self.pitcon_range_low = low
self.pitcon_range_high = high
self.model.pitcon_par_space = scipy.linspace(self.pitcon_range_low,self.pitcon_range_high,self.pitcon_scan_density)
self.model.pitcon_flux_gen = 1
if runQuiet:
self.model.SetQuiet()
else:
self.model.SetLoud()
if self.pitcon_scan_parameter_3d != None:
self.pitcon_res = self.model.PITCON(self.pitcon_scan_parameter, self.pitcon_scan_parameter_3d)
self.res_idx = self.pitcon_res[:,:2]
self.res_metab = self.pitcon_res[:,2:len(self.model.species)+2:]
self.res_flux = self.pitcon_res[:,len(self.model.species)+2:]
else:
self.pitcon_res = self.model.PITCON(self.pitcon_scan_parameter)
self.res_idx = self.pitcon_res[:,0]
self.res_idx = self.res_idx.reshape(self.res_idx.shape[0],1)
self.res_metab = self.pitcon_res[:,1:len(self.model.species)+1]
self.res_flux = self.pitcon_res[:,len(self.model.species)+1:]
print '\n\tContinuation complete\n'
def define_bins(self, **kwargs):
r"""
This defines the bins for a logscaled histogram
"""
self.data_vector.sort()
sf = self.args['scale_fact']
num_bins = int(sp.logn(sf, self.data_vector[-1]) + 1)
#
# generating initial bins from 1 - sf**num_bins
low = list(sp.logspace(0, num_bins, num_bins + 1, base=sf))[:-1]
high = list(sp.logspace(0, num_bins, num_bins + 1, base=sf))[1:]
#
# Adding "catch all" bins for anything between 0 - 1 and less than 0
if self.data_vector[0] < 1.0:
low.insert(0, 0.0)
high.insert(0, 1.0)
if self.data_vector[0] < 0.0:
low.insert(0, self.data_vector[0])
high.insert(0, 0.0)
#
self.bins = [bin_ for bin_ in zip(low, high)]
def run(self, npts=25, inv_pressures=None):
r"""
Run the algorithm for specified number of points or at given capillary
pressures.
Parameters
----------
npts : scalar
The number of points to obtain on the curve. The points are
automatically selected to span the range of capillary pressures
using a logarithmic spacing (more points are lower capillary
pressure values).
inv_pressures : array_like
A list of capillary pressures to apply. List should contain
increasing and unique values.
"""
# If no invasion points are given then generate some
if inv_pressures is None:
logger.info('Generating list of invasion pressures')
min_p = sp.amin(self['throat.entry_pressure']) * 0.98 # nudge down
max_p = sp.amax(self['throat.entry_pressure']) * 1.02 # bump up
inv_points = sp.logspace(sp.log10(min_p), sp.log10(max_p), npts)
else:
# Make sure the given invastion points are sensible
inv_points = sp.unique(inv_pressures)
self._inv_points = inv_points
# Ensure inlets are set
if sp.sum(self['pore.inlets']) == 0:
raise Exception('Inlet pores have not been specified')
# Ensure outlet pores are set if trapping is enabled
if self._trapping:
if sp.sum(self['pore.outlets']) == 0:
raise Exception('Outlet pores have not been specified')
# Generate curve from points
for inv_val in self._inv_points:
# Apply one applied pressure and determine invaded pores
logger.info('Applying capillary pressure: ' + str(inv_val))
self._apply_percolation(inv_val)
if self._trapping:
logger.info('Checking for trapping')
self._check_trapping(inv_val)
# Find invasion sequence values (to correspond with IP algorithm)
Pinv = self['pore.inv_Pc']
self['pore.inv_seq'] = sp.searchsorted(sp.unique(Pinv), Pinv)
Tinv = self['throat.inv_Pc']
self['throat.inv_seq'] = sp.searchsorted(sp.unique(Tinv), Tinv)
def makeRange(self,start,end,points,log):
"""
Should be pretty self evident it defines a range:
- float(start)
- float(end)
- int(points)
- bool(log)
"""
if log:
rng = scipy.logspace(scipy.log10(start),scipy.log10(end),points)
else:
rng = scipy.linspace(start,end,points)
return rng
def test_gaussian_multiple_populations_crossval_kde(db_path, sampler):
sigma_x = 1
sigma_y = .5
y_observed = 2
def model(args):
return {"y": st.norm(args['x'], sigma_y).rvs()}
models = [model]
models = list(map(SimpleModel, models))
nr_populations = 4
population_size = ConstantPopulationSize(600)
parameter_given_model_prior_distribution = [
Distribution(x=st.norm(0, sigma_x))
]
parameter_perturbation_kernels = [
GridSearchCV(MultivariateNormalTransition(),
{"scaling": sp.logspace(-1, 1.5, 5)})
]
abc = ABCSMC(models,
parameter_given_model_prior_distribution,
MinMaxDistanceFunction(measures_to_use=["y"]),
population_size,
transitions=parameter_perturbation_kernels,
eps=MedianEpsilon(.2),
sampler=sampler)
abc.new(db_path, {"y": y_observed})
minimum_epsilon = -1
abc.do_not_stop_when_only_single_model_alive()
history = abc.run(minimum_epsilon, max_nr_populations=nr_populations)
posterior_x, posterior_weight = history.get_distribution(0, None)
posterior_x = posterior_x["x"].as_matrix()
sort_indices = sp.argsort(posterior_x)
f_empirical = sp.interpolate.interp1d(
sp.hstack((-200, posterior_x[sort_indices], 200)),
sp.hstack((0, sp.cumsum(posterior_weight[sort_indices]), 1)))
sigma_x_given_y = 1 / sp.sqrt(1 / sigma_x**2 + 1 / sigma_y**2)
mu_x_given_y = sigma_x_given_y**2 * y_observed / sigma_y**2
expected_posterior_x = st.norm(mu_x_given_y, sigma_x_given_y)
x = sp.linspace(-8, 8)
max_distribution_difference = sp.absolute(
f_empirical(x) - expected_posterior_x.cdf(x)).max()
assert max_distribution_difference < 0.052
assert history.max_t == nr_populations - 1
mean_emp, std_emp = mean_and_std(posterior_x, posterior_weight)
assert abs(mean_emp - mu_x_given_y) < .07
assert abs(std_emp - sigma_x_given_y) < .12
def makeRange(self,start,end,points,log):
"""
Should be pretty self evident it defines a range:
- float(start)
- float(end)
- int(points)
- bool(log)
"""
if log:
rng = scipy.logspace(scipy.log10(start),scipy.log10(end),points)
else:
rng = scipy.linspace(start,end,points)
return rng
def getquarts(data1, data2, log=False):
n = len(data1)
mx = -sp.Inf
mn = sp.Inf
for i in xrange(n):
mn = min(mn, min(data1[i]))
mx = max(mx, max(data1[i]))
if not log:
xaxis = sp.linspace(mn, mx, 200)
else:
xaxis = sp.logspace(sp.log10(mn), sp.log10(mx), 200)
low0, med0, upp0 = gpbo.core.ESutils.quartsirregular(data1, data2, xaxis)
return xaxis, low0, med0, upp0
def betweenness_distrib(net, use_weights=True, log=False):
'''
Computing the betweenness distribution of a network
Parameters
----------
net : :class:`~nngt.Graph` or subclass
the network to analyze.
use_weights : bool, optional (default: True)
use weighted degrees (do not take the sign into account : all weights
are positive).
log : bool, optional (default: False)
use log-spaced bins.
Returns
-------
ncounts : :class:`numpy.array`
number of nodes in each bin
nbetw : :class:`numpy.array`
bins for node betweenness
ecounts : :class:`numpy.array`
number of edges in each bin
ebetw : :class:`numpy.array`
bins for edge betweenness
'''
ia_nbetw, ia_ebetw = net.get_betweenness(use_weights)
num_nbins, num_ebins = int(len(ia_nbetw) / 50), int(len(ia_ebetw) / 50)
ra_nbins = sp.linspace(ia_nbetw.min(), ia_nbetw.max(), num_nbins)
ra_ebins = sp.linspace(ia_ebetw.min(), ia_ebetw.max(), num_ebins)
if log:
ra_nbins = sp.logspace(sp.log10(sp.maximum(ia_nbetw.min(),10**-8)),
sp.log10(ia_nbetw.max()), num_nbins)
ra_ebins = sp.logspace(sp.log10(sp.maximum(ia_ebetw.min(),10**-8)),
sp.log10(ia_ebetw.max()), num_ebins)
ncounts,nbetw = sp.histogram(ia_nbetw, ra_nbins)
ecounts,ebetw = sp.histogram(ia_ebetw, ra_ebins)
return ncounts, nbetw[:-1], ecounts, ebetw[:-1]
def plot(self, indice):
self.diagrama.axes2D.clear()
self.diagrama.axes2D.set_xlim(0.1, 10)
self.diagrama.axes2D.set_ylim(0, 1)
self.diagrama.axes2D.set_xscale("log")
self.diagrama.axes2D.set_title(QtGui.QApplication.translate("pychemqt", "Heat Transfer Temperature Effectiveness"), size='12')
self.diagrama.axes2D.set_xlabel("NTU", size='12')
self.diagrama.axes2D.set_ylabel("P", size='14')
self.diagrama.axes2D.set_xticklabels(["0.1", "1.0", "10"])
self.diagrama.axes2D.set_xticklabels(["0.2", "0.3", "", "0.5", "", "0.7", "", "", "2.0", "3.0", "", "5.0", "", "7.0", "", ""], minor=True)
flujo=self.flujo[indice][1]
self.mixed.setVisible(flujo=="CrFSMix")
kwargs={}
if flujo=="CrFSMix":
kwargs["mixed"]=str(self.mixed.currentText())
R=[0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.2, 1.4, 1.6, 1.8, 2., 2.5, 3., 4., 6., 8., 10., 15.]
NTU=logspace(-1.5, 1, 100)
for ri in R:
e=[0]+[Heat_ExchangerDesign.TemperatureEffectiveness(N, ri, flujo, **kwargs) for N in NTU[1:]]
self.diagrama.plot(NTU, e, "k")
self.diagrama.axes2D.annotate(" R=%0.1f" %ri, (NTU[-1], e[-1]), size="medium", horizontalalignment="left", verticalalignment="center")
# F=[0.3]
# for f in F:
# p=[]
# NTU=[]
# for r in R:
# func=lambda P: Heat_ExchangerDesign.CorrectionFactor(P, r, flujo)-f
# print func(0.)
# pi=fsolve(func, 0.2)
# p.append(pi)
# NTU.append(Heat_ExchangerDesign.NTU_fPR(p, r, flujo))
# p=[fsolve(lambda P: Heat_ExchangerDesign.CorrectionFactor(P, r, flujo)-f, 0.5)[0] for r in R]
# NTU=[Heat_ExchangerDesign.NTU_fPR(pi, ri) for pi, ni in zip(p, R)]
# self.diagrama.plot(NTU, p, "--")
self.diagrama.draw()
if flujo=="CrFSMix" and self.mixed.currentIndex():
img=image.imread('images/equation/%s2.png' %flujo)
else:
img=image.imread('images/equation/%s.png' %flujo)
self.image.set_data(img)
self.refixImage()
def P_CONTINUATION(self, *args):
"""
[str(p), float(min), float(max), int(points), *float(y-value)]
"""
self.setStatus('CONTINUING')
args = args[0]
print 'Args', args
self.model.pitcon_par_space = scipy.logspace(\
scipy.log10(float(args[1].strip())), scipy.log10(float(args[2].strip())), int(args[3].strip()))
if len(args) == 4:
self.RESULT = self.model.PITCON(args[0].strip())
elif len(args) == 5:
self.RESULT = self.model.PITCON(args[0].strip(), float(args[4].strip()))
return True
def run(self, npts=20, sizes=None):
self._make_dt()
if npts is not None:
sizes = sp.logspace(sp.log10(sp.amax(self._imdt)), 0.1, npts)
self._make_seeds(sizes=sizes)
imresults = sp.zeros(sp.shape(self.image))
print('Dilating seeds')
print('0%|'+'-'*len(sizes)+'|100%')
print(' |', end='')
for r in sizes:
print('.', end='')
sys.stdout.flush()
im = self._dilate_seeds(im_seeds=self._imseeds, radius=r)
imresults[(imresults == 0) * im] = r
print('')
self._iminv = imresults
def P_CONTINUATION(self, *args):
"""
[str(p), float(min), float(max), int(points), *float(y-value)]
"""
self.setStatus('CONTINUING')
args = args[0]
print 'Args', args
self.model.pitcon_par_space = scipy.logspace(\
scipy.log10(float(args[1].strip())), scipy.log10(float(args[2].strip())), int(args[3].strip()))
if len(args) == 4:
self.RESULT = self.model.PITCON(args[0].strip())
elif len(args) == 5:
self.RESULT = self.model.PITCON(args[0].strip(), float(args[4].strip()))
return True
def run(self):
#See if setup has been run
try: capillary_pressure = self._p_cap
except:
raise Exception('setup has not been run, cannot proceed!')
#Create a pore and throat conditions list to store inv_val at which each is invaded
self._p_inv = sp.zeros((self._net.num_pores(),))
self._p_seq = sp.zeros_like(self._p_inv)
self._t_inv = sp.zeros((self._net.num_throats(),))
self._t_seq = sp.zeros_like(self._t_inv)
#Determine the invasion pressures to apply
self._t_cap = self._net.get_throat_data(phase=self._fluid_inv,prop=capillary_pressure)
min_p = sp.amin(self._t_cap)*0.98 # nudge min_p down slightly
max_p = sp.amax(self._t_cap)*1.02 # bump max_p up slightly
self._inv_points = sp.logspace(sp.log10(min_p),sp.log10(max_p),self._npts)
self._do_outer_iteration_stage()
def run(self, npts=20, sizes=None):
self._make_dt()
if npts is not None:
sizes = sp.logspace(sp.log10(sp.amax(self._imdt)), 0.1, npts)
self._make_seeds(sizes=sizes)
imresults = sp.zeros(sp.shape(self.image))
print('Dilating seeds')
print('0%|' + '-' * len(sizes) + '|100%')
print(' |', end='')
for r in sizes:
print('.', end='')
sys.stdout.flush()
im = self._dilate_seeds(im_seeds=self._imseeds, radius=r)
imresults[(imresults == 0) * im] = r
print('')
self._iminv = imresults
def calc_cstr_locus_fast(Cf, rate_fn, t_end, num_pts):
'''
Quick (potentially inexact) CSTR solver using a standard non-linear solver
(Newton). The initial guess is based on the previous solution.
Note: this method will not find multiple solutions and may behave poorly
with systems with multiple solutions. Use only if you know that the system
is 'simple' (no multiple solutions) and you need a quick answer
Parameters:
Cf
rate_fn
t_end
num_pts
Returns:
cstr_cs
cstr_ts
'''
cstr_ts = sp.hstack([0., sp.logspace(-3, sp.log10(t_end), num_pts - 1)])
cstr_cs = []
# loop through each cstr residence time and solve for the corresponding
# cstr effluent concentration
C_guess = Cf
for ti in cstr_ts:
# define CSTR function
def cstr_fn(C):
return Cf + ti * rate_fn(C, 1) - C
# solve
ci = scipy.optimize.newton_krylov(cstr_fn, C_guess)
cstr_cs.append(ci)
# update guess
C_guess = ci
# convert to numpy array
cstr_cs = sp.array(cstr_cs)
return cstr_cs, cstr_ts
def __plot(self, metodo=0, eD=[]):
"""Plot the Moody chart using the indicate method
método de cálculo:
0 - Colebrook
1 - Chen (1979)
2 - Romeo (2002)
3 - Goudar-Sonnad
4 - Manadilli (1997)
5 - Serghides
6 - Churchill (1977)
7 - Zigrang-Sylvester (1982)
8 - Swamee-Jain (1976)")
eD: lista con las líneas de rugosidades relativas a dibujar
Prmin: escala del eje x, minimo valor de Pr a representar
Prmax: escala del eje y, maximo valor de Pr a representar
"""
if not eD:
eD=[0, 1e-6, 5e-6, 1e-5, 2e-5, 5e-5, 1e-4, 2e-4, 4e-4, 6e-4, 8e-4, 0.001, 0.0015, 0.002, 0.003, 0.004, 0.006, 0.008, 0.01, 0.0125, 0.015, 0.0175, 0.02, 0.025, 0.03, 0.035, 0.04, 0.045, 0.05, 0.06, 0.07]
F=f_list[metodo]
#laminar
Re=[600, 2400]
f=[64./R for R in Re]
self.diagrama.axes2D.plot(Re, f, "k")
#turbulento
Re=logspace(log10(2400), 8, 50)
for e in eD:
self.diagrama.axes2D.plot(Re, [F(Rei, e) for Rei in Re], "k")
self.diagrama.axes2D.annotate(representacion(e, tol=4.5), (Re[45], F(Re[45], e)), size="small", horizontalalignment="center", verticalalignment="bottom", rotation=arctan((log10(F(Re[47], e))-log10(F(Re[35], e)))/(log10(Re[47])-log10(Re[35])))*360/2/pi)
#Transición
f=[(1/(1.14-2*log10(3500/R)))**2 for R in Re]
self.diagrama.axes2D.plot(Re, f, "k", lw=0.5, linestyle=":")
self.diagrama.axes2D.add_artist(ConnectionPatch((600, 0.009), (2400, 0.009), "data", "data", arrowstyle="<|-|>", mutation_scale=20, fc="w"))
self.diagrama.axes2D.add_artist(ConnectionPatch((2400, 0.009), (6000, 0.009), "data", "data", arrowstyle="<|-|>", mutation_scale=20, fc="w"))
self.diagrama.axes2D.add_artist(ConnectionPatch((6000, 0.095), (40000, 0.095), "data", "data", arrowstyle="<|-|>", mutation_scale=20, fc="w"))
self.diagrama.axes2D.add_artist(ConnectionPatch((40000, 0.095), (9.9e7, 0.095), "data", "data", arrowstyle="<|-|>", mutation_scale=20, fc="w"))
self.diagrama.axes2D.text(15000, 0.094, QtGui.QApplication.translate("pychemqt", "Transition Zone"), size="small", verticalalignment="top", horizontalalignment="center")
self.diagrama.axes2D.text(2e6, 0.094, QtGui.QApplication.translate("pychemqt", "Turbulent flux fully desarrolled"), size="small", verticalalignment="top", horizontalalignment="center")
self.diagrama.axes2D.text(4000, 0.0091, QtGui.QApplication.translate("pychemqt", "Critic\nzone"), size="small", verticalalignment="bottom", horizontalalignment="center")
self.diagrama.axes2D.text(1200, 0.0091, QtGui.QApplication.translate("pychemqt", "Laminar flux"), size="small", verticalalignment="bottom", horizontalalignment="center")
def calc_pfr_trajectory(Cf, rate_fn, t_end, NUM_PTS=250, linspace_ts=False):
'''
Convenience function that integrate the PFR trajecotry from the feed point
specified Cf, using scipy.integrate.odeint().
Time is based on a logscaling
Parameters:
Cf (d x 1) numpy array. Feed concentration to the PFR.
rate_fn Python function. Rate function in (C,t) format that returns
an array equal to the length of Cf.
t_end Float indicating the residence time of the PFR.
NUM_PTS Optional. Number of PFR points.
Default value is 250 points.
Returns:
pfr_cs (NUM_PTS x d) numpy array representing the PFR trajectory
points.
pfr_ts (NUM_PTS x 1) numpy array of PFR residence times
corresponding to pfr_cs.
'''
# TODO: optional accuracy for integration
# since logspace can't give log10(0), append 0.0 to the beginning of pfr_ts
# and decrese NUM_PTS by 1
if linspace_ts:
pfr_ts = sp.linspace(0, t_end, NUM_PTS)
else:
pfr_ts = sp.append(0.0, sp.logspace(-3, sp.log10(t_end), NUM_PTS - 1))
pfr_cs = scipy.integrate.odeint(rate_fn, Cf, pfr_ts)
return pfr_cs, pfr_ts
def __init__(self):
self._tempangles = numpy.array([1,0.6,0.4,0.3,0.2,0.1,0.05,0.0])
self._angles = numpy.arccos(self._tempangles)
self._datafile = list(csv.reader(open("muonflux2.csv", "rb" ), delimiter = '\t')) # reads each row from the csv into a list, stores each list as an element of a list
self._fluxtable = [item for sublist in self._datafile for item in sublist] # flatten the list
self._concatflux = []
for i in xrange(len(self._fluxtable)/2):
x = float(self._fluxtable.pop(0))
y = float(self._fluxtable.pop(0))
self._concatflux.append(x*10**y)
self._fluxdata = numpy.array(self._concatflux).reshape(-1,9) # takes flattened array and reshapes to a 9 column matrix with arbitrary row size
self._cumsums = self._fluxdata
# this loop iterates over sliced rows to replace them with cumulative sums of the slice. The slice is the whole row minus the first element
for i in xrange(numpy.alen(self._cumsums)):
self._cumsums[i,1:] = numpy.cumsum(self._cumsums[i,1:])
self.interpgrid=scipy.interpolate.RectBivariateSpline(self._fluxdata[:,0],self._angles,self._fluxdata[:,1:],kx=1,ky=1)
self.precision = 30
self.newx = scipy.logspace(math.log10(self._fluxdata[0,0]),math.log10(self._fluxdata[-1,0]),self.precision)
#print self.newx # the interpolated energies
self.interpedgrid = self.interpgrid(self.newx,self._angles)
self.interpcumsumgrid = scipy.interpolate.RectBivariateSpline(self._fluxdata[:,0],self._angles,self._cumsums[:,1:],kx=1,ky=1)
self.interpedcumsums = self.interpcumsumgrid(self.newx,self._angles)
self._ncs = numpy.cumsum(self.interpedcumsums[:,-1]) # takes the cumulative sum of the last column of cumsums[]
self._ncs = self._ncs/self._ncs[-1] # normalizes to the last element which is the largest
# this loop does the same thing, but for the rows
for i in xrange(numpy.alen(self.interpedcumsums)):
self.interpedcumsums[i,:] /= self.interpedcumsums[i,-1]
def get_error(num_points, num_iter=100):
"""
Compute mean and standard deviation from the mean. Standard deviation from
the mean is error.
"""
num_points = sp.floor(num_points)
pi_values = []
for i in range(num_iter):
pi_values.append(find_pi_approx(num_points)[1])
pi_values = sp.array(pi_values)
return num_points, sp.std(pi_values)
if __name__ == '__main__':
points = sp.logspace(4, 6, 100)
x = []
y = []
for i in points:
num_points, err = get_error(i)
print(num_points, err)
x.append(num_points)
y.append(err)
plt.figure(0)
plt.plot(x, y)
plt.show()
def trainModel(self, do_pca = False,out_dir='./cache', rftop = 40, class_labels = SP.array(['G1','S','G2M']), cv=10, npc=3, is_SVM=1, is_RFE=0 , scale=False):
if not os.path.exists(out_dir):
os.makedirs(out_dir)
CFG = {}
CFG['is_RFE'] = is_RFE # use recursive feature selection (can be slow for large datasets)
CFG['is_SVM'] = is_SVM # use SVM with univariate feature selection (faster than RFE)
CFG['CV_inner'] = cv #inner CV for RFE_CV: either an int or 'LOOCV'
CFG['out_dir'] = out_dir
CFG['do_pca'] = do_pca
CFG['lassotop'] = 20
self.cv = cv
Y = self.Y
labels = self.labels
var_names = self.geneNames
numClasses = self.numClasses
predRF = SP.zeros((len(labels),numClasses))
predSVM = SP.zeros((len(labels),numClasses))
predSVMrbf = SP.zeros((len(labels),numClasses))
predGNB = SP.zeros((len(labels),numClasses))
predLR = SP.zeros((len(labels),numClasses))
predLRall = SP.zeros((len(labels),numClasses))
names_dict={}
if self.cv == 'LOOCV':
loo = LeaveOneOut(len(labels))
CV_list = (list(iter(loo)))
CV_list.append((SP.array(range(Y.shape[0])), SP.array(range(Y.shape[0]))))#all data...
else:
skf = StratifiedKFold(labels, n_folds=self.cv)
CV_list = (list(iter(skf)))
CV_list.append((SP.array(range(Y.shape[0])), SP.array(range(Y.shape[0]))))#all data...
lambda_best = SP.zeros((1,len(CV_list))).ravel()
print("Performing cross validation ...")
for i in range(len(CV_list)):
if i<len(CV_list)-1:
print("Fold " + str(i+1) + " of " + str(len(CV_list)-1))
else:
print("Final model")
# string label for this fold
#get data of a CV run
cv_tr = CV_list[i][0]
cv_tst = CV_list[i][1]
lab_tr = labels[cv_tr]
Ytr = Y[cv_tr,:]
Ytst = Y[cv_tst,:]
lab_tst = labels[cv_tst]
if (i==len(CV_list)-1):
foldlabel = 'full'
if (self.Y_tst==None):
Ytst = Y[cv_tst,:]
lab_tst = labels[cv_tst]
else:
foldlabel = 'Test'
Ytst = self.Y_tst
lab_tst = self.labels_tst
else:
foldlabel = str(i)
if do_pca>=1:
npc = npc#3
#do PCA to get features
pcaCC = PCA(n_components=npc, whiten=False)
pcaCC.fit(Ytr)
pcaTst=pcaCC.transform(Ytst)
pcaTr=pcaCC.transform(Ytr)
#selection = SelectKBest(k=1)
#combined_features = FeatureUnion([("pca", pcaCC), ("univ_select", selection)])
combined_features = FeatureUnion([("pca", pcaCC)])
gnb = GaussianNB()
y_pred = gnb.fit(pcaTr, lab_tr).predict_proba(pcaTst)
if i<len(CV_list)-1:
predGNB[cv_tst,:] =y_pred#[:,1]
else:
predGNB_ts = y_pred#[:,1]
if do_pca==2:
Ytr = SP.concatenate((Ytr, pcaTr),1)
Ytst = SP.concatenate((Ytst, pcaTst),1)
pcnames = []
for pci in range(npc):
pcnames.append('PC'+str(pci+1))
var_names = SP.concatenate((var_names, SP.array(pcnames)),1)
print(" Computing random forest ...")
if CFG['is_RFE']==1:#Recursive feature selection with SVM
print(" Computing RFE with SVM ...")
svc = SVC(kernel="linear", probability=False, class_weight='auto')#use linear SVM for selection
rfecv = RFECV(estimator=svc, step=1,scoring='f1')
param_grid = dict(estimator__C=[0.1, 1, 10, 100, 1000])
clf_rfe = GridSearchCV(rfecv, param_grid=param_grid, cv=3, scoring='f1')#GridSearch to find optimal parameters
clf_rfe.fit(Ytr, lab_tr)
svc = SVC(kernel="linear", probability=False,C=clf_rfe.best_estimator_.estimator.C, class_weight='auto')#use linear SVM for selection
if CFG['CV_inner']=='':
rfecv = RFECV(estimator=svc, step=1,scoring='f1')
elif CFG['CV_inner']=='LOOCV':
rfecv = RFECV(estimator=svc, step=1,scoring='f1', cv=LeaveOneOut(len(lab_tr)))
else:
rfecv = RFECV(estimator=svc, step=1,scoring='f1', cv=StratifiedKFold(lab_tr, n_folds=CFG['CV_inner']))
clf_rfe.best_estimator_.fit(Ytr, lab_tr)
predicted = clf_rfe.best_estimator_.predict(Ytst)
if i<len(CV_list)-1:
predSVM[cv_tst,:] = predicted
else:
predSVM_ts[cv_tst] = predicted
classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True)#rbf kernel for prediction
param_grid = dict(C=[0.1, 1], gamma=[1e-1,1e-2,1e-3])
clf_rbf = GridSearchCV(classifier, param_grid=param_grid, cv=3, scoring='f1')
clf_rbf.fit(Ytr[:,clf_rfe.best_estimator_.ranking_==1], lab_tr)
clf_rbf.best_estimator_.fit(Ytr[:,clf_rfe.best_estimator_.ranking_==1], lab_tr)
predicted = clf_rbf.best_estimator_.predict_proba(Ytst[:,clf_rfe.best_estimator_.ranking_==1])
if i<len(CV_list)-1:
predSVMrbf[cv_tst,:] = predicted
fpr, tpr, thresholds = metrics.roc_curve(lab_tst, predicted[:,1])
if (i==len(CV_list)-1) | CFG["CV_plots"]>0:
PL.figure()
PL.plot(fpr, tpr)
PL.savefig(CFG['out_dir']+'/RF_SVM_'+foldlabel+'.pdf')
names_dict[foldlabel+'_SVM']=self.geneNames[clf_rfe.best_estimator_.ranking_==1]
elif CFG['is_SVM']==1:#univariate FS with rbf SVM; choose this if you hava a large data set (many features, eg RNAseq)
print(" SVM feature selection ...")
classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True)
selection = SelectKBest(k=1)
combined_features = FeatureUnion([("univ_select", selection)])
X_features = combined_features.fit(Ytr, lab_tr).transform(Ytr)
scaler = preprocessing.StandardScaler().fit(Ytr)
YtrS = scaler.transform(Ytr)
YtstS = scaler.transform(Ytst)
classifier.fit(X_features, lab_tr)
pipeline = Pipeline([("features", combined_features), ("svm", classifier)])
if CFG['do_pca']==3:
param_grid = dict(features__pca__n_components=SP.unique(SP.round_(SP.logspace(1.0,max(SP.log2(Ytr.shape[1]), SP.log2(10)),num=min(5,Ytr.shape[1]),base=2.0))),
features__univ_select__k=SP.unique(SP.round_(SP.logspace(3.0,SP.log2(Ytr.shape[1]),num=min(10,Ytr.shape[1]),base=2.0))),
svm__C=[0.1, 1, 10], svm__gamma=[1e-1,1e-2,1e-3])
else:
C_range = 10. ** SP.arange(0, 2)
gamma_range = 10. ** SP.arange(-5, 1)
param_grid = dict(features__univ_select__k=SP.unique(SP.round_(SP.logspace(3.0,SP.log2(Ytr.shape[1]),num=min(10,Ytr.shape[1]),base=2.0))),
svm__C=C_range, svm__gamma=gamma_range)
clf = GridSearchCV(pipeline, param_grid=param_grid, cv=5, scoring='f1')
clf.fit(YtrS, lab_tr)
print("The best classifier is: ", clf.best_estimator_)
select_best=clf.best_estimator_.get_params()['features__univ_select']
#names_dict[foldlabel+'_SVM']=self.geneNames[SP.argsort(-1.0*select_best.scores_)[0:(select_best.k-1)]]
expected = lab_tst
predicted = clf.best_estimator_.predict_proba(YtstS)
if i<len(CV_list)-1:
predSVM[cv_tst,:] = predicted
else:
predSVM_ts = predicted
#print(clf.best_estimator_)
classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True)#rbf kernel for prediction
param_grid = dict(C=[1,10], gamma=[ 1e-1,1e-2,1e-3])
clf_rbf = GridSearchCV(classifier, param_grid=param_grid, cv=5, scoring='f1')
clf_rbf.fit(Ytr, lab_tr)
clf_rbf.best_estimator_.fit(Ytr, lab_tr)
predicted = clf_rbf.best_estimator_.predict_proba(Ytst)
if i<len(CV_list)-1:
predSVMrbf[cv_tst,:] = predicted
else:
predSVMrbf_ts = predicted
#do lasso with regularisation path
cs = l1_min_c(Ytr, lab_tr, loss='log') * SP.logspace(0, 3)
print(" Computing regularization path ...")
lasso = linear_model.LogisticRegression(C=cs[0]*10.0, penalty='l1', tol=1e-6)
param_grid = dict(C=cs)
clf_lr = GridSearchCV(lasso, param_grid=param_grid, cv=5, scoring='f1')
clf_lr.fit(Ytr, lab_tr)
clf_lr.best_estimator_.fit(Ytr, lab_tr)
lambda_best[i] = clf_lr.best_params_.get('C')
predicted = clf_lr.best_estimator_.predict_proba(Ytst)
clf = linear_model.LogisticRegression(C=cs[0]*10.0, penalty='l1', tol=1e-6)
coefs_ = []
for c in cs:
clf.set_params(C=c)
clf.fit(Ytr, lab_tr)
coefs_.append(clf.coef_.ravel().copy())
if i<len(CV_list)-1:
predLR[cv_tst,:] = predicted
else:
predLR_ts = predicted
coefs_ = SP.array(coefs_)
# get ordering by importance (how many times they appear)
order=(coefs_!=0).sum(axis=0).argsort()
order=order[::-1] # descending
# store this order
featrank_lasso = order
showtop= min(Ytr.shape[1], CFG['lassotop'])
clfAll = linear_model.LogisticRegression(C=1e5, penalty='l2', tol=1e-6)
clfAll.fit(Ytr, lab_tr)
predicted = clfAll.predict_proba(Ytst)
if i<len(CV_list)-1:
predLRall[cv_tst,:] = predicted
else:
predLRall_ts = predicted
forest = ExtraTreesClassifier(n_estimators=500,
random_state=0, criterion="entropy", bootstrap=False)
#forest = RandomForestClassifier(n_estimators=500,
# random_state=0, criterion="entropy")
forest.fit(Ytr, lab_tr)
pred = forest.predict_proba(Ytst)
#pdb.set_trace()
if i<len(CV_list)-1:
predRF[cv_tst,:] = pred#[:,1]
else:
predRF_ts = pred#[:,1]
importances = forest.feature_importances_
std = SP.std([tree.feature_importances_ for tree in forest.estimators_],
axis=0)
topfeat=min(Ytr.shape[1], rftop)
indices = SP.argsort(importances)[::-1][0:topfeat]
# store full feature ranking
featrank_rf = SP.argsort(importances)[::-1]
# Plot the feature importances of the forest
if (i==len(CV_list)-1):
PL.figure()
#PL.title("Feature importances, Fold "+foldddPPlabel+', AUC='+str(SP.round_(metrics.auc(fpr, tpr),3)))
PL.title("Feature importances")
#PL.bar(range(topfeat), importances[indices],color="r", yerr=std[indices], align="center")
PL.bar(range(topfeat), importances[indices],color="r", align="center")
PL.xticks(range(topfeat), indices, rotation=70)
PL.gca().set_xticklabels(var_names[indices])
PL.setp(PL.gca().get_xticklabels(), fontsize=8)
PL.xlim([-1, topfeat])
PL.savefig(out_dir+'/RF_featureimportance_'+foldlabel+'.pdf')
f2 = open(os.path.join(out_dir,'classification_reportCV.txt') ,'w')
predRFv = SP.argmax(predRF_ts,axis=1)+1
predRF_trv = SP.argmax(predRF,axis=1)+1
self.scores = predRF
self.scores_tst = predRF_ts
self.ranking = var_names[indices]
predLRv = SP.argmax(predLR_ts,axis=1)+1
predLR_trv = SP.argmax(predLR,axis=1)+1
self.scoresLR = predLR
self.scoresLR_tst = predLR_ts
predLRallv = SP.argmax(predLRall_ts,axis=1)+1
predLRall_trv = SP.argmax(predLRall,axis=1)+1
self.scoresLRall = predLRall
self.scoresLRall_tst = predLRall_ts
if CFG['is_SVM']==1:
predSVMv = SP.argmax(predSVM_ts,axis=1)+1
predSVM_trv = SP.argmax(predSVM,axis=1)+1
self.scoresSVM = predSVM
self.scoresSVM_tst = predSVM_ts
predSVMrbfv = SP.argmax(predSVMrbf_ts,axis=1)+1
predSVMrbf_trv = SP.argmax(predSVMrbf,axis=1)+1
self.scoresSVMrbf = predSVMrbf
self.scoresSVMrbf_tst = predSVMrbf_ts
predGNBv = SP.argmax(predGNB_ts,axis=1)+1
predGNB_trv = SP.argmax(predGNB,axis=1)+1
self.scoresGNB = predGNB
self.scoresGNB_tst = predGNB_ts
print("Classification report for classifier %s:\n%s\n" % ('Gaussian Naive Bayes', metrics.classification_report(self.labels, predGNB_trv)))
print("Classification report for classifier %s:\n%s\n" % ('Random Forest', metrics.classification_report(self.labels, predRF_trv)))
print("Classification report for classifier %s:\n%s\n" % ('LR', metrics.classification_report(self.labels, predLR_trv)))
print("Classification report for classifier %s:\n%s\n" % ('LRall', metrics.classification_report(self.labels, predLRall_trv)))
if CFG['is_RFE']==1:
print("Classification report for classifier %s:\n%s\n" % ('SVM ', metrics.classification_report(labels, predSVM>0.5)),file=f2)
elif CFG['is_SVM']==1:
print("Classification report for classifier %s:\n%s\n" % ('SVM', metrics.classification_report(self.labels, predSVM_trv)))
print("Classification report for classifier %s:\n%s\n" % ('SVMrbf', metrics.classification_report(self.labels, predSVMrbf_trv)))
f2.close()
def roomcomp(impresp, filter, target, ntaps, mixed_phase, opformat, trim, nsthresh, noplot):
print "Loading impulse response"
# Read impulse response
Fs, data = wavfile.read(impresp)
data = norm(np.hstack(data))
if trim:
print "Removing leading silence"
for spos,sval in enumerate(data):
if abs(sval)>nsthresh:
lzs=max(spos-1,0)
ld =len(data)
print 'Impulse starts at position ', spos, '/', len(data)
print 'Trimming ', float(lzs)/float(Fs), ' seconds of silence'
data=data[lzs:len(data)] #remove everything before sample at spos
break
print "\nSample rate = ", Fs
print "\nGenerating correction filter"
###
## Logarithmic pole positioning
###
fplog = np.hstack((sp.logspace(sp.log10(20.), sp.log10(200.), 14.), sp.logspace(sp.log10(250.),
sp.log10(20000.), 13.)))
plog = freqpoles(fplog, Fs)
###
## Preparing data
###
# making the measured response minumum-phase
cp, minresp = rceps(data)
# Impulse response
imp = np.zeros(len(data), dtype=np.float64)
imp[0]=1.0
# Target
outf = []
db = []
if target is 'flat':
# Make the target output a bandpass filter
Bf, Af = sig.butter(4, 30/(Fs/2), 'high')
outf = sig.lfilter(Bf, Af, imp)
else:
# load target file
t = np.loadtxt(target)
frq = t[:,0]; pwr = t[:,1]
# calculate the FIR filter via windowing method
fir = sig.firwin2(501, frq, np.power(10, pwr/20.0), nyq = frq[-1])
# Minimum phase, zero padding
cp, outf = rceps(np.append(fir, np.zeros(len(minresp) - len(fir))))
###
## Filter design
###
#Parallel filter design
(Bm, Am, FIR) = parfiltid(minresp, outf, plog)
# equalized loudspeaker response - filtering the
# measured transfer function by the parallel filter
equalizedresp = parfilt(Bm, Am, FIR, data)
# Equalizer impulse response - filtering a unit pulse
equalizer = norm(parfilt(Bm, Am, FIR, imp))
# Windowing with a half hanning window in time domain
han = np.hanning(ntaps*2)[-ntaps:]
equalizer = han * equalizer[:ntaps]
###
## Mixed-phase compensation
## Based on the paper "Mixed Time-Frequency approach for Multipoint
## Room Rosponse Equalization," by A. Carini et al.
## To use this feature, your Room Impulse Response should have all
## the leading zeros removed.
###
if mixed_phase is True:
# prototype function
hp = norm(np.real(equalizedresp))
# time integration of the human ear is ~24ms
# See "Measuring the mixing time in auditoria," by Defrance & Polack
hop_size = 0.024
samples = hop_size * Fs
bins = np.int(np.ceil(len(hp) / samples))
tmix = 0
# Kurtosis method
for b in range(bins):
start = np.int(b * samples)
end = np.int((b+1) * samples)
k = kurtosis(hp[start:end])
if k <= 0:
tmix = b * hop_size
break
# truncate the prototype function
taps = np.int(tmix*Fs)
print "\nmixing time(secs) = ", tmix, "; taps = ", taps
if taps > 0:
# Time reverse the array
h = hp[:taps][::-1]
# create all pass filter
phase = np.unwrap(np.angle(h))
H = np.exp(1j*phase)
# convert from db to linear
mixed = np.power(10, np.real(H)/20.0)
# create filter's impulse response
mixed = np.real(ifft(mixed))
# convolve and window to desired length
equalizer = conv(equalizer, mixed)
equalizer = han * equalizer[:ntaps]
#data = han * data[:ntaps]
#eqresp = np.real(conv(equalizer, data))
else:
print "zero taps; skipping mixed-phase computation"
if opformat in ('wav', 'wav24'):
# Write data
wavwrite_24(filter, Fs, norm(np.real(equalizer)))
print '\nOutput format is wav24'
print 'Output filter length =', len(equalizer), 'taps'
print 'Output filter written to ' + filter
print "\nUse sox to convert output .wav to raw 32 bit IEEE floating point if necessary,"
print "or to merge left and right channels into a stereo .wav"
print "\nExample: sox leq48.wav -t f32 leq48.bin"
print " sox -M le148.wav req48.wav output.wav\n"
elif opformat == 'wav32':
wavwrite_32(filter, Fs, norm(np.real(equalizer)))
print '\nOutput format is wav32'
print 'Output filter length =', len(equalizer), 'taps'
print 'Output filter written to ' + filter
print "\nUse sox to convert output .wav to raw 32 bit IEEE floating point if necessary,"
print "or to merge left and right channels into a stereo .wav"
print "\nExample: sox leq48.wav -t f32 leq48.bin"
print " sox -M le148.wav req48.wav output.wav\n"
elif opformat == 'bin':
# direct output to bin avoids float64->pcm16->float32 conversion by going direct
#float64->float32
f = open(filter, 'wb')
norm(np.real(equalizer)).astype('float32').tofile(f)
f.close()
print '\nOutput filter length =', len(equalizer), 'taps'
print 'Output filter written to ' + filter
else:
print 'Output format not recognized, no file generated.'
###
## Plots
###
if not noplot:
data *= 500
# original loudspeaker-room response
tfplot(data, Fs, avg = 'abs')
# 1/3 Octave smoothed
tfplots(data, Fs, 'r')
#tfplot(mixed, Fs, 'r')
# equalizer transfer function
tfplot(0.75*equalizer, Fs, 'g')
# indicating pole frequencies
plt.vlines(fplog, -2, 2, color='k', linestyles='solid')
# equalized loudspeaker-room response
tfplot(equalizedresp*0.01, Fs, avg = 'abs')
# 1/3 Octave smoothed
tfplots(equalizedresp*0.01, Fs, 'r')
# Add labels
# May need to reposition these based on input data
plt.text(325,30,'Unequalized loudspeaker-room response')
plt.text(100,-15,'Equalizer transfer function')
plt.text(100,-21,'(Black lines: pole locations)')
plt.text(130,-70,'Equalized loudspeaker-room response')
a = plt.gca()
a.set_xlim([20, 20000])
a.set_ylim([-80, 80])
plt.ylabel('Amplitude (dB)', color='b')
plt.xlabel('Frequency (Hz)')
plt.grid()
plt.legend()
plt.show()
