def energies(H, hermitian=False):
"""Given a hamiltonian matrix, calculates energies and sorts them."""
if hermitian:
eigvals, eigvecs = linalg.eigh(H)
else:
eigvals, eigvecs = linalg.eig(H)
indexes = sp.real_if_close(eigvals).argsort()
eigvals = sp.real_if_close(eigvals[indexes])
eigvecs = eigvecs[:, indexes]
return eigvals, eigvecs
def MarkovMutualInfo(transitionMatrix):
p0 = MarkovSteadyState(transitionMatrix)
#M = scipy.transpose(transitionMatrix)
M = transitionMatrix #***8testing
sum, dot, log2 = scipy.sum, scipy.dot, lambda x: scipy.nan_to_num(
scipy.log2(x))
return scipy.real_if_close(sum(dot(p0, M * log2(M))) - sum(p0 * log2(p0)))
def eigensolve(H, hermitian=False):
"""
Given a hamiltonian matrix, calculates energies and
eigenvectors (≈ wavefunctions) and sorts them by
the real part of the energy in ascending order.
"""
if hermitian:
energies, eigenvectors = linalg.eigh(H)
else:
energies, eigenvectors = linalg.eig(H)
indexes = energies.argsort()
energies = sp.real_if_close(energies[indexes])
eigenvectors = eigenvectors[:, indexes]
return energies, eigenvectors
def eigensolve(H, hermitian=False):
"""
Given a hamiltonian matrix, calculates energies and
eigenvectors (≈ wavefunctions) and sorts them by
the real part of the energy in ascending order.
"""
if hermitian:
energies, eigenvectors = linalg.eigh(H)
else:
energies, eigenvectors = linalg.eig(H)
indexes = energies.argsort()
energies = sp.real_if_close(energies[indexes])
eigenvectors = eigenvectors[:, indexes]
return energies, eigenvectors
def MarkovSteadyState(transitionMatrix, tol=1.e-10):
"""
transitionMatrix : NxN matrix, where N = 2^i for
some integer i. Rows should
sum to 1.
"""
# find the steady-state probabilities p0 by finding the
# eigenvector with eigenvalue 1.
M = scipy.transpose(transitionMatrix)
valsM, vecsM = scipy.linalg.eig(M)
valsM = scipy.real_if_close(valsM)
indices = pylab.find(abs(valsM - 1.) < tol)
if len(indices) != 1:
raise Exception("MarkovPCA: No unique steady-state solution. " + \
"Check form of transition matrix.")
p0 = vecsM[:, indices[0]].T
p0 = p0 / sum(p0)
return p0
def _evaluate(self, params, T=1):
"""
Evaluate the cost for the model, returning the intermediate residuals,
and chi-squared.
(Summing up the residuals is a negligible amount of work. This
arrangment makes notification of observers much simpler.)
"""
self.params.update(params)
self.check_parameter_bounds(params)
self.CalculateForAllDataPoints(params)
self.ComputeInternalVariables(T)
resvals = [
res.GetValue(self.calcVals, self.internalVars, self.params)
for res in self.residuals.values()
]
# Occasionally it's useful to use residuals with a sqrt(-1) in them,
# to get negative squares. Then, however, we might get small imaginary
# parts in our results, which this shaves off.
chisq = scipy.real_if_close(scipy.sum(scipy.asarray(resvals)**2),
tol=self.imag_cutoff)
if scipy.isnan(chisq):
logger.warn('Chi^2 is NaN, converting to Infinity.')
chisq = scipy.inf
cost = 0.5 * chisq
entropy = 0
for expt, sf_ents in self.internalVars['scaleFactor_entropies'].items(
):
for group, ent in sf_ents.items():
entropy += ent
self._notify(event='evaluation',
resvals=resvals,
chisq=chisq,
cost=cost,
free_energy=cost - T * entropy,
entropy=entropy,
params=self.params)
return resvals, chisq, cost, entropy
def sqrtm(M):
""" Returns the symmetric semi-definite positive square root of a matrix.
"""
r = real_if_close(expm2(0.5 * logm(M)), 1e-8)
return (r + r.T) / 2
def sqrtm(M):
""" Returns the symmetric semi-definite positive square root of a matrix. """
r = real_if_close(expm(0.5 * logm(M)), 1e-8)
return (r + r.T) / 2
def MarkovEntropy(transitionMatrix):
p0 = MarkovSteadyState(transitionMatrix)
sum, log2 = scipy.sum, lambda x: scipy.nan_to_num(scipy.log2(x))
return -scipy.real_if_close(sum(p0 * log2(p0)))
def SmeanField(cluster,
coocMat,
meanFieldPriorLmbda=0.,
numSamples=None,
indTerm=True,
alternateEnt=False,
useRegularizedEq=True):
"""
meanFieldPriorLmbda (0.): 3.23.2014
indTerm (True) : As of 2.19.2014, I'm not
sure whether this term should
be included, but I think so
alternateEnt (False) : Explicitly calculate entropy
using the full partition function
useRegularizedEq (True) : Use regularized form of equation
even when meanFieldPriorLmbda = 0.
"""
coocMatCluster = coocCluster(coocMat, cluster)
# in case we're given an upper-triangular coocMat:
coocMatCluster = symmetrizeUsingUpper(coocMatCluster)
outer = scipy.outer
N = len(cluster)
freqs = scipy.diag(coocMatCluster)
c = coocMatCluster - outer(freqs, freqs)
Mdenom = scipy.sqrt(outer(freqs * (1. - freqs), freqs * (1 - freqs)))
M = c / Mdenom
if indTerm:
Sinds = -freqs*scipy.log(freqs) \
-(1.-freqs)*scipy.log(1.-freqs)
Sind = scipy.sum(Sinds)
else:
Sind = 0.
# calculate off-diagonal (J) parameters
if (meanFieldPriorLmbda != 0.) or useRegularizedEq:
# 3.22.2014
if meanFieldPriorLmbda != 0.:
gamma = meanFieldPriorLmbda / numSamples
else:
gamma = 0.
mq, vq = scipy.linalg.eig(M)
mqhat = 0.5*( mq-gamma + \
scipy.sqrt((mq-gamma)**2 + 4.*gamma) )
jq = 1. / mqhat #1. - 1./mqhat
Jprime = scipy.real_if_close( \
dot( vq , dot(scipy.diag(jq),vq.T) ) )
JMF = zeroDiag(Jprime / Mdenom)
ent = scipy.real_if_close( \
Sind + 0.5*scipy.sum( scipy.log(mqhat) \
+ 1. - mqhat ) )
else:
# use non-regularized equations
Minv = scipy.linalg.inv(M)
JMF = zeroDiag(Minv / Mdenom)
logMvals = scipy.log(scipy.linalg.svdvals(M))
ent = Sind + 0.5 * scipy.sum(logMvals)
# calculate diagonal (h) parameters
piFactor = scipy.repeat([(freqs - 0.5) / (freqs * (1. - freqs))],
N,
axis=0).T
pjFactor = scipy.repeat([freqs], N, axis=0)
factor2 = c * piFactor - pjFactor
hMF = scipy.diag(scipy.dot(JMF, factor2.T)).copy()
if indTerm:
hMF -= scipy.log(freqs / (1. - freqs))
J = replaceDiag(0.5 * JMF, hMF)
if alternateEnt:
ent = analyticEntropy(J)
# make 'full' version of J (of size NfullxNfull)
Nfull = len(coocMat)
Jfull = JfullFromCluster(J, cluster, Nfull)
return ent, Jfull
sum += (w[i] * integrand( ((end-start)/2.0)*xx[i] + (start+end)/2.0, x, y, step));
float integral=(end-start)*sum/2.0;
float diagonal=((x+0.0)*(x+0.0)*step*step)/(2*mass)*(fabs(x-y)<0.001);
return diagonal+2*((y+0.0)*(y+0.0)*step*step)*step*integral/PI;
}
""")
# Chose which kernel to execute.
#krnl_identity_matrix(gpu_matrix_x,gpu_matrix_y,gpu_matrix_res)
krnl_gaussian_matrix(gpu_matrix_x,gpu_matrix_y,start_val,end_val,(end_val-start_val)/side_length,gpu_matrix_res)
t2=time.time()
print "Time generating matrix:", (t2-t1)
# Reshape to matrix.
shape=(side_length,side_length)
# Calculate eigenvalues of the matrix.
#print gpu_matrix_res.get()
[eigs,_]=la.eig(gpu_matrix_res.get().reshape(shape))
indexes = eigs.argsort()
eigs = sp.real_if_close(eigs[indexes])
t3=time.time()
print "Time calculating eigenvalues:", (t3-t2)
print "Total time:", (t3-t1)
print "Energy eigenvalue:", eigs[0] # Print eigenvalues.
#gpu_matrix_res.get()
# Timing, again.
# t2=time.time()
# print "Time: ", (t2-t1)
def dyn_var_fixed_point(net, dv0=None, with_logs=True, xtol=1e-6, time=0,
stability=False, fsolve_factor=100,
maxfev=10000):
"""
Return the dynamic variables values at the closest fixed point of the net.
dv0 Initial guess for the fixed point. If not given, the current state
of the net is used.
with_logs If True, the calculation is done in terms of logs of variables,
so that they cannot be negative.
xtol Tolerance to aim for.
time Time to plug into equations.
stability If True, return the stability for the fixed point. -1 indicates
stable node, +1 indicates unstable node, 0 indicates saddle
fsolve_factor 'factor' argument for fsolve. For more information, see
help(scipy.optimize.fsolve). Should be in range 0.1 to 100.
maxfev 'maxfev' argument for fsolve. For more information, see
help(scipy.optimize.fsolve). Should be an integer > 1.
"""
net.compile()
if dv0 is None:
dv0 = scipy.array(net.getDynamicVarValues())
else:
dv0 = scipy.asarray(dv0)
consts = net.constantVarValues
zeros = scipy.zeros(len(dv0), scipy.float_)
if with_logs:
# We take the absolute value of dv0 to avoid problems from small
# numerical noise negative values.
if scipy.any(dv0 <= 0):
logger.warning('Non-positive values in initial guess for fixed '
'point and with_logs = True. Rounding them up to '
'double_tiny. The most negative value was %g.'
% min(dv0))
dv0 = scipy.maximum(dv0, _double_tiny_)
# XXX: Would like to replace these with C'd versions, if it's holding
# any of our users up.
def func(logy):
return net.res_function_logdv(time, logy, zeros, consts)
def fprime(logy):
y = scipy.exp(logy)
y = scipy.maximum(y, _double_tiny_)
return net.dres_dc_function(time, y, zeros, consts)
x0 = scipy.log(dv0)
# To transform sigma_x to sigma_log_x, we divide by x. We can set
# our sigma_log_x use to be the mean of what our xtol would yield
# for each chemical.
xtol = scipy.mean(xtol/dv0)
else:
def func(y):
return net.res_function(time, y, zeros, consts)
def fprime(y):
return net.dres_dc_function(time, y, zeros, consts)
x0 = dv0
try:
dvFixed, infodict, ier, mesg =\
scipy.optimize.fsolve(func, x0=x0.copy(), full_output=True,
fprime=fprime,
xtol=xtol, maxfev=maxfev,
factor=fsolve_factor)
except (scipy.optimize.minpack.error, ArithmeticError) as X:
raise FixedPointException(('Failure in fsolve.', X))
tiny = _double_epsilon_
if with_logs:
dvFixed = scipy.exp(dvFixed)
if ier != 1:
if scipy.all(abs(dvFixed) < tiny) and not scipy.all(abs(x0) < 1e6*tiny):
# This is the case where the answer is zero, and our initial guess
# was reasonably large. In this case, the solver fails because
# it's looking at a relative tolerance, but it's not really a
# failure.
pass
else:
raise FixedPointException(mesg, infodict)
if not stability:
return dvFixed
else:
jac = net.dres_dc_function(time, dvFixed, zeros, consts)
u = scipy.linalg.eigvals(jac)
u = scipy.real_if_close(u)
if scipy.all(u < 0):
stable = -1
elif scipy.all(u > 0):
stable = 1
else:
stable = 0
return (dvFixed, stable)
import Common
for model_ii, (model, temp, temp) in enumerate(Common.model_list):
# Load the hessian
h = scipy.io.read_array(os.path.join(model, 'hessian.dat'))
# Load the list of keys
f = file(os.path.join(model, 'hessian_keys.dat'), 'r')
keys = f.readlines()
f.close()
# Strip off extraneous characters
keys = [k.strip() for k in keys]
e, v = Utility.eig(h)
v = scipy.real_if_close(v)
Plotting.figure(figsize=(6, 4.5))
N = 4
# Plot the eigenvectors
for ii in range(N):
Plotting.subplot(N, 1, ii + 1)
Plotting.plot_eigvect(v[:, ii], labels=keys)
for p in Plotting.gca().patches:
p.set_fc([0.5] * 3)
Plotting.gca().set_ylim(-1, 1)
Plotting.gca().set_yticks([-1, 0, 1])
if ii == 0:
Plotting.title('(%s) %s' %
(string.ascii_lowercase[model_ii], model),
fontsize='x-large')
if ier != 1:
if scipy.all(abs(dvFixed) < tiny) and not scipy.all(abs(x0) < 1e6*tiny):
# This is the case where the answer is zero, and our initial guess
# was reasonably large. In this case, the solver fails because
# it's looking at a relative tolerance, but it's not really a
# failure.
pass
else:
raise FixedPointException(mesg, infodict)
if not stability:
return dvFixed
else:
jac = net.dres_dc_function(time, dvFixed, zeros, consts)
u = scipy.linalg.eigvals(jac)
u = scipy.real_if_close(u)
if scipy.all(u < 0):
stable = -1
elif scipy.all(u > 0):
stable = 1
else:
stable = 0
return (dvFixed, stable)
def find_ypic_sens(y, yp, time, var_types, rtol, atol_for_sens, constants,
net, opt_var, redirect_msgs=False):
# On some systems, the f2py'd functions don't like len(constants)=0.
if len(constants) == 0:
constants = [0]
var_types = scipy.asarray(var_types)
y = scipy.asarray(y, scipy.float_)
def _evaluate(self, params, periodic_distance=False,
oscillate_distance=False, T=1):
"""
Evaluate the cost for the model, returning the intermediate residuals,
and chi-squared.
(Summing up the residuals is a negligible amount of work. This
arrangment makes notification of observers much simpler.)
"""
self.params.update(params)
self.check_parameter_bounds(params)
if (periodic_distance == True or
oscillate_distance == True):
def get_nested_dict(dic, nest_level):
for level in range(nest_level):
dic = dic.values()[0]
return dic
def get_expt_trajectory(expt_dict):
return [item[1][0] for item in sorted(expt_dict.iteritems())]
def get_expt_times(expt_dict):
return [item[0] for item in sorted(expt_dict.iteritems())]
# Get calculations corresponding to experiment times
def get_corresponding_calcs(traj_dict, expt_time):
return [traj_dict[time] for time in expt_time]
exptData = self.exptColl.GetData()
expts = get_nested_dict(exptData, 2).values()
expt_times = map(get_expt_times, expts)
expt_trajectories = map(get_expt_trajectory, expts)
calcData = self.CalculateForAllDataPoints(params)
calcs = get_nested_dict(calcData, 1).values()
# Get calculations corresponding to experimental sampling times
calc_trajectories = map(get_corresponding_calcs, calcs, expt_times)
def p_dist(a,b): return(oc.periodic_distance(a, b))
def o_dist(a,b): return(oc.oscillate_distance(a, b))
#WARNING exp must come first, it does not change
if periodic_distance:
cost = sum(map(p_dist, expt_trajectories, calc_trajectories))
else:
cost = sum(map(o_dist, expt_trajectories, calc_trajectories))
if scipy.isnan(cost):
logger.warn('cost is NaN, converting to Infinity.')
print 'cost is inf'
return(scipy.inf)
else:
return(cost)
self.CalculateForAllDataPoints(params)
self.ComputeInternalVariables(T)
resvals = [res.GetValue(self.calcVals, self.internalVars, self.params, no_sf=True)
for res in self.residuals.values()]
# Occasionally it's useful to use residuals with a sqrt(-1) in them,
# to get negative squares. Then, however, we might get small imaginary
# parts in our results, which this shaves off.
chisq = scipy.real_if_close(scipy.sum(scipy.asarray(resvals)**2),
tol=self.imag_cutoff)
if scipy.isnan(chisq):
logger.warn('Chi^2 is NaN, converting to Infinity.')
chisq = scipy.inf
cost = 0.5 * chisq
entropy = 0
for expt, sf_ents in self.internalVars['scaleFactor_entropies'].items():
for group, ent in sf_ents.items():
entropy += ent
self._notify(event = 'evaluation',
resvals = resvals,
chisq = chisq,
cost = cost,
free_energy = cost-T*entropy,
entropy = entropy,
params = self.params)
return resvals, chisq, cost, entropy
