def sample(self, model, evidence):
z = evidence['z']
T = evidence['T']
g = evidence['g']
h = evidence['h']
transition_var_g = evidence['transition_var_g']
shot_id = evidence['shot_id']
observation_var_g = model.known_params['observation_var_g']
observation_var_h = model.known_params['observation_var_h']
prior_mu_g = model.hyper_params['g']['mu']
prior_cov_g = model.hyper_params['g']['cov']
N = len(z)
n = len(g)
# Make g, h, and z vector valued to avoid ambiguity
g = g.copy().reshape((n, 1))
h = h.copy().reshape((n, 1))
z_g = ma.asarray(nan + zeros((n, 1)))
obs_cov = ma.asarray(inf + zeros((n, 1, 1)))
for i in xrange(n):
z_i = z[shot_id == i]
T_i = T[shot_id == i]
if 1 in T_i and 2 in T_i:
# Sample mean and variance for multiple observations
n_obs_g, n_obs_h = sum(T_i == 1), sum(T_i == 2)
obs_cov_g, obs_cov_h = observation_var_g / n_obs_g, observation_var_h / n_obs_h
z_g[i] = (mean(z_i[T_i == 1]) / obs_cov_g +
mean(z_i[T_i == 2] - h[i]) / obs_cov_h) / (
1 / obs_cov_g + 1 / obs_cov_h)
obs_cov[i] = 1 / (1 / obs_cov_g + 1 / obs_cov_h)
elif 1 in T_i:
n_obs_g = sum(T_i == 1)
z_g[i] = mean(z_i[T_i == 1])
obs_cov[i] = observation_var_g / n_obs_g
elif 2 in T_i:
n_obs_h = sum(T_i == 2)
z_g[i] = mean(z_i[T_i == 2] - h[i])
obs_cov[i] = observation_var_h / n_obs_h
z_g[isnan(z_g)] = ma.masked
obs_cov[isinf(obs_cov)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([
prior_mu_g[0],
])
kalman.initial_state_covariance = array([
prior_cov_g[0],
])
kalman.transition_matrices = eye(1)
kalman.transition_covariance = array([
transition_var_g,
])
kalman.observation_matrices = eye(1)
kalman.observation_covariance = obs_cov
sampled_g = forward_filter_backward_sample(kalman, z_g, prior_mu_g,
prior_cov_g)
return sampled_g.reshape((n, ))
def sample(self, model, evidence):
z = evidence['z']
T, g, h, sigma_g = [evidence[var] for var in ['T', 'g', 'h', 'sigma_g']]
sigma_z_g = model.known_params['sigma_z_g']
sigma_z_h = model.known_params['sigma_z_h']
prior_mu_g, prior_cov_g = [model.hyper_params[var] for var in ['prior_mu_g', 'prior_cov_g']]
n = len(g)
# Must be a more concise way to deal with scalar vs vector
g = g.copy().reshape((n,1))
h = h.copy().reshape((n,1))
z_g = ma.asarray(z.copy().reshape((n,1)))
obs_cov = sigma_z_g**2*ones((n,1,1))
if sum(T == 0) > 0:
z_g[T == 0] = nan
if sum(T == 2) > 0:
z_g[T == 2] -= h[T == 2]
obs_cov[T == 2] = sigma_z_h**2
z_g[isnan(z_g)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([prior_mu_g[0],])
kalman.initial_state_covariance = array([prior_cov_g[0,0],])
kalman.transition_matrices = eye(1)
kalman.transition_covariance = array([sigma_g**2,])
kalman.observation_matrices = eye(1)
kalman.observation_covariance = obs_cov
sampled_g = forward_filter_backward_sample(kalman, z_g)
return sampled_g.reshape((n,))
def define_model(data):
# Builds model object
n = len(data)
z = data.get('z')
variable_names = ['surfaces', 'T', 'p_type', 'sigma_g', 'sigma_h']
known_params = {
'sigma_z_g': sigma_z_g,
'sigma_z_h': sigma_z_h,
'mu_h': mu_h,
'phi': phi
}
hyper_params = {
'alpha_type': array((1., 1., 1.)),
'prior_mu_g': -25. + zeros(n),
'prior_cov_g': 100. * eye(n),
'prior_mu_h': 30. + zeros(n),
'prior_cov_h': 100. * eye(n),
'a_g': 11,
'b_g': .1,
'a_h': 11,
'b_h': 40
}
initials = {
'surfaces': [-25, 30] * ones((n, 2)),
'sigma_g': .1,
'sigma_h': 1,
'T': array([(0 if abs(z[i] + 25) > 1 else 1) for i in xrange(n)])
}
#initials = {'sigma_g': sigma_g,
# 'sigma_h': sigma_h,
# 'T': T[:n],
# 'g': g[:n],
# 'h': h[:n]}
priors = {
'p_type': dirichlet(hyper_params['alpha_type']),
'sigma_g': stats.invgamma(hyper_params['a_g'],
scale=hyper_params['b_g']),
'sigma_h': stats.invgamma(hyper_params['a_h'],
scale=hyper_params['b_h']),
'T': iid_dist(categorical(hyper_params['alpha_type']), n)
}
FCP_samplers = {
'p_type': p_type_step(),
'surfaces': surfaces_step(),
'sigma_g': sigma_ground_step(),
'sigma_h': sigma_height_step(),
'T': type_step()
}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def setup():
A = pb.matrix([[0.8, -0.4], [1, 0]])
B = pb.matrix([[1, 0], [0, 1]])
C = pb.matrix([[1, 0], [0, 1], [1, 1]])
Q = 2.3 * pb.matrix(pb.eye(2))
R = 0.2 * pb.matrix(pb.eye(3))
x0 = pb.matrix([[1], [1]])
return LDS.LDS(A, B, C, Q, R, x0)
def setup():
A = pb.matrix([[0.8, -0.4], [1, 0]])
B = pb.matrix([[1, 0], [0, 1]])
C = pb.matrix([[1, 0], [0, 1], [1, 1]])
Q = 2.3 * pb.matrix(pb.eye(2))
R = 0.2 * pb.matrix(pb.eye(3))
x0 = pb.matrix([[1], [1]])
return LDS.LDS(A, B, C, Q, R, x0)
def sample(self, model, evidence):
z = evidence['z']
T = evidence['T']
g = evidence['g']
h = evidence['h']
transition_var_g = evidence['transition_var_g']
shot_id = evidence['shot_id']
observation_var_g = model.known_params['observation_var_g']
observation_var_h = model.known_params['observation_var_h']
prior_mu_g = model.hyper_params['g']['mu']
prior_cov_g = model.hyper_params['g']['cov']
N = len(z)
n = len(g)
## Make g, h, and z vector valued to avoid ambiguity
#g = g.copy().reshape((n, 1))
#h = h.copy().reshape((n, 1))
#
pdb.set_trace()
z_g = ma.asarray(nan + zeros(n))
obs_cov = ma.asarray(inf + zeros(n))
if 1 in T:
z_g[T==1] = z[T==1]
obs_cov[T==1] = observation_var_g
if 2 in T:
z_g[T==2] = z[T==2] - h[T==2]
obs_cov[T==2] = observation_var_h
#for i in xrange(n):
# z_i = z[shot_id == i]
# T_i = T[shot_id == i]
# if 1 in T_i and 2 in T_i:
# # Sample mean and variance for multiple observations
# n_obs_g, n_obs_h = sum(T_i == 1), sum(T_i == 2)
# obs_cov_g, obs_cov_h = observation_var_g/n_obs_g, observation_var_h/n_obs_h
# z_g[i] = (mean(z_i[T_i == 1])/obs_cov_g + mean(z_i[T_i == 2] - h[i])/obs_cov_h)/(1/obs_cov_g + 1/obs_cov_h)
# obs_cov[i] = 1/(1/obs_cov_g + 1/obs_cov_h)
# elif 1 in T_i:
# n_obs_g = sum(T_i == 1)
# z_g[i] = mean(z_i[T_i == 1])
# obs_cov[i] = observation_var_g/n_obs_g
# elif 2 in T_i:
# n_obs_h = sum(T_i == 2)
# z_g[i] = mean(z_i[T_i == 2] - h[i])
# obs_cov[i] = observation_var_h/n_obs_h
z_g[isnan(z_g)] = ma.masked
obs_cov[isinf(obs_cov)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([prior_mu_g[0],])
kalman.initial_state_covariance = array([prior_cov_g[0],])
kalman.transition_matrices = eye(1)
kalman.transition_covariance = array([transition_var_g,])
kalman.observation_matrices = eye(1)
kalman.observation_covariance = obs_cov
sampled_g = forward_filter_backward_sample(kalman, z_g, prior_mu_g, prior_cov_g)
return sampled_g.reshape((n,))
def smooth(y,smoothBeta=smoothBeta):
m = len(y)
p = pl.diff(pl.eye(m),3).transpose()
A = pl.eye(m)+smoothBeta*pl.dot(p.transpose(),p)
smoothY = pl.solve(A, y)
return smoothY
def setup_nonstationary():
T = 100
A_ns = [pb.matrix([[0.8, -0.4], [1, 0]]) for t in range(T)]
B = pb.matrix([[1, 0], [0, 1]])
C = pb.matrix([[1, 0], [0, 1], [1, 1]])
Q = 2.3 * pb.matrix(pb.eye(2))
R = 0.2 * pb.matrix(pb.eye(3))
x0 = pb.matrix([[1], [1]])
return T, LDS.LDS(A_ns, B, C, Q, R, x0)
def setup_nonstationary():
T = 100
A_ns = [pb.matrix([[0.8, -0.4], [1, 0]]) for t in range(T)]
B = pb.matrix([[1, 0], [0, 1]])
C = pb.matrix([[1, 0], [0, 1], [1, 1]])
Q = 2.3 * pb.matrix(pb.eye(2))
R = 0.2 * pb.matrix(pb.eye(3))
x0 = pb.matrix([[1], [1]])
return T, LDS.LDS(A_ns, B, C, Q, R, x0)
def define_model(data):
# Builds model object
m = 3
n_points = len(data)
n_shots = len(set(data['shot_id']))
variable_names = ['g', 'h', 'T', 'p_type', 'sigma_g', 'sigma_h']
known_params = {'sigma_z_g': sigma_z_g,
'sigma_z_h': sigma_z_h,
'mu_h': mu_h,
'phi': phi}
hyper_params = {'alpha_type': array((0, 1., 1.)),
'prior_mu_g': -25.+zeros(n_shots),
'prior_cov_g': 100.*eye(n_shots),
'prior_mu_h': 30.+zeros(n_shots),
'prior_cov_h': 100.*eye(n_shots),
'a_g': 6,
'b_g': 1,
'a_h': 6,
'b_h': 1}
initials = {}
#initials = {'sigma_g': sigma_g,
# 'sigma_h': sigma_h,
# 'T': T[:n_shots],
# 'g': g[:n_shots],
# 'h': h[:n_shots]}
priors = {'p_type': dirichlet(hyper_params['alpha_type']),
'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']),
'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g']),
'h': mvnorm(hyper_params['prior_mu_h'], hyper_params['prior_cov_h']),
'T': iid_dist(categorical(hyper_params['alpha_type']/sum(hyper_params['alpha_type'])), n_points)}
FCP_samplers = {'p_type': p_type_step(),
'g': ground_height_step(),
'h': canopy_height_step(),
'sigma_g': sigma_ground_step(),
'sigma_h': sigma_height_step(),
'T': type_step()}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def all_related_equally(n, sigma):
C = pl.eye(n)
for ii in range(n-2):
for jj in range(n-2):
C[ii,jj] += 1.
C *= sigma**2.
return C
def mpow(A, n):
"""
Returns the n-th power of A.
If n is no integer, the next smaller integer will be assumed.
==========
Parameter:
==========
A : *array*
the square matrix from which the n-th power should be returned
n : *integer*
the power
========
Returns:
========
B : *array*
B = A^n
"""
return reduce(dot, [
eye(A.shape[0]),
] * 2 + [
A,
] * int(n))
def __init__(self, n, x_guess, P_guess, Q, R, A, H, B):
"""
x state (n)
z mesurement (m)
u control (l)
A (n*n): x_k = A*x_k-1
B (n*l): dx = B*u
H (m*n): z_k = H*x_k
Q (n*n) process noise covariance m.rand(3,4)
R (m*m) measurement noise covariance
P (n*n) state noise covariance
K Kalman gain
"""
super(KalmanFilter, self).__init__()
# allocate space for arrays
self.x = np.zeros(n) # a posteri estimate of x
self.x_bel = np.zeros(n) # a priori estimate of x
self.P = np.zeros(n) # a posteri error estimate
self.P_bel = np.zeros(n) # a priori error estimate
self.K = np.zeros(n) # gain or blending factor
self.Q = Q
self.R = R
self.A = A
self.H = H
self.B = B
self.I = pylab.eye(1)
self.x[0] = x_guess[0]
self.P[0] = P_guess
def define_model(data):
# Builds model object
n = len(data)
variable_names = ['g', 'sigma_g']
known_params = {'sigma_z_g': sigma_z_g,
'T': ones(n)}
hyper_params = {'prior_mu_g': 0+zeros(n),
'prior_cov_g': 100*eye(n),
'a_g': 0.,
'b_g': 0.}
priors = {'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])}
initials = {'g': g[:n],
'sigma_g': sigma_g}
FCP_samplers = {'g': ground_height_step(),
'sigma_g': sigma_ground_step()}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def testCollisionsE8(n,d=8):
M = pylab.eye(8,8)
S = [0.0]*n
C = [0]*n
#generate distances and buckets
for i in range(n):
p = [random() for j in xrange(d)]
q = [p[j] + (gauss(0,1)/(d**.5)) for j in xrange(d)]
S[i]=distance(p,q,d)
C[i]= int(decodeE8(dot(p,M)) == decodeE8(dot(q,M)))
ranges = pylab.histogram(S,30)[1]
bucketsCol = [0]*len(ranges)
bucketsDis = [0]*len(ranges)
#fill buckets with counts
for i in xrange(n):
k = len(ranges)-1
while S[i] < ranges[k]:k=k-1
if C[i]:bucketsCol[k]=bucketsCol[k]+1
else:bucketsDis[k] = bucketsDis[k]+1
print bucketsDis
print ranges
pylab.plot(ranges,[float(bucketsCol[i])/(float(bucketsDis[i]+.000000000001)) for i in range(len(ranges))],color='purple')
def __init__(self, poscar=None, xyz=None):
"""Initialize the data members of this class"""
# List of the chemical symbols of the atoms
self.atom_symbols = []
# Lattice constant, in Ångströms
self.lattice_constant = 1.
# 3x3 matrix containing the basis vectors of the supercell
# in row major format
self.basis_vectors = m.eye(3)
# Are the ions allowed to move?
self.selective_dynamics = False
# Flags for each atom describing in which cartesian coordinate
# direction the atom is allowed to move. It is thus a natomsx3
# size list
self.selective_flags = []
# Are the atomic coordinates cartesian or in direct coordinates
# If direct, cartesian coordinates can be calculated by
# multiplying each coordinate with the basis vector matrix
# times the lattice constant
self.cartesian = True
# Coordinates of the atoms
self.atoms = m.zeros((0, 3))
if (poscar != None):
self.read_poscar(poscar)
elif (xyz != None):
self.read_xyz(xyz)
def sample(self, model, evidence):
z, T, g, h, sigma_h, phi = [evidence[var] for var in ['z', 'T', 'g', 'h', 'sigma_h', 'phi']]
sigma_z_h = model.known_params['sigma_z_h']
mu_h = model.known_params['mu_h']
prior_mu_h = model.hyper_params['prior_mu_h']
prior_cov_h = model.hyper_params['prior_cov_h']
n = len(h)
g = g.copy().reshape((n,1))
h = h.copy().reshape((n,1))
z_h = ma.asarray(z.copy().reshape((n,1)))
if sum(T == 0) > 0:
z_h[T == 0] = nan
if sum(T == 1) > 0:
z_h[T == 1] = nan
if sum(T == 2) > 0:
z_h[T == 2] -= g[T == 2]
z_h[isnan(z_h)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([prior_mu_h[0],])
kalman.initial_state_covariance = array([prior_cov_h[0,0],])
kalman.transition_matrices = array([phi,])
kalman.transition_covariance = array([sigma_h**2,])
kalman.transition_offsets = mu_h*(1-phi)*ones((n, 1))
kalman.observation_matrices = eye(1)
kalman.observation_covariance = array([sigma_z_h**2,])
sampled_h = forward_filter_backward_sample(kalman, z_h)
return sampled_h.reshape((n,))
def _filter(self,Y): ## initialise xf=self.x0 Pf=self.P0 # filter quantities xfStore =[] PfStore=[] #calculate the weights Wm_i,Wc_i=self.sigma_vectors_weights() for y in Y: #calculate the sigma points matrix, each column is a sigma vector Xi_f_=self.sigma_vectors(xf,Pf) #propogate sigma verctors through non-linearity Xi_f=self.state_equation(Xi_f_) #pointwise multiply by weights and sum along y-axis xf_=pb.sum(Wm_i*Xi_f,1) xf_=xf_.reshape(self.nx,1) #purturbation Xi_purturbation=Xi_f-xf_ weighted_Xi_purturbation=Wc_i*Xi_purturbation Pf_=pb.dot(Xi_purturbation,weighted_Xi_purturbation.T)+self.Sigma_e #measurement update equation Pyy=dots(self.C,Pf_,self.C.T)+self.Sigma_varepsilon Pxy=pb.dot(Pf_,self.C.T) K=pb.dot(Pxy,pb.inv(Pyy)) yf_=pb.dot(self.C,xf_) xf=xf_+pb.dot(K,(y-yf_)) Pf=pb.dot((pb.eye(self.nx)-pb.dot(K,self.C)),Pf_) xfStore.append(xf) PfStore.append(Pf) return xfStore,PfStore
def mcmc_fit(stoch_names):
print '\nfitting', ' '.join(stoch_names)
mcmc = mc.MCMC([dm.vars[key] for key in stoch_names] + [dm.vars['observed_counts'], dm.vars['rate_potential'], dm.vars['priors']])
mcmc.use_step_method(mc.Metropolis, dm.vars['log_dispersion'],
proposal_sd=dm.vars['dispersion_step_sd'])
# TODO: make a wrapper function for handling this adaptive metropolis setup
stoch_list = [dm.vars['study_coeffs'], dm.vars['region_coeffs'], dm.vars['age_coeffs_mesh']]
d1 = len(dm.vars['study_coeffs'].value)
d2 = len(dm.vars['region_coeffs_step_cov'])
d3 = len(dm.vars['age_coeffs_mesh_step_cov'])
C = pl.eye(d1+d2+d3)
C[d1:(d1+d2), d1:(d1+d2)] = dm.vars['region_coeffs_step_cov']
C[(d1+d2):(d1+d2+d3), (d1+d2):(d1+d2+d3)] = dm.vars['age_coeffs_mesh_step_cov']
C *= .01
mcmc.use_step_method(mc.AdaptiveMetropolis, stoch_list, cov=C)
# more step methods
mcmc.use_step_method(mc.AdaptiveMetropolis, dm.vars['study_coeffs'])
mcmc.use_step_method(mc.AdaptiveMetropolis, dm.vars['region_coeffs'], cov=dm.vars['region_coeffs_step_cov'])
mcmc.use_step_method(mc.AdaptiveMetropolis, dm.vars['age_coeffs_mesh'], cov=dm.vars['age_coeffs_mesh_step_cov'])
try:
mcmc.sample(iter=10000, burn=5000, thin=5, verbose=verbose)
except KeyboardInterrupt:
debug('User halted optimization routine before optimal value found')
sys.stdout.flush()
# reset stoch values to sample mean
for key in stoch_names:
mean = dm.vars[key].stats()['mean']
if isinstance(dm.vars[key], mc.Stochastic):
dm.vars[key].value = mean
print key, mean.round(2)
def animation_to_SO3(skeleton, animation):
# Get rotation matrices for all joints and all frames
bone_names = ['root'] + list(skeleton.bones.keys())
frames = []
for frame in animation.get_frames():
frames.append(convert_to_SO3(skeleton, frame, True))
# Convert into numpy arrays
channels = pl.zeros((len(bone_names), len(frames), 3, 3))
i = 0
for key in animation.channel_order:
if not key in bone_names:
continue
i += 1
for j, frame in enumerate(frames):
channels[i, j, :, :] = frame[key][:3, :3]
for i in range(channels.shape[0]):
for j in range(channels.shape[1]):
if pl.array_equal(channels[i, j, :, :], pl.zeros((3, 3))):
channels[i, j, :, :] = pl.eye(3)
return channels
def testCollisionsE8(n, d=8):
M = pylab.eye(8, 8)
S = [0.0] * n
C = [0] * n
#generate distances and buckets
for i in range(n):
p = [random() for j in xrange(d)]
q = [p[j] + (gauss(0, 1) / (d**.5)) for j in xrange(d)]
S[i] = distance(p, q, d)
C[i] = int(decodeE8(dot(p, M)) == decodeE8(dot(q, M)))
ranges = pylab.histogram(S, 30)[1]
bucketsCol = [0] * len(ranges)
bucketsDis = [0] * len(ranges)
#fill buckets with counts
for i in xrange(n):
k = len(ranges) - 1
while S[i] < ranges[k]:
k = k - 1
if C[i]: bucketsCol[k] = bucketsCol[k] + 1
else: bucketsDis[k] = bucketsDis[k] + 1
print bucketsDis
print ranges
pylab.plot(ranges, [
float(bucketsCol[i]) / (float(bucketsDis[i] + .000000000001))
for i in range(len(ranges))
],
color='purple')
def define_model(data):
# Builds model object
n = len(data)
variable_names = ['g', 'sigma_g']
known_params = {'sigma_z_g': sigma_z_g, 'T': ones(n)}
hyper_params = {
'prior_mu_g': 0 + zeros(n),
'prior_cov_g': 100 * eye(n),
'a_g': 0.,
'b_g': 0.
}
priors = {
'sigma_g': stats.invgamma(hyper_params['a_g'],
scale=hyper_params['b_g']),
'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])
}
initials = {'g': g[:n], 'sigma_g': sigma_g}
FCP_samplers = {'g': ground_height_step(), 'sigma_g': sigma_ground_step()}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def _muaConstraints( self ):
'''
This function ...
Aguments
--------
Keyword arguments
-----------------
'''
npop = self.npop
ub = self.ub
# Create linear constraints
A = pl.eye(3*npop)
b = pl.zeros(3*npop)
for i in xrange(npop-1):
# setting extra constraints on z0
A[i, i+1] = -1
# setting constraints on pop width
A[i + npop, i] = 1
A[i + npop, i + 1] = -1
A[i + npop, i + npop + 1] = 1
# no additional constraints on slope
# Treat the last pop width separately
A[2*npop-1, npop - 2] = 1
A[2*npop-1, npop - 1] = -1
# b is set for the rows where no constraints are present
b[npop-1] = ub[npop-1]
# Try this with and without the maxslopewidth
b[2*npop:] = ub[2*npop:]
return A, b
def define_model(data):
# Builds model object
n = len(data)
variable_names = ['g', 'sigma_g', 'p_type', 'T']
known_params = {'sigma_z_g': sigma_z_g}
hyper_params = {'prior_mu_g': 0*ones(n),
'prior_cov_g': 100*eye(n),
'alpha_type': (1., 1.),
'a_g': 3.,
'b_g': 1.}
priors = {'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
'p_type': dirichlet(hyper_params['alpha_type']),
'T': iid_dist(categorical((1., 1.)), n),
'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])}
#initials = {'g': g[:n],
# 'sigma_g': sigma_g}
FCP_samplers = {'g': ground_height_step(),
'p_type': p_type_step(),
'T': type_step(),
'sigma_g': sigma_ground_step()}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
#model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def define_model(data):
# Builds model object
n = len(data)
z = data.get('z')
variable_names = ['surfaces', 'T', 'p_type', 'sigma_g', 'sigma_h']
known_params = {'sigma_z_g': sigma_z_g,
'sigma_z_h': sigma_z_h,
'mu_h': mu_h,
'phi': phi}
hyper_params = {'alpha_type': array((1., 1., 1.)),
'prior_mu_g': -25.+zeros(n),
'prior_cov_g': 100.*eye(n),
'prior_mu_h': 30.+zeros(n),
'prior_cov_h': 100.*eye(n),
'a_g': 11,
'b_g': .1,
'a_h': 11,
'b_h': 40}
initials = {'surfaces': [-25, 30]*ones((n,2)),
'sigma_g': .1,
'sigma_h': 1,
'T': array([(0 if abs(z[i]+25)>1 else 1) for i in xrange(n)])}
#initials = {'sigma_g': sigma_g,
# 'sigma_h': sigma_h,
# 'T': T[:n],
# 'g': g[:n],
# 'h': h[:n]}
priors = {'p_type': dirichlet(hyper_params['alpha_type']),
'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']),
'T': iid_dist(categorical(hyper_params['alpha_type']), n)}
FCP_samplers = {'p_type': p_type_step(),
'surfaces': surfaces_step(),
'sigma_g': sigma_ground_step(),
'sigma_h': sigma_height_step(),
'T': type_step()}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def randcov(n):
"""
Generates a random, but valid, covariance matrix (size nxn)
"""
L = pylab.randn(n, n)
D = pylab.eye(n)
return L.T.dot(D).dot(L)
def project_perp(A):
"""
Creates a projection matrix onto the space perpendicular to the
rowspace of A.
"""
A = pl.matrix(A)
I = pl.matrix(pl.eye(A.shape[1]))
P = project(A)
return I - P
def project_perp(A):
"""
Creates a projection matrix onto the space perpendicular to the
rowspace of A.
"""
A = np.matrix(A)
I = np.matrix(pl.eye(A.shape[1]))
P = project(A)
return I - P
def randcov (n):
"""
Generates a random, but valid, covariance matrix (size nxn)
"""
L = pylab.randn (n, n)
D = pylab.eye (n)
return L.T.dot (D).dot (L)
def sample(self, model, evidence):
z = evidence['z']
g = evidence['g']
h = evidence['h']
T = evidence['T']
phi = evidence['phi']
transition_var_h = evidence['transition_var_h']
shot_id = evidence['shot_id']
observation_var_h = model.known_params['observation_var_h']
mu_h = model.known_params['mu_h']
prior_mu_h = model.hyper_params['h']['mu']
prior_cov_h = model.hyper_params['h']['cov']
n = len(h)
N = len(z)
# Making g, h, and z vector valued to avoid ambiguity
g = g.copy().reshape((n, 1))
h = h.copy().reshape((n, 1))
z_h = ma.asarray(nan + zeros((n, 1)))
obs_cov = ma.asarray(inf + zeros((n, 1, 1)))
for i in xrange(n):
z_i = z[shot_id == i]
T_i = T[shot_id == i]
if 2 in T_i:
# Sample mean and variance for multiple observations
n_obs = sum(T_i == 2)
z_h[i] = mean(z_i[T_i == 2])
obs_cov[i] = observation_var_h / n_obs
z_h[isnan(z_h)] = ma.masked
obs_cov[isinf(obs_cov)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([
prior_mu_h[0],
])
kalman.initial_state_covariance = array([
prior_cov_h[0],
])
kalman.transition_matrices = array([
phi,
])
kalman.transition_covariance = array([
transition_var_h,
])
kalman.transition_offsets = mu_h * (1 - phi) * ones((n, 1))
kalman.observation_matrices = eye(1)
kalman.observation_offsets = g
kalman.observation_covariance = obs_cov
sampled_h = forward_filter_backward_sample(kalman, z_h, prior_mu_h,
prior_cov_h)
return sampled_h.reshape((n, ))
def sample(self, model, evidence):
z = evidence['z']
T, g, h, sigma_g = [
evidence[var] for var in ['T', 'g', 'h', 'sigma_g']
]
sigma_z_g = model.known_params['sigma_z_g']
sigma_z_h = model.known_params['sigma_z_h']
prior_mu_g, prior_cov_g = [
model.hyper_params[var] for var in ['prior_mu_g', 'prior_cov_g']
]
n = len(g)
# Must be a more concise way to deal with scalar vs vector
g = g.copy().reshape((n, 1))
h = h.copy().reshape((n, 1))
z_g = ma.asarray(z.copy().reshape((n, 1)))
obs_cov = sigma_z_g**2 * ones((n, 1, 1))
if sum(T == 0) > 0:
z_g[T == 0] = nan
if sum(T == 2) > 0:
z_g[T == 2] -= h[T == 2]
obs_cov[T == 2] = sigma_z_h**2
z_g[isnan(z_g)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([
prior_mu_g[0],
])
kalman.initial_state_covariance = array([
prior_cov_g[0, 0],
])
kalman.transition_matrices = eye(1)
kalman.transition_covariance = array([
sigma_g**2,
])
kalman.observation_matrices = eye(1)
kalman.observation_covariance = obs_cov
sampled_g = forward_filter_backward_sample(kalman, z_g)
return sampled_g.reshape((n, ))
def scale_to_h(img, target_height, order=1, dtype=dtype('f'), cval=0):
h, w = img.shape
scale = target_height * 1.0 / h
target_width = int(scale * w)
output = interpolation.affine_transform(1.0 * img,
eye(2) / scale,
order=order,
output_shape=(target_height,
target_width),
mode='constant',
cval=cval)
output = array(output, dtype=dtype)
return output
def train_readout(states, targets, reg_fact=0):
# train readout with linear regression
# states... numpy array with states[i,j] the state of neuron j in example i
# targets.. the targets for training/testing. targets[i] is target of example i
# reg_fact..regularization factor. If set to 0, no regularization is performed
# returns:
# w...weight vector
if reg_fact == 0:
w = np.linalg.lstsq(states, targets)[0]
else:
w = np.dot(np.dot(pylab.inv(reg_fact * pylab.eye(np.size(states, 1)) + np.dot(states.T, states)), states.T),
targets)
return w
def convert(node):
if node is 'root':
transf = [pl.deg2rad(x) for x in frame['root']]
return pl.dot(Rz(transf[5]), pl.dot(Ry(transf[4]), Rx(transf[3])))
cbone = skeleton.bones[node]
#Motion matrix
M = pl.eye(4)
try:
for dof, val in zip(cbone.dof, frame[node]):
val = pl.deg2rad(val)
R = pl.eye(4)
if dof == 'rx':
R = Rx(val)
elif dof == 'ry':
R = Ry(val)
elif dof == 'rz':
R = Rz(val)
M = pl.dot(R, M)
except: #We might not have dof data for the current bone
pass
return M
def lfilter_zi(b,a):
#compute the zi state from the filter parameters. see [Gust96].
#Based on:
# [Gust96] Fredrik Gustafsson, Determining the initial states in forward-backward
# filtering, IEEE Transactions on Signal Processing, pp. 988--992, April 1996,
# Volume 44, Issue 4
n=max(len(a),len(b))
zin = ( pylab.eye(n-1) - pylab.hstack( (-a[1:n,pylab.newaxis],
pylab.vstack((pylab.eye(n-2), pylab.zeros(n-2))))))
zid= b[1:n] - a[1:n]*b[0]
zi_matrix=pylab.linalg.inv(zin)*(pylab.matrix(zid).transpose())
zi_return=[]
#convert the result into a regular array (not a matrix)
for i in range(len(zi_matrix)):
zi_return.append(float(zi_matrix[i][0]))
return pylab.array(zi_return)
def adjointVectors(ksi):
''' Return the adjoint vectors of ksi where ksi is composed of m vector of size > 1
'''
from pylab import matrix, eye
A = matrix(dot(ksi, ksi.T))
A = A + 1e-1 * eye(A.shape[0])
try:
#A = matrix( dot(ksi, ksi.T) ).I
A = A.I
except:
A = zeros(dot(ksi, ksi.T).shape)
print(
'Non inversible dot(ksi, ksi.T) building adjoint vectors where ksi are the patterns'
)
return dot(A, ksi)
def lfilter_zi(b, a):
#compute the zi state from the filter parameters. see [Gust96].
#Based on:
# [Gust96] Fredrik Gustafsson, Determining the initial states in forward-backward
# filtering, IEEE Transactions on Signal Processing, pp. 988--992, April 1996,
# Volume 44, Issue 4
n = max(len(a), len(b))
zin = (pylab.eye(n - 1) - pylab.hstack(
(-a[1:n, pylab.newaxis],
pylab.vstack((pylab.eye(n - 2), pylab.zeros(n - 2))))))
zid = b[1:n] - a[1:n] * b[0]
zi_matrix = pylab.linalg.inv(zin) * (pylab.matrix(zid).transpose())
zi_return = []
#convert the result into a regular array (not a matrix)
for i in range(len(zi_matrix)):
zi_return.append(float(zi_matrix[i][0]))
return pylab.array(zi_return)
def compute_readout_weights(states, targets, reg_fact=0):
"""
Train readout with linear regression
:param states: numpy array with states[i, j], the state of neuron j in example i
:param targets: numpy array with targets[i], while target i corresponds to example i
:param reg_fact: regularization factor; 0 results in no regularization
:return: numpy array with weights[j]
"""
if reg_fact == 0:
w = np.linalg.lstsq(states, targets)[0]
else:
w = np.dot(
np.dot(
pylab.inv(reg_fact * pylab.eye(np.size(states, 1)) +
np.dot(states.T, states)), states.T), targets)
return w
def calc_k_matrix(self):
'''Calculate the K-matrix used by to calculate E-matrices'''
el_len = self.coord_electrode.size
# expanding electrode grid
z_js = pl.zeros(el_len+2)
z_js[1:-1] = self.coord_electrode
z_js[-1] = self.coord_electrode[-1] + \
pl.diff(self.coord_electrode).mean()
c_vec = 1./pl.diff(z_js)
# Define transformation matrices
c_jm1 = pl.matrix(pl.zeros((el_len+2, el_len+2)))
c_j0 = pl.matrix(pl.zeros((el_len+2, el_len+2)))
c_jall = pl.matrix(pl.zeros((el_len+2, el_len+2)))
c_mat3 = pl.matrix(pl.zeros((el_len+1, el_len+1)))
for i in xrange(el_len+1):
for j in xrange(el_len+1):
if i == j:
c_jm1[i+1, j+1] = c_vec[i]
c_j0[i, j] = c_jm1[i+1, j+1]
c_mat3[i, j] = c_vec[i]
c_jm1[-1, -1] = 0
c_jall = c_j0
c_jall[0, 0] = 1
c_jall[-1, -1] = 1
c_j0 = 0
tjp1 = pl.matrix(pl.zeros((el_len+2, el_len+2)))
tjm1 = pl.matrix(pl.zeros((el_len+2, el_len+2)))
tj0 = pl.matrix(pl.eye(el_len+2))
tj0[0, 0] = 0
tj0[-1, -1] = 0
for i in xrange(1, el_len+2):
for j in xrange(el_len+2):
if i == j-1:
tjp1[i, j] = 1
elif i == j+1:
tjm1[i, j] = 1
# Defining K-matrix used to calculate e_mat1-3
return (c_jm1*tjm1 + 2*c_jm1*tj0 + 2*c_jall + c_j0*tjp1)**-1 * 3 * \
(c_jm1**2 * tj0 - c_jm1**2 * tjm1 + c_j0**2 * tjp1 - c_j0**2 * tj0)
def sample(self, model, evidence):
z = evidence['z']
g = evidence['g']
h = evidence['h']
T = evidence['T']
phi = evidence['phi']
transition_var_h = evidence['transition_var_h']
shot_id = evidence['shot_id']
observation_var_h = model.known_params['observation_var_h']
mu_h = model.known_params['mu_h']
prior_mu_h = model.hyper_params['h']['mu']
prior_cov_h = model.hyper_params['h']['cov']
n = len(h)
N = len(z)
# Making g, h, and z vector valued to avoid ambiguity
z_h = ma.asarray(nan + zeros(n))
obs_cov = ma.asarray(inf + zeros(n))
if 2 in T:
z_h[T==2] = z[T==2]
obs_cov[T==2] = observation_var_h
pdb.set_trace()
#for i in xrange(n):
# z_i = z[shot_id == i]
# T_i = T[shot_id == i]
# if 2 in T_i:
# # Sample mean and variance for multiple observations
# n_obs = sum(T_i == 2)
# z_h[i] = mean(z_i[T_i == 2])
# obs_cov[i] = observation_var_h/n_obs
z_h[isnan(z_h)] = ma.masked
obs_cov[isinf(obs_cov)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([prior_mu_h[0],])
kalman.initial_state_covariance = array([prior_cov_h[0],])
kalman.transition_matrices = array([phi,])
kalman.transition_covariance = array([transition_var_h,])
kalman.transition_offsets = mu_h*(1-phi)*ones((n, 1))
kalman.observation_matrices = eye(1)
kalman.observation_offsets = g
kalman.observation_covariance = obs_cov
sampled_h = forward_filter_backward_sample(kalman, z_h, prior_mu_h, prior_cov_h)
return sampled_h.reshape((n,))
def regions_nested_in_superregions(n, sigma):
C = pl.eye(n)
for ii in range(n-2):
for jj in range(n-2):
C[ii,jj] += .1
for S in superregions:
for ii in S:
for jj in S:
C[ii,jj] += 10.
C[n-2,n-2] = 11.
C[n-1,n-1] = 11.
#print "making prior for sex effect very uninformative"
#C[n-1,n-1] = 1001.
C *= sigma**2.
return C
def inverse(A):
def LUdecomp(A):
# use Crout's algorithm to perform LU decomposition of A
n = len(A)
L = pylab.zeros(A.shape)
U = pylab.zeros(A.shape)
for i in range(n):
L[i, i] = 1.0
for j in range(n):
for i in range(j + 1):
U[i, j] = A[i, j]
for k in range(i):
U[i, j] -= L[i, k] * U[k, j]
for i in range(j + 1, n):
L[i, j] = A[i, j]
for k in range(j):
L[i, j] -= L[i, k] * U[k, j]
L[i, j] /= U[j, j]
return L, U
def solve(A, b):
# solves the linear system A.x = b for x
n = len(A)
L, U = LUdecomp(A)
x = pylab.zeros(b.shape)
y = pylab.zeros(b.shape)
# forward substitute to solve equation L.y = b for y
for i in range(n):
y[i] = b[i]
for j in range(i):
y[i] -= L[i, j] * y[j]
y[i] /= L[i, i]
# back substitute to solve equation U.x = y for x
for i in reversed(range(n)):
x[i] = y[i]
for j in range(i + 1, n):
x[i] -= U[i, j] * x[j]
x[i] /= U[i, i]
return x
# when b is a matrix, solve(A,b) gives inverse of A
B = pylab.eye(len(A))
return solve(A, B)
def __init__(self, A=None, IMAGES=None, gamma=0.01, lbda=0.3, eta=0.1,
adapt=0.96, iter=150, soft=1, display_every=1, run_gd=0,
run_cg=1, eta_gd=0.01, cg_maxiter=20, cg_epsilon=0.00000001,
cg_gtol=0.0001, L=64, M=64):
if (A == None):
# init basis functions, normalize
self.A = matrix(rand(L,M)-0.5)
self.A *= matrix(eye(M)*1/sqrt(sum(self.A.A**2)))
else:
self.A = A
if (IMAGES == None):
self.IMAGES = pickle.load(open(images_filename))
else:
self.IMAGES = IMAGES
self.update = 0
self.run_gd = run_gd
self.run_cg = run_cg
# gd params
self.eta_gd = eta_gd
# cg params
self.cg_maxiter = cg_maxiter
self.cg_epsilon = cg_epsilon
self.cg_gtol = cg_gtol
self.gamma = gamma
self.display_every = display_every
self.display_bf = 1
self.display_coef = 0
self.display_norm = 1
self.display_recon = 0
# threshold circuit params
self.lbda = float(lbda)
self.eta = eta
self.adapt = adapt
self.iter = iter
self.soft = soft
def sample(self, model, evidence):
z, T, g, h, sigma_h, phi = [
evidence[var] for var in ['z', 'T', 'g', 'h', 'sigma_h', 'phi']
]
sigma_z_h = model.known_params['sigma_z_h']
mu_h = model.known_params['mu_h']
prior_mu_h = model.hyper_params['prior_mu_h']
prior_cov_h = model.hyper_params['prior_cov_h']
n = len(h)
g = g.copy().reshape((n, 1))
h = h.copy().reshape((n, 1))
z_h = ma.asarray(z.copy().reshape((n, 1)))
if sum(T == 0) > 0:
z_h[T == 0] = nan
if sum(T == 1) > 0:
z_h[T == 1] = nan
if sum(T == 2) > 0:
z_h[T == 2] -= g[T == 2]
z_h[isnan(z_h)] = ma.masked
kalman = self._kalman
kalman.initial_state_mean = array([
prior_mu_h[0],
])
kalman.initial_state_covariance = array([
prior_cov_h[0, 0],
])
kalman.transition_matrices = array([
phi,
])
kalman.transition_covariance = array([
sigma_h**2,
])
kalman.transition_offsets = mu_h * (1 - phi) * ones((n, 1))
kalman.observation_matrices = eye(1)
kalman.observation_covariance = array([
sigma_z_h**2,
])
sampled_h = forward_filter_backward_sample(kalman, z_h)
return sampled_h.reshape((n, ))
def mpow(A, n):
"""
Returns the n-th power of A.
If n is no integer, the next smaller integer will be assumed.
==========
Parameter:
==========
A : *array*
the square matrix from which the n-th power should be returned
n : *integer*
the power
========
Returns:
========
B : *array*
B = A^n
"""
return reduce(dot, [eye(A.shape[0]), ] * 2 + [A, ] * int(n))
def ridgeFit(X, Y, phi, params, verbose=False):
#phi = designMatrix(X, params['order'], includeConstantTerm=False)
l = params['lambda']
phi_avg = sum(phi)*1.0 / len(phi)
Z = phi - phi_avg
Y_avg = sum(Y)*1.0 / len(Y)
Yc = Y - Y_avg
if verbose:
print('phi', phi)
print('phi_avg', phi_avg)
print('Z', Z)
print('Yc', Yc)
a = pl.dot(Z.T, Z) + l * pl.eye(len(Z.T))
b = np.linalg.inv(a).dot(Z.T)
W = b.dot(Yc)
W_0 = np.array([Y_avg - W.T.dot(phi_avg)])
if verbose:
print('W_0', W_0)
print('W', W)
return np.hstack((W_0, W.T)).T
def define_model(data):
# Builds model object
n = len(data)
variable_names = ['g', 'sigma_g', 'p_type', 'T']
known_params = {'sigma_z_g': sigma_z_g}
hyper_params = {
'prior_mu_g': 0 * ones(n),
'prior_cov_g': 100 * eye(n),
'alpha_type': (1., 1.),
'a_g': 3.,
'b_g': 1.
}
priors = {
'sigma_g': stats.invgamma(hyper_params['a_g'],
scale=hyper_params['b_g']),
'p_type': dirichlet(hyper_params['alpha_type']),
'T': iid_dist(categorical((1., 1.)), n),
'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])
}
#initials = {'g': g[:n],
# 'sigma_g': sigma_g}
FCP_samplers = {
'g': ground_height_step(),
'p_type': p_type_step(),
'T': type_step(),
'sigma_g': sigma_ground_step()
}
model = Model()
model.set_variable_names(variable_names)
model.set_known_params(known_params)
model.set_hyper_params(hyper_params)
model.set_priors(priors)
#model.set_initials(initials)
model.set_FCP_samplers(FCP_samplers)
model.set_data(data)
return model
def bad_eta_prior_complex_sim(n=[12, 13, 9, 17, 11, 11, 13, 8, 15], n_mis=2):
# generate full data
d = data.complex_hierarchical_data(n)
# make some data missing
y_w_missing = [y_j.copy() for y_j in d['y']]
for k in range(n_mis):
j = random.choice(range(d['J']))
i = random.choice(range(d['n'][j]))
y_w_missing[j][i] = pl.nan
# generate model
m = models.complex_hierarchical_model(y_w_missing, d['X'], d['t'])
# replace eta prior with wrong covariance
m['eta'].parents['C'] = pl.eye(4)
# fit model with Normal Approx
na = mc.NormApprox(m)
na.fit(method='fmin_powell', verbose=True)
na.sample(5000)
return d, m
def compute_readout_weights(states, targets, reg_fact=0):
"""
Train readout with linear regression
:param states: numpy array with states[i, j], the state of neuron j in example i
:param targets: numpy array with targets[i], while target i corresponds to example i
:param reg_fact: regularization factor; 0 results in no regularization
:return: numpy array with weights[j]
"""
if reg_fact == 0:
# lstsq solves the equation Xw = b for the best w
w = np.linalg.lstsq(states, targets)[0]
else:
# pylab.inv -> inverse
# pylab.eye -> identity matrix
# Note that the inverse of kI_n = 1/k I_n for a scalar k.
# This is somewhat related to the least squares equation.
# A^TA x = A^T b
# for vectors x and b
w = np.dot(np.dot(pylab.inv(reg_fact * pylab.eye(np.size(states, 1)) + np.dot(states.T, states)),
states.T),
targets)
return w
def check_actuated_torques(hrp, q, qd, qdd, tau, J, F_ext):
"""Check actuated torques `tau` computed against the external wrench F_ext
using Equation (8) from (Mistry, Buchli and Schall, 2010).
robot -- robot object
q -- full-body configuration
qd -- full-body velocity
qdd -- full-body acceleration
tau -- active joint torques
J -- contact Jacobian
F_ext -- contact wrench
"""
with hrp.rave:
hrp.rave.SetDOFValues(q)
hrp.rave.SetDOFVelocities(qd)
_, tc, tg = hrp.rave.ComputeInverseDynamics(qdd, returncomponents=True)
M = hrp.compute_inertia_matrix(hrp.q)
S = hstack([eye(50), zeros((50, 6))])
SMS_inv = inv(dot(S, dot(inv(M), S.T)))
S_bar = dot(SMS_inv, dot(S, inv(M))).T
v = dot(S_bar.T, (tc + tg - dot(J.T, F_ext)))
tau_check = dot(SMS_inv, qdd[:50]) + v
return norm(tau - tau_check) < 1e-5
def pseudoSpect(A,
npts=200,
s=2.,
gridPointSelect=100,
verbose=True,
lstSqSolve=True):
"""
original code from http://www.cs.ox.ac.uk/projects/pseudospectra/psa.m
% psa.m - Simple code for 2-norm pseudospectra of given matrix A.
% Typically about N/4 times faster than the obvious SVD method.
% Comes with no guarantees! - L. N. Trefethen, March 1999.
parameter: A: the matrix to analyze
npts: number of points at the grid
s: axis limits (-s ... +s)
gridPointSelect: ???
verbose: prints progress messages
lstSqSolve: if true, use least squares in algorithm where
solve could be used (probably) instead. (replacement for
ldivide in MatLab)
"""
from scipy.linalg import schur, triu
from pylab import (meshgrid, norm, dot, zeros, eye, diag, find, linspace,
arange, isreal, inf, ones, lstsq, solve, sqrt, randn,
eig, all)
ldiv = lambda M1, M2: lstsq(M1, M2)[
0] if lstSqSolve else lambda M1, M2: solve(M1, M2)
def planerot(x):
'''
return (G,y)
with a matrix G such that y = G*x with y[1] = 0
'''
G = zeros((2, 2))
xn = x / norm(x)
G[0, 0] = xn[0]
G[1, 0] = -xn[1]
G[0, 1] = xn[1]
G[1, 1] = xn[0]
return G, dot(G, x)
xmin = -s
xmax = s
ymin = -s
ymax = s
x = linspace(xmin, xmax, npts, endpoint=False)
y = linspace(ymin, ymax, npts, endpoint=False)
xx, yy = meshgrid(x, y)
zz = xx + 1j * yy
#% Compute Schur form and plot eigenvalues:
T, Z = schur(A, output='complex')
T = triu(T)
eigA = diag(T)
# Reorder Schur decomposition and compress to interesting subspace:
select = find(eigA.real > -250) # % <- ALTER SUBSPACE SELECTION
n = len(select)
for i in arange(n):
for k in arange(select[i] - 1, i, -1): #:-1:i
G = planerot([T[k, k + 1],
T[k, k] - T[k + 1, k + 1]])[0].T[::-1, ::-1]
J = slice(k, k + 2)
T[:, J] = dot(T[:, J], G)
T[J, :] = dot(G.T, T[J, :])
T = triu(T[:n, :n])
I = eye(n)
# Compute resolvent norms by inverse Lanczos iteration and plot contours:
sigmin = inf * ones((len(y), len(x)))
#A = eye(5)
niter = 0
for i in arange(len(y)): # 1:length(y)
if all(isreal(A)) and (ymax == -ymin) and (i > len(y) / 2):
sigmin[i, :] = sigmin[len(y) - i, :]
else:
for jj in arange(len(x)):
z = zz[i, jj]
T1 = z * I - T
T2 = T1.conj().T
if z.real < gridPointSelect: # <- ALTER GRID POINT SELECTION
sigold = 0
qold = zeros((n, 1))
beta = 0
H = zeros((100, 100))
q = randn(n, 1) + 1j * randn(n, 1)
while norm(q) < 1e-8:
q = randn(n, 1) + 1j * randn(n, 1)
q = q / norm(q)
for k in arange(99):
v = ldiv(T1, (ldiv(T2, q))) - dot(beta, qold)
#stop
alpha = dot(q.conj().T, v).real
v = v - alpha * q
beta = norm(v)
qold = q
q = v / beta
H[k + 1, k] = beta
H[k, k + 1] = beta
H[k, k] = alpha
if (alpha > 1e100):
sig = alpha
else:
sig = max(abs(eig(H[:k + 1, :k + 1])[0]))
if (abs(sigold / sig - 1) < .001) or (sig < 3
and k > 2):
break
sigold = sig
niter += 1
#print 'niter = ', niter
#%text(x(jj),y(i),num2str(k)) % <- SHOW ITERATION COUNTS
sigmin[i, jj] = 1. / sqrt(sig)
#end
# end
if verbose:
print 'finished line ', str(i), ' out of ', str(len(y))
return x, y, sigmin
def pseudoSpect(A, npts=200, s=2., gridPointSelect=100, verbose=True,
lstSqSolve=True):
"""
original code from http://www.cs.ox.ac.uk/projects/pseudospectra/psa.m
% psa.m - Simple code for 2-norm pseudospectra of given matrix A.
% Typically about N/4 times faster than the obvious SVD method.
% Comes with no guarantees! - L. N. Trefethen, March 1999.
parameter: A: the matrix to analyze
npts: number of points at the grid
s: axis limits (-s ... +s)
gridPointSelect: ???
verbose: prints progress messages
lstSqSolve: if true, use least squares in algorithm where
solve could be used (probably) instead. (replacement for
ldivide in MatLab)
"""
from scipy.linalg import schur, triu
from pylab import (meshgrid, norm, dot, zeros, eye, diag, find, linspace,
arange, isreal, inf, ones, lstsq, solve, sqrt, randn,
eig, all)
ldiv = lambda M1,M2 :lstsq(M1,M2)[0] if lstSqSolve else lambda M1,M2: solve(M1,M2)
def planerot(x):
'''
return (G,y)
with a matrix G such that y = G*x with y[1] = 0
'''
G = zeros((2,2))
xn = x / norm(x)
G[0,0] = xn[0]
G[1,0] = -xn[1]
G[0,1] = xn[1]
G[1,1] = xn[0]
return G, dot(G,x)
xmin = -s
xmax = s
ymin = -s
ymax = s;
x = linspace(xmin,xmax,npts,endpoint=False)
y = linspace(ymin,ymax,npts,endpoint=False)
xx,yy = meshgrid(x,y)
zz = xx + 1j*yy
#% Compute Schur form and plot eigenvalues:
T,Z = schur(A,output='complex');
T = triu(T)
eigA = diag(T)
# Reorder Schur decomposition and compress to interesting subspace:
select = find( eigA.real > -250) # % <- ALTER SUBSPACE SELECTION
n = len(select)
for i in arange(n):
for k in arange(select[i]-1,i,-1): #:-1:i
G = planerot([T[k,k+1],T[k,k]-T[k+1,k+1]] )[0].T[::-1,::-1]
J = slice(k,k+2)
T[:,J] = dot(T[:,J],G)
T[J,:] = dot(G.T,T[J,:])
T = triu(T[:n,:n])
I = eye(n);
# Compute resolvent norms by inverse Lanczos iteration and plot contours:
sigmin = inf*ones((len(y),len(x)));
#A = eye(5)
niter = 0
for i in arange(len(y)): # 1:length(y)
if all(isreal(A)) and (ymax == -ymin) and (i > len(y)/2):
sigmin[i,:] = sigmin[len(y) - i,:]
else:
for jj in arange(len(x)):
z = zz[i,jj]
T1 = z * I - T
T2 = T1.conj().T
if z.real < gridPointSelect: # <- ALTER GRID POINT SELECTION
sigold = 0
qold = zeros((n,1))
beta = 0
H = zeros((100,100))
q = randn(n,1) + 1j*randn(n,1)
while norm(q) < 1e-8:
q = randn(n,1) + 1j*randn(n,1)
q = q/norm(q)
for k in arange(99):
v = ldiv(T1,(ldiv(T2,q))) - dot(beta,qold)
#stop
alpha = dot(q.conj().T, v).real
v = v - alpha*q
beta = norm(v)
qold = q
q = v/beta
H[k+1,k] = beta
H[k,k+1] = beta
H[k,k] = alpha
if (alpha > 1e100):
sig = alpha
else:
sig = max(abs(eig(H[:k+1,:k+1])[0]))
if (abs(sigold/sig-1) < .001) or (sig < 3 and k > 2):
break
sigold = sig
niter += 1
#print 'niter = ', niter
#%text(x(jj),y(i),num2str(k)) % <- SHOW ITERATION COUNTS
sigmin[i,jj] = 1./sqrt(sig);
#end
# end
if verbose:
print 'finished line ', str(i), ' out of ', str(len(y))
return x,y,sigmin
def uninformative(n, sigma):
print 'using uninformative regional similarity prior'
C = pl.eye(n) * 11. * sigma**2.
return C
def T(t):
M = pl.eye(4)
M[:3, 3] = t
return M
#Define sensor geometry sensor_center=pb.matrix([[0],[0]]) sensor_width=0.9**2 sensor_kernel=basis(sensor_center,sensor_width,dimension) #Define sigmoidal activation function and inverse synaptic time constant fmax=10 v0=2 varsigma=0.8 act_fun=ActivationFunction(v0,fmax,varsigma) #inverse synaptic time constant zeta=100 #define field initialasation and number of iterations for estimation mean=[0]*len(Phi) P0=10*pb.eye(len(mean)) x0=pb.matrix(pb.multivariate_normal(mean,P0,[1])).T number_of_iterations=10 #ignore first 100 observations allowing the model's initial transients to die out First_n_observations=100 #populate the model NF_model=NF(NF_Connectivity_kernel,sensor_kernel,obs_locns,observation_locs_mm,gamma,gamma_weight,Sigma_varepsilon,act_fun,zeta,Ts,field_space,spacestep) IDE_model=IDE(IDE_Connectivity_kernel,IDE_field,sensor_kernel,obs_locns,gamma,gamma_weight,Sigma_varepsilon,act_fun,x0,P0,zeta,Ts,field_space,spacestep) #generate the Neural Field model NF_model.gen_ssmodel() V,Y=NF_model.simulate(T) #generate the reduced model (state space model) IDE_model.gen_ssmodel() #estimate the states, the connectivity kernel parameters and the synaptic dynamics ps_estimate=para_state_estimation(IDE_model)
