def correct( self ): self.Z = np.mat([ self.sensors['accelerometer'].roll, self.sensors['accelerometer'].pitch, self.sensors['dummy_yaw'].yaw ]).transpose() self.StateMap = np.mat( tf.transformations.euler_from_quaternion( self.quaternion.get_quaternion(), axes = 'sxyz' ) ).transpose(); c11 = 1 - 2 * (self.quaternion.y**2 + self.quaternion.z**2) c33 = 1 - 2 * (self.quaternion.x**2 + self.quaternion.y**2) c21 = 2 * ( self.quaternion.x*self.quaternion.y + self.quaternion.w*self.quaternion.z ) c31 = 2 * ( self.quaternion.x*self.quaternion.z - self.quaternion.w*self.quaternion.y ) c32 = 2 * ( self.quaternion.y*self.quaternion.z + self.quaternion.w*self.quaternion.x ) self.MeasurementJacobian = np.asmatrix( matlib.diag( [2 * c33/sqrt(c33 ** 2 + c32 ** 2), 2 / sqrt(1 - c31**2), 2 * c11/sqrt(c11 ** 2 + c21 ** 2)] ) ) * np.mat([ [ self.quaternion.x , self.quaternion.w, self.quaternion.z, self.quaternion.y], [ self.quaternion.y, -self.quaternion.z, self.quaternion.w, -self.quaternion.x ], [ self.quaternion.z, self.quaternion.y, self.quaternion.x, self.quaternion.w] ]) + np.asmatrix( matlib.diag( [4 * c32/sqrt(c33 ** 2 + c32 ** 2), 0 , 4 * c21/sqrt(c11 ** 2 + c21 ** 2) ]) ) * np.mat([ [ 0, self.quaternion.x, self.quaternion.y, 0], [ 0, 0, 0, 0], [ 0, 0 , self.quaternion.y, self.quaternion.z] ]) super(IMU_Kalman, self).correct() self.set_quaternion()
def refine_R1(self, smoothR1, smoothk2, smoothk2a, h):
'''
Ridge regression to get better R1, k2, k2a estimates
Args:
smoothR1 (float): R1 value to drive the estimate toward
smoothk2 (float): k2 value to drive the estimate toward
smoothk2a (float): k2a value to drive the estimate toward
h (numpy.ndarray): 1-D array consisting of the diagonal elements
of the matrix used to compute the weighted norm
'''
if not smoothR1.ndim==smoothk2.ndim==smoothk2a.ndim==1:
raise ValueError('smoothR1, smoothk2, smoothk2a must be 1-D')
if not len(smoothR1)==len(smoothk2)==len(smoothk2a)==self.TAC.shape[0]:
raise ValueError('Length of smoothR1, smoothk2, smoothk2a must be \
equal to the number of rows of TAC')
if not h.ndim==2:
raise ValueError('h must be 2-D')
if not h.shape==(self.TAC.shape[0], 3):
raise ValueError('Number of rows of h must equal the number of rows of TAC, \
and the number of columns of h must be 3')
# Numerical integration of reference TAC
intrefTAC = km_integrate(self.refTAC,self.t,self.startActivity)
for k, TAC in enumerate(self.TAC):
W = mat.diag(self.weights[k,:])
# Numerical integration of target TAC
intTAC = km_integrate(TAC,self.t,self.startActivity)
# ----- Get R1 incorporating spatial constraint -----
# Set up the ridge regression model
# based on Eq. 11 in Zhou et al.
#X = np.mat(np.column_stack((self.refTAC,intrefTAC,-intTAC)))
X = np.column_stack((self.refTAC,intrefTAC,-intTAC))
#y = np.mat(TAC).T
y = TAC
H = mat.diag(h[k,:])
b_sc = np.array((smoothR1[k],smoothk2[k],smoothk2a[k])) #.reshape(-1,1)
try:
b = solve(X.T @ W @ X + H, X.T @ W @ y + H @ b_sc)
R1_lrsc = b[0]
k2_lrsc = b[1]
k2a_lrsc = b[2]
except:
R1_lrsc = k2_lrsc = k2a_lrsc = 0
self.results['R1_lrsc'][k] = R1_lrsc
self.results['k2_lrsc'][k] = k2_lrsc
self.results['k2a_lrsc'][k] = k2a_lrsc
return self
def EMForMoG(datam, n, pl, muvl, covml, max_iters=1):
assert len(pl)==len(muvl) and len(muvl)==len(covml)
d=datam.shape[0]
N=datam.shape[1]
#start EM posteriorm n*N
posteriorm=matlib.zeros((n, N), dtype=np.float32)
for it in xrange(max_iters):
print 'Iter: '+str(it)
#create Gaussian kernels
NormalFl=[makeNormalF(muv, covm) for muv, covm in zip(muvl, covml)]
#probability
px=matlib.zeros((1, N), dtype=np.float32)
posteriorm.fill(0)
#caculate posteriorm
for j in xrange(N):
cur_data=datam[:, j]
for i in xrange(n):
#print i, j
posteriorm[i, j]=pl[i]*NormalFl[i](cur_data)
px[0, j]+=posteriorm[i, j]
# print 'px:', px
posteriorm/=px
#update parameters
#soft num n*1
softnum=matlib.sum(posteriorm, 1)
print softnum
softnum_inv=1.0/softnum
pl=np.array((softnum/N)).reshape(-1).tolist()
mum=datam*posteriorm.T*matlib.diag(np.array(softnum_inv).reshape(-1))
muvl=[mum[:, k] for k in range(n)]
mum=[]#release
for k in range(n):
datam_temp=datam-muvl[k]
covml[k]=softnum_inv[k, 0]*datam_temp*matlib.diag(np.array(posteriorm[k, :]).reshape(-1))\
*datam_temp.T
return pl, muvl, covml
def design_controller():
# Control input weighting
R = 1.0
# State weighting matrix Q
Q = diag([(10 * pi / 180)**(-2), (10 * pi / 180)**(-2),
(10 * pi / 180)**(-2), (10 * pi / 180)**(-2)]) / R
# Always keep this at 1.0 and adjust the scaling of Q
R = np.array([[1.0]])
# State error covariance
W = diag([0.0, 0.0, 1e-6, 1e-6]) * dt
# Measurement error covariance
V = .01 * diag([
(1.0 / 20000 * 2.0 * pi)**2., # square of 1.0 count
(0.00227631723111)**2
]) # square of std deviation from static
# Calculate closed loop eigenvalues and gains
data = compute_gains(Q, np.array([[1.0]]), W, V, dt)
matlab_data = {
'A_cl_w': data['A_cl'],
'B_cl_w': data['B_cl'],
'C_cl_w': data['C_cl'],
'A_w': data['A'],
'B_c_w': data['B_c'],
'C_m_w': data['C_m'],
'C_z_w': data['C_z'],
'K_c_w': data['K_c'],
'A_e_w': data['A_e'],
'B_e_w': data['B_e']
}
sio.savemat("cl_data.mat", mdict=matlab_data)
matlab = "/home/hazelnusse/usr/matlab2012b/bin/matlab"
import os
os.system(matlab + " -nosplash -nodesktop -nojvm -r 'tune_pi; exit;'")
pi_gains = sio.loadmat('pi_gains.mat')
data['Kp'] = pi_gains['Kp_w'].reshape((N, ))
data['Ki'] = pi_gains['Ki_w'].reshape((N, ))
data['Kp_fit'] = smoother(data['theta_R_dot'], data['Kp'])
data['Ki_fit'] = smoother(data['theta_R_dot'], data['Ki'])
form_PI_cl(data)
return data
def belief_dynamics(b_t, u_t, z_tp1, model,profiler=None,profile=False):
dynamics_func = model.dynamics_func
obs_func = model.obs_func
qDim = model.qDim
rDim = model.rDim
x_t, SqrtSigma_t = decompose_belief(b_t, model)
Sigma_t = SqrtSigma_t*SqrtSigma_t
if z_tp1 is None:
# Maximum likelihood observation assumption
z_tp1 = obs_func(dynamics_func(x_t, u_t, ml.zeros([qDim,1])), ml.zeros([rDim,1]))
if profile: profiler.start('ekf')
x_tp1, Sigma_tp1 = ekf(x_t, Sigma_t, u_t, z_tp1, model)
if profile: profiler.stop('ekf')
# Compute square root for storage
# Several different choices available -- we use the principal square root
if profile: profiler.start('eigh')
D_diag, V = ml.linalg.eigh(Sigma_tp1)
if profile: profiler.stop('eigh')
SqrtSigma_tp1 = V*np.sqrt(ml.diag(D_diag))*V.T
b_tp1 = compose_belief(x_tp1, SqrtSigma_tp1, model)
return b_tp1
def belief_dynamics(b_t, u_t, z_tp1, model, profiler=None, profile=False):
dynamics_func = model.dynamics_func
obs_func = model.obs_func
qDim = model.qDim
rDim = model.rDim
x_t, SqrtSigma_t = decompose_belief(b_t, model)
Sigma_t = SqrtSigma_t * SqrtSigma_t
if z_tp1 is None:
# Maximum likelihood observation assumption
z_tp1 = obs_func(dynamics_func(x_t, u_t, ml.zeros([qDim, 1])),
ml.zeros([rDim, 1]))
if profile: profiler.start('ekf')
x_tp1, Sigma_tp1 = ekf(x_t, Sigma_t, u_t, z_tp1, model)
if profile: profiler.stop('ekf')
# Compute square root for storage
# Several different choices available -- we use the principal square root
if profile: profiler.start('eigh')
D_diag, V = ml.linalg.eigh(Sigma_tp1)
if profile: profiler.stop('eigh')
SqrtSigma_tp1 = V * np.sqrt(ml.diag(D_diag)) * V.T
b_tp1 = compose_belief(x_tp1, SqrtSigma_tp1, model)
return b_tp1
def srtm(vol, int_vol, ref, int_ref, time_frames, opts={}, header=None ):
'''
TODO: Add reference to author of code
'''
try :
isotope=header["Info"]["Tracer"]["Isotope"][0]
print(isotope)
isotope=re.sub('-', '', isotope)
print(isotope)
half_life = half_life_dict[ isotope ]
except KeyError :
half_life = opts.quant_half_life
if half_life == None :
print("Error : 1) isotope was either not found in .json header or not one of ",half_life_dict.keys()," was not specified manually with --half-life option.")
exit(1)
decayConstant = np.log(2) / half_life
time_widths = np.array(header["Time"]["FrameTimes"]["Duration"]).reshape(-1,) / 50.
time_frames = np.array(time_frames).reshape(-1,) / 60.
pet_sum = np.sum(vol,axis=0)
weights = time_widths / (pet_sum * np.exp(decayConstant * time_frames))
startActivity=0
ref = ref.reshape(-1,)
R1=BP=[]
for k in range(vol.shape[0]):
TAC = vol[k,:]
W = mat.diag(weights)
y = np.mat(TAC).T
def energy_fun(theta3):
exp_theta3_t = np.exp(np.asscalar(theta3)*time_frames)
integrant = ref * exp_theta3_t
conv=np.zeros_like(time_frames)
for t in range(time_frames.shape[0])[1:]:
conv[t] = simps(integrant[:t], time_frames[:t]) # km_integrate(integrant,time_frames, startActivity) / exp_theta3_t
X = np.mat(np.column_stack((ref, conv)))
thetas = solve(X.T * W * X, X.T * W * y)
residual = y - X * thetas
rss = residual.T * W * residual
return rss
res = minimize_scalar(energy_fun, bounds=(0.06, 0.6), method='bounded', options=dict(xatol=1e-1))
theta3 = np.asscalar(res.x)
exp_theta3_t = np.exp(theta3*time_frames)
integrant = ref * exp_theta3_t
conv = simps(integrant,time_frames) / exp_theta3_t
X = np.mat(np.column_stack((ref, conv)))
thetas = solve(X.T * W * X, X.T * W * y)
R1 += thetas[0]
k2 = thetas[1] + R1[-1]*theta3
BP += [k2 / theta3 - 1]
if opts["quant_R1"] :
return R1
return BP
def design_controller():
# Control input weighting
R = 1.0
# State weighting matrix Q
Q = diag([(10*pi/180)**(-2), (10*pi/180)**(-2),
(10*pi/180)**(-2), (10*pi/180)**(-2)]) / R
# Always keep this at 1.0 and adjust the scaling of Q
R = np.array([[1.0]])
# State error covariance
W = diag([0.0, 0.0, 1e-6, 1e-6]) * dt
# Measurement error covariance
V = .01*diag([(1.0/20000*2.0*pi)**2., # square of 1.0 count
(0.00227631723111)**2]) # square of std deviation from static
# Calculate closed loop eigenvalues and gains
data = compute_gains(Q, np.array([[1.0]]), W, V, dt)
matlab_data = {'A_cl_w' : data['A_cl'],
'B_cl_w' : data['B_cl'],
'C_cl_w' : data['C_cl'],
'A_w' : data['A'],
'B_c_w' : data['B_c'],
'C_m_w' : data['C_m'],
'C_z_w' : data['C_z'],
'K_c_w' : data['K_c'],
'A_e_w' : data['A_e'],
'B_e_w' : data['B_e']}
sio.savemat("cl_data.mat", mdict=matlab_data)
matlab = "/home/hazelnusse/usr/matlab2012b/bin/matlab"
import os
os.system(matlab + " -nosplash -nodesktop -nojvm -r 'tune_pi; exit;'")
pi_gains = sio.loadmat('pi_gains.mat')
data['Kp'] = pi_gains['Kp_w'].reshape((N,))
data['Ki'] = pi_gains['Ki_w'].reshape((N,))
data['Kp_fit'] = smoother(data['theta_R_dot'], data['Kp'])
data['Ki_fit'] = smoother(data['theta_R_dot'], data['Ki'])
form_PI_cl(data)
return data
def qzdiv(stake, A2, B2, Q, Z):
Aout = A2.copy(); Bout = B2.copy(); Qout = Q.copy(); Zout = Z.copy()
n, jnk = A2.shape
# remember diag returns 1d
root = mat(abs(c_[diag(A2)[:,newaxis], diag(B2)[:,newaxis]]))
root[:,1] /= where(root[:,0]<1e-13, -root[:,1], root[:,0])
for i in range(1,n+1)[::-1]: # always first i rows, decreasing
m = None
for j in range(1,i+1)[::-1]: # search backwards in the first i rows
#print root.shape
#print n, i, j
#print 'i,j in qzdiv', i,j
if root[j-1,1] > stake or root[j-1,1] < -0.1:
m = j # get last relevant row
break
if m == None: return (Aout, Bout, Qout, Zout)
for k in range(m,i): # from relev. row to end of first part
(Aout, Bout, Qout, Zout) = qzswitch(k, Aout, Bout, Qout, Zout)
root[k-1:k+1, 1] = root[k-1:k+1, 1][::-1]
return (Aout, Bout, Qout, Zout)
def qzdiv(stake, A2, B2, Q, Z):
Aout = A2.copy(); Bout = B2.copy(); Qout = Q.copy(); Zout = Z.copy()
n, jnk = A2.shape
# remember diag returns 1d
root = mat(abs(c_[diag(A2)[:,newaxis], diag(B2)[:,newaxis]]))
root[:,1] /= where(root[:,0]<1e-13, -root[:,1], root[:,0])
for i in range(1,n+1)[::-1]: # always first i rows, decreasing
m = None
for j in range(1,i+1)[::-1]: # search backwards in the first i rows
#print root.shape
#print n, i, j
#print 'i,j in qzdiv', i,j
if root[j-1,1] > stake or root[j-1,1] < -0.1:
m = j # get last relevant row
break
if m == None: return (Aout, Bout, Qout, Zout)
for k in range(m,i): # from relev. row to end of first part
(Aout, Bout, Qout, Zout) = qzswitch(k, Aout, Bout, Qout, Zout)
root[k-1:k+1, 1] = root[k-1:k+1, 1][::-1]
return (Aout, Bout, Qout, Zout)
def GetCovm2D(axis1_len, axis2_len, axis1_angle, nsigma=3):
'axis1_angle measured in degrees'
assert axis1_len>0 and axis2_len>0
w=np.array([axis1_len, axis2_len], dtype=np.float32)
w=(w/nsigma)**2
v=matlib.zeros((2, 2), dtype=np.float32)
axis1_rad=math.radians(axis1_angle)
axis2_rad=math.radians(axis1_angle+90)
v[:, 0]=matlib.mat((math.cos(axis1_rad), math.sin(axis1_rad))).T
v[:, 1]=matlib.mat((math.cos(axis2_rad), math.sin(axis2_rad))).T
#print 'v get2D', v
return v*matlib.diag(w)*v.T
def fit(self):
n = len(self.t)
m = 3
# diagonal matrix with diagonal elements corresponding to the duration
# of each time frame
W = mat.diag(self.dt)
# Numerical integration of target TAC
intTAC = km_integrate(self.TAC,self.t,self.startActivity)
# Numerical integration of reference TAC
intrefTAC = km_integrate(self.refTAC,self.t,self.startActivity)
# ----- Get DVR, BP -----
# Set up the weighted linear regression model
# based on Eq. 9 in Zhou et al.
# Per the recommendation in first paragraph on p. 979 of Zhou et al.,
# smoothed TAC is used in the design matrix, if provided.
if self.smoothTAC is None:
X = np.mat(np.column_stack((intrefTAC, self.refTAC, self.TAC)))
else:
X = np.mat(np.column_stack((intrefTAC, self.refTAC, self.smoothTAC)))
y = np.mat(intTAC).T
b = linalg.solve(X.T * W * X, X.T * W * y)
residual = y - X * b
var_b = residual.T * W * residual / (n-m)
DVR = b[0]
BP = DVR - 1
# ----- Get R1 -----
# Set up the weighted linear regression model
# based on Eq. 8 in Zhou et al.
X = np.mat(np.column_stack((self.refTAC,intrefTAC,-intTAC)))
y = np.mat(self.TAC).T
b = linalg.solve(X.T * W * X, X.T * W * y)
residual = y - X * b
var_b = residual.T * W * residual / (n-m)
R1 = b[0]
self.BP = BP
self.R1 = R1
return self
def fit(self):
#print(self.TAC.shape)
for k, TAC in enumerate(self.TAC):
W = mat.diag(self.weights[k,:])
#y = np.mat(TAC).T
y = TAC
def energy_fun(theta3):
exp_theta3_t = np.exp(np.asscalar(theta3)*self.t)
integrant = self.refTAC * exp_theta3_t
conv = km_integrate(integrant,self.t,self.startActivity) / exp_theta3_t
#X = np.mat(np.column_stack((self.refTAC, conv)))
X = np.column_stack((self.refTAC, conv))
#thetas = solve(X.T * W * X, X.T * W * y)
thetas = solve(X.T @ W @ X, X.T @ W @ y)
#residual = y - X * thetas
residual = y - X @ thetas
#rss = residual.T * W * residual
rss = residual.T @ W @ residual
return rss
res = minimize_scalar(energy_fun, bounds=(0.06, 0.6),
method='bounded', options=dict(xatol=1e-1))
theta3 = np.asscalar(res.x)
exp_theta3_t = np.exp(theta3*self.t)
integrant = self.refTAC * exp_theta3_t
conv = km_integrate(integrant,self.t,self.startActivity) / exp_theta3_t
#X = np.mat(np.column_stack((self.refTAC, conv)))
X = np.column_stack((self.refTAC, conv))
#thetas = solve(X.T * W * X, X.T * W * y)
thetas = solve(X.T @ W @ X, X.T @ W @ y)
R1 = thetas[0]
k2 = thetas[1] + R1*theta3
BP = k2 / theta3 - 1
self.results['BP'][k] = BP
self.results['R1'][k] = R1
self.results['k2'][k] = k2
return self
def inf(self, x, meanonly=False):
x = np.asmatrix(x)
assert x.shape[1] == self.d
n = x.shape[0]
# Handle empty test set
if n == 0:
return (np.zeros((0, 1)), np.zeros((0, 1)))
ms = self.kernel.mean*np.ones((n, 1))
Kbb = self.kernel(x, diag=True)
# Handle empty training set
if len(self) == 0:
return (ms, np.asmatrix(np.diag(Kbb)).T)
Kba = self.kernel(x, self.x)
m = self.kernel.mean*np.ones((len(self), 1))
fm = ms + Kba*scipy.linalg.cho_solve((self.L, True), self.y - m,
overwrite_b=True)
if meanonly:
return fm
else:
W = scipy.linalg.cho_solve((self.L, True), Kba.T)
fv = np.asmatrix(Kbb - np.sum(np.multiply(Kba.T, W), axis=0).T)
# W = np.asmatrix(scipy.linalg.solve(self.L, Kba.T, lower=True))
# fv = np.asmatrix(Kbb - np.sum(np.power(W, 2), axis=0).T)
return (fm, fv)
def MStaircase(Y, Z, precision=1e-12):
"""
Computes a smaller representation using the staircase
algorithm.
Notes
-----
This function should not be called directly.
It is used by 'MinimalRepFromME' and 'MinimalRepFromRAP'.
References
----------
.. [1] P. Buchholz, M. Telek, "On minimal representation
of rational arrival processes." Madrid Conference
on Qeueuing theory (MCQT), June 2010.
"""
X = []
for y in Y:
X.append(ml.matrix(y))
M = len(X)
m = X[0].shape[0]
U = ml.eye(m)
#The sum of the ranks calculated in every loop
ranksum = 0
crit = True #The stopping criteria
while crit == True:
r = la.matrix_rank(Z, tol=precision)
ranksum += r
[Ui, S, T] = la.svd(Z)
Transf = ml.eye(ranksum - r + Ui.shape[0])
Transf[-Ui.shape[1]:, -Ui.shape[0]:] = Ui.T
U = (Transf * U.T).T
for i in range(M):
TEMP = Ui.T * X[i] * Ui
X[i] = TEMP[r:, r:]
if i == 0:
Z = TEMP[r:, 0:r]
else:
Z = np.hstack((Z, TEMP[r:, 0:r]))
if la.norm(Z) < precision or la.matrix_rank(
Z, tol=precision) == m - ranksum:
crit = False
n = ranksum
if la.norm(Z) < precision:
n = ranksum
x = np.sum(U.T, 1)
x = x[0:n]
#does x have a 0 value somewhere
yes = False
zeroloc = ml.zeros((n, 1))
nonzero = -1 # this will indicate a row of x for which x's value is non-zero
for l in range(n):
if abs(x[l]) < precision:
yes = True
zeroloc[l, 0] = 1
elif nonzero == -1:
nonzero = l
R = ml.eye(n)
if yes:
for l in range(n):
if zeroloc[l, 0] == 1:
R[l, nonzero] = 1
y = R * x
Gamma = ml.diag(np.array(y).flatten())
TEMP1 = ml.eye(m)
TEMP1[0:n, 0:n] = la.inv(Gamma)
TEMP2 = ml.eye(m)
TEMP2[0:n, 0:n] = R
B = la.inv(TEMP1 * TEMP2 * U.T)
else:
n = m
B = ml.eye(m)
return (B, n)
caldatafile.readline()) # second line is number of data to read
data = nm.zeros((numdata, 4))
for i in range(0, numdata):
zap = caldatafile.readline().split()
data[i, 0] = float(zap[0])
data[i, 1] = float(zap[1])
data[i, 2] = float(zap[2])
data[i, 3] = float(zap[3])
Minima = [0, 0, 0, 0, 0, 0, 0, 0, 0]
pMinima = nm.reshape(Minima, [9])
Maxima = [10, 10, 6, 6, 6, 0.5, 0.5, 0.5, 0.5]
pMaxima = nm.reshape(Maxima, [9]) # max and min for prior
vcovProposal = ml.diag(
(0.005 * (pMaxima - pMinima))**2) # variance of the proposal
param = core.import_pools('KL_FaunalParams')
gmax = param[
0, :] #Original values in the parameterset are the starting values
#Values = [1.06,1.14,1.04,1.540,1.188,0.038,0.072,0.028,0.14] ; pValues=nm.reshape(Values,[9]) # starting values of the 9 model being optimised (gmax)
priorChain = nm.zeros([chainLength, len(gmax)], 'd')
priorChain[0, :] = gmax # start the chain
posteriorChain = nm.zeros([chainLength, len(gmax)], 'd')
posteriorChain[0, :] = gmax # start the chain
logPrior0 = nm.sum(nm.log(stats.uniform.pdf(gmax, pMinima, pMaxima)))
# this is the call to the model with the initial parameter values
y, PWt, PVt, pores = core.KeylinkModel(
gmax) #returns biomsses of all pools on all days in y
n = 200
a = nm.linspace(0, nm.pi, n / 2)
x_u = np.c_[nm.cos(a) + 0.5, nm.cos(a) - 0.5].reshape(n, 1)
u = -10 * x_u + nm.randn(n, 1)
x_v = np.c_[nm.sin(a), -nm.sin(a)].reshape(n, 1)
v = 10 * x_v + nm.randn(n, 1)
x = np.c_[u, v]
y = np.zeros((n, 1))
y[0] = 1
y[n - 1] = -1
x2 = np.sum(np.power(x, 2), 1)
hh = 2 * 1**2
k = nm.exp(-(nm.repmat(x2, 1, n) + nm.repmat(x2.T, n, 1) - 2 * x * x.T) / hh)
w = k
t_tmp1 = k**2 + 1 * np.eye(n) + 10 * k * (nm.diag(sum(w)) - w) * k
t = np.linalg.inv(t_tmp1) * (k * y)
m = 100
X = nm.linspace(-20, 20, m).T
X2 = np.power(X, 2)
U = nm.exp(
-(nm.repmat(np.power(u, 2), 1, m) + nm.repmat(X2.T, n, 1) - 2 * u * X.T) /
hh)
V = nm.exp(
-(nm.repmat(np.power(v, 2), 1, m) + nm.repmat(X2.T, n, 1) - 2 * v * X.T) /
hh)
plt.figure()
plt.xlim(-20, 20)
plt.ylim(-20, 20)
def fit(self, smoothTAC=None):
'''
Estimate parameters of the SRTM Zhou 2003 model.
Args:
smoothTAC (numpy.ndarray): optional. 1- or 2-D array, where each row
corresponds to a (spatially) smoothed time activity curve
'''
if smoothTAC is not None:
if smoothTAC.ndim==1:
if not len(smoothTAC)==len(self.t):
raise ValueError('smoothTAC and t must have same length')
# make smoothTAC into a row vector
smoothTAC = smoothTAC[np.newaxis,:]
elif smoothTAC.ndim==2:
if not smoothTAC.shape==self.TAC.shape:
raise ValueError('smoothTAC and TAC must have same shape')
else:
raise ValueError('smoothTAC must be 1- or 2-dimensional')
n = len(self.t)
m = 3
# Numerical integration of reference TAC
intrefTAC = km_integrate(self.refTAC,self.t,self.startActivity)
# Compute BP/DVR, R1, k2, k2a
for k, TAC in enumerate(self.TAC):
W = mat.diag(self.weights[k,:])
# Numerical integration of target TAC
intTAC = km_integrate(TAC,self.t,self.startActivity)
# ----- Get DVR -----
# Set up the weighted linear regression model
# based on Eq. 9 in Zhou et al.
# Per the recommendation in first paragraph on p. 979 of Zhou et al.,
# smoothed TAC is used in the design matrix, if provided.
if smoothTAC is None:
X = np.column_stack((intrefTAC, self.refTAC, -TAC))
else:
X = np.column_stack((intrefTAC, self.refTAC, -smoothTAC[k,:].flatten()))
y = intTAC
try:
b = solve(X.T @ W @ X, X.T @ W @ y)
residual = y - X @ b
# unbiased estimator of noise variance
noiseVar_eqDVR = residual.T @ W @ residual / (n-m)
DVR = b[0]
#R1 = b[1] / b[2]
#k2 = b[0] / b[2]
BP = DVR - 1
except:
DVR = BP = noiseVar_eqDVR = 0
# ----- Get R1 -----
# Set up the weighted linear regression model
# based on Eq. 8 in Zhou et al.
#X = np.mat(np.column_stack((self.refTAC,intrefTAC,-intTAC)))
X = np.column_stack((self.refTAC,intrefTAC,-intTAC))
#y = np.mat(TAC).T
y = TAC
try:
b = solve(X.T @ W @ X, X.T @ W @ y)
residual = y - X @ b
# unbiased estimator of noise variance
noiseVar_eqR1 = residual.T @ W @ residual / (n-m)
R1 = b[0]
k2 = b[1]
k2a = b[2]
except:
R1 = k2 = k2a = noiseVar_eqR1 = 0
self.results['BP'][k] = BP
self.results['DVR'][k] = DVR
self.results['R1'][k] = R1
self.results['k2'][k] = k2
self.results['k2a'][k] = k2a
self.results['noiseVar_eqDVR'][k] = noiseVar_eqDVR
self.results['noiseVar_eqR1'][k] = noiseVar_eqR1
return self
