def regression_warp(beta, time, q, y, alpha):
"""
calculates optimal warping for function linear regression
:param beta: numpy ndarray of shape (M,N) of M functions with N samples
:param time: vector of size N describing the sample points
:param q: numpy ndarray of shape (M,N) of M functions with N samples
:param y: numpy ndarray of shape (1,N) of M functions with N samples
responses
:param alpha: numpy scalar
:rtype: numpy array
:return gamma_new: warping function
"""
gam_M = uf.optimum_reparam(beta, time, q)
qM = uf.warp_q_gamma(time, q, gam_M)
y_M = trapz(qM * beta, time)
gam_m = uf.optimum_reparam(-1 * beta, time, q)
qm = uf.warp_q_gamma(time, q, gam_m)
y_m = trapz(qm * beta, time)
if y > alpha + y_M:
gamma_new = gam_M
elif y < alpha + y_m:
gamma_new = gam_m
else:
gamma_new = uf.zero_crossing(y - alpha, q, beta, time, y_M, y_m, gam_M,
gam_m)
return gamma_new
def regression_warp(beta, time, q, y, alpha):
"""
calculates optimal warping for function linear regression
:param beta: numpy ndarray of shape (M,N) of M functions with N samples
:param time: vector of size N describing the sample points
:param q: numpy ndarray of shape (M,N) of M functions with N samples
:param y: numpy ndarray of shape (1,N) of M functions with N samples
responses
:param alpha: numpy scalar
:rtype: numpy array
:return gamma_new: warping function
"""
gam_M = uf.optimum_reparam(beta, time, q)
qM = uf.warp_q_gamma(time, q, gam_M)
y_M = trapz(qM * beta, time)
gam_m = uf.optimum_reparam(-1 * beta, time, q)
qm = uf.warp_q_gamma(time, q, gam_m)
y_m = trapz(qm * beta, time)
if y > alpha + y_M:
gamma_new = gam_M
elif y < alpha + y_m:
gamma_new = gam_m
else:
gamma_new = uf.zero_crossing(y - alpha, q, beta, time, y_M, y_m,
gam_M, gam_m)
return gamma_new
def _elastic_alignment_array(template_data, q_data,
eval_points, penalty, grid_dim):
r"""Wrapper between the cython interface and python.
Selects the corresponding routine depending on the dimensions of the
arrays.
Args:
template_data (numpy.ndarray): Array with the srsf of the template.
q_data (numpy.ndarray): Array with the srsf of the curves
to be aligned.
eval_points (numpy.ndarray): Discretisation points of the functions.
penalty (float): Penalisation term.
grid_dim (int): Dimension of the grid used in the alignment algorithm.
Return:
(numpy.ndarray): Array with the same shape than q_data with the srsf of
the functions aligned to the template(s).
"""
return optimum_reparam(np.ascontiguousarray(template_data.T),
np.ascontiguousarray(eval_points),
np.ascontiguousarray(q_data.T),
method="DP2",
lam=penalty, grid_dim=grid_dim).T
def map_driver(q1, f, bet, t, dt):
q2 = uf.f_to_srsf(f, t)
gam = uf.optimum_reparam(q1, t, q2)
fn = uf.warp_f_gamma(t, f, gam)
tmp = bet * fn
y = tmp.sum() * dt
return y
def logistic_warp(beta, time, q, y):
"""
calculates optimal warping for function logistic regression
:param beta: numpy ndarray of shape (M,N) of N functions with M samples
:param time: vector of size N describing the sample points
:param q: numpy ndarray of shape (M,N) of N functions with M samples
:param y: numpy ndarray of shape (1,N) responses
:rtype: numpy array
:return gamma: warping function
"""
if y == 1:
gamma = uf.optimum_reparam(beta, time, q)
elif y == -1:
gamma = uf.optimum_reparam(-1*beta, time, q)
return gamma
def logistic_warp(beta, time, q, y):
"""
calculates optimal warping for function logistic regression
:param beta: numpy ndarray of shape (M,N) of N functions with M samples
:param time: vector of size N describing the sample points
:param q: numpy ndarray of shape (M,N) of N functions with M samples
:param y: numpy ndarray of shape (1,N) responses
:rtype: numpy array
:return gamma: warping function
"""
if y == 1:
gamma = uf.optimum_reparam(beta, time, q)
elif y == -1:
gamma = uf.optimum_reparam(-1 * beta, time, q)
return gamma
def MapC_to_y(n, c, B, t, f, parallel):
dt = np.diff(t)
dt = dt.mean()
y = np.zeros(n)
if parallel:
bet = np.dot(B, c)
q1 = uf.f_to_srsf(bet, t)
y = Parallel(n_jobs=-1)(delayed(map_driver)(q1, f[:, k], bet, t, dt)
for k in range(n))
else:
for k in range(0, n):
bet = np.dot(B, c)
q1 = uf.f_to_srsf(bet, t)
q2 = uf.f_to_srsf(f[:, k], t)
gam = uf.optimum_reparam(q1, t, q2)
fn = uf.warp_f_gamma(t, f[:, k], gam)
tmp = bet * fn
y[k] = tmp.sum() * dt
return (y)
def align_fPCA(f, time, num_comp=3, showplot=True, smoothdata=False, cores=-1):
"""
aligns a collection of functions while extracting principal components.
The functions are aligned to the principal components
:param f: numpy ndarray of shape (M,N) of N functions with M samples
:param time: vector of size M describing the sample points
:param num_comp: number of fPCA components
:param showplot: Shows plots of results using matplotlib (default = T)
:param smooth_data: Smooth the data using a box filter (default = F)
:param cores: number of cores for parallel (default = -1 (all))
:type sparam: double
:type smooth_data: bool
:type f: np.ndarray
:type time: np.ndarray
:rtype: tuple of numpy array
:return fn: aligned functions - numpy ndarray of shape (M,N) of N
functions with M samples
:return qn: aligned srvfs - similar structure to fn
:return q0: original srvf - similar structure to fn
:return mqn: srvf mean or median - vector of length M
:return gam: warping functions - similar structure to fn
:return q_pca: srsf principal directions
:return f_pca: functional principal directions
:return latent: latent values
:return coef: coefficients
:return U: eigenvectors
:return orig_var: Original Variance of Functions
:return amp_var: Amplitude Variance
:return phase_var: Phase Variance
"""
lam = 0.0
MaxItr = 50
coef = np.arange(-2., 3.)
Nstd = coef.shape[0]
M = f.shape[0]
N = f.shape[1]
if M > 500:
parallel = True
elif N > 100:
parallel = True
else:
parallel = False
eps = np.finfo(np.double).eps
f0 = f
if showplot:
plot.f_plot(time, f, title="Original Data")
# Compute SRSF function from data
f, g, g2 = uf.gradient_spline(time, f, smoothdata)
q = g / np.sqrt(abs(g) + eps)
print("Initializing...")
mnq = q.mean(axis=1)
a = mnq.repeat(N)
d1 = a.reshape(M, N)
d = (q - d1)**2
dqq = np.sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
print("Aligning %d functions in SRVF space to %d fPCA components..." %
(N, num_comp))
itr = 0
mq = np.zeros((M, MaxItr + 1))
mq[:, itr] = q[:, min_ind]
fi = np.zeros((M, N, MaxItr + 1))
fi[:, :, 0] = f
qi = np.zeros((M, N, MaxItr + 1))
qi[:, :, 0] = q
gam = np.zeros((M, N, MaxItr + 1))
cost = np.zeros(MaxItr + 1)
while itr < MaxItr:
print("updating step: r=%d" % (itr + 1))
if itr == MaxItr:
print("maximal number of iterations is reached")
# PCA Step
a = mq[:, itr].repeat(N)
d1 = a.reshape(M, N)
qhat_cent = qi[:, :, itr] - d1
K = np.cov(qi[:, :, itr])
U, s, V = svd(K)
alpha_i = np.zeros((num_comp, N))
for ii in range(0, num_comp):
for jj in range(0, N):
alpha_i[ii, jj] = trapz(qhat_cent[:, jj] * U[:, ii], time)
U1 = U[:, 0:num_comp]
tmp = U1.dot(alpha_i)
qhat = d1 + tmp
# Matching Step
if parallel:
out = Parallel(n_jobs=cores)(
delayed(uf.optimum_reparam)(qhat[:,
n], time, qi[:, n,
itr], "DP", lam)
for n in range(N))
gam_t = np.array(out)
gam[:, :, itr] = gam_t.transpose()
else:
gam[:, :, itr] = uf.optimum_reparam(qhat, time, qi[:, :, itr],
"DP", lam)
for k in range(0, N):
time0 = (time[-1] - time[0]) * gam[:, k, itr] + time[0]
fi[:, k, itr + 1] = np.interp(time0, time, fi[:, k, itr])
qi[:, k, itr + 1] = uf.f_to_srsf(fi[:, k, itr + 1], time)
qtemp = qi[:, :, itr + 1]
mq[:, itr + 1] = qtemp.mean(axis=1)
cost_temp = np.zeros(N)
for ii in range(0, N):
cost_temp[ii] = norm(qtemp[:, ii] - qhat[:, ii])**2
cost[itr + 1] = cost_temp.mean()
if abs(cost[itr + 1] - cost[itr]) < 1e-06:
break
itr += 1
if itr >= MaxItr:
itrf = MaxItr
else:
itrf = itr + 1
cost = cost[1:(itrf + 1)]
# Aligned data & stats
fn = fi[:, :, itrf]
qn = qi[:, :, itrf]
q0 = qi[:, :, 0]
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mqn = mq[:, itrf]
gamf = gam[:, :, 0]
for k in range(1, itr):
gam_k = gam[:, :, k]
for l in range(0, N):
time0 = (time[-1] - time[0]) * gam_k[:, l] + time[0]
gamf[:, l] = np.interp(time0, time, gamf[:, l])
# Center Mean
gamI = uf.SqrtMeanInverse(gamf)
gamI_dev = np.gradient(gamI, 1 / float(M - 1))
time0 = (time[-1] - time[0]) * gamI + time[0]
mqn = np.interp(time0, time, mqn) * np.sqrt(gamI_dev)
for k in range(0, N):
qn[:, k] = np.interp(time0, time, qn[:, k]) * np.sqrt(gamI_dev)
fn[:, k] = np.interp(time0, time, fn[:, k])
gamf[:, k] = np.interp(time0, time, gamf[:, k])
mean_fn = fn.mean(axis=1)
std_fn = fn.std(axis=1)
# Get Final PCA
mididx = int(np.round(time.shape[0] / 2))
m_new = np.sign(fn[mididx, :]) * np.sqrt(np.abs(fn[mididx, :]))
mqn2 = np.append(mqn, m_new.mean())
qn2 = np.vstack((qn, m_new))
K = np.cov(qn2)
U, s, V = svd(K)
stdS = np.sqrt(s)
# compute the PCA in the q domain
q_pca = np.ndarray(shape=(M + 1, Nstd, num_comp), dtype=float)
for k in range(0, num_comp):
for l in range(0, Nstd):
q_pca[:, l, k] = mqn2 + coef[l] * stdS[k] * U[:, k]
# compute the correspondence in the f domain
f_pca = np.ndarray(shape=(M, Nstd, num_comp), dtype=float)
for k in range(0, num_comp):
for l in range(0, Nstd):
q_pca_tmp = q_pca[0:M, l, k] * np.abs(q_pca[0:M, l, k])
q_pca_tmp2 = np.sign(q_pca[M, l, k]) * (q_pca[M, l, k]**2)
f_pca[:, l, k] = uf.cumtrapzmid(time, q_pca_tmp, q_pca_tmp2,
np.floor(time.shape[0] / 2),
mididx)
N2 = qn.shape[1]
c = np.zeros((N2, num_comp))
for k in range(0, num_comp):
for l in range(0, N2):
c[l, k] = sum((np.append(qn[:, l], m_new[l]) - mqn2) * U[:, k])
if showplot:
CBcdict = {
'Bl': (0, 0, 0),
'Or': (.9, .6, 0),
'SB': (.35, .7, .9),
'bG': (0, .6, .5),
'Ye': (.95, .9, .25),
'Bu': (0, .45, .7),
'Ve': (.8, .4, 0),
'rP': (.8, .6, .7),
}
cl = sorted(CBcdict.keys())
# Align Plots
fig, ax = plot.f_plot(np.arange(0, M) / float(M - 1),
gamf,
title="Warping Functions")
ax.set_aspect('equal')
plot.f_plot(time, fn, title="Warped Data")
tmp = np.array([mean_f0, mean_f0 + std_f0, mean_f0 - std_f0])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title=r"Original Data: Mean $\pm$ STD")
tmp = np.array([mean_fn, mean_fn + std_fn, mean_fn - std_fn])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title=r"Warped Data: Mean $\pm$ STD")
# PCA Plots
fig, ax = plt.subplots(2, num_comp)
for k in range(0, num_comp):
axt = ax[0, k]
for l in range(0, Nstd):
axt.plot(time, q_pca[0:M, l, k], color=CBcdict[cl[l]])
axt.hold(True)
axt.set_title('q domain: PD %d' % (k + 1))
plot.rstyle(axt)
axt = ax[1, k]
for l in range(0, Nstd):
axt.plot(time, f_pca[:, l, k], color=CBcdict[cl[l]])
axt.hold(True)
axt.set_title('f domain: PD %d' % (k + 1))
plot.rstyle(axt)
fig.set_tight_layout(True)
cumm_coef = 100 * np.cumsum(s) / sum(s)
idx = np.arange(0, M + 1) + 1
plot.f_plot(idx, cumm_coef, "Coefficient Cumulative Percentage")
plt.xlabel("Percentage")
plt.ylabel("Index")
plt.show()
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mean_fn = fn.mean(axis=1)
std_fn = fn.std(axis=1)
tmp = np.zeros(M)
tmp[1:] = cumtrapz(mqn * np.abs(mqn), time)
fmean = np.mean(f0[1, :]) + tmp
fgam = np.zeros((M, N))
for k in range(0, N):
time0 = (time[-1] - time[0]) * gamf[:, k] + time[0]
fgam[:, k] = np.interp(time0, time, fmean)
var_fgam = fgam.var(axis=1)
orig_var = trapz(std_f0**2, time)
amp_var = trapz(std_fn**2, time)
phase_var = trapz(var_fgam, time)
K = np.cov(fn)
U, s, V = svd(K)
align_fPCAresults = collections.namedtuple('align_fPCA', [
'fn', 'qn', 'q0', 'mqn', 'gam', 'q_pca', 'f_pca', 'latent', 'coef',
'U', 'orig_var', 'amp_var', 'phase_var', 'cost'
])
out = align_fPCAresults(fn, qn, q0, mqn, gamf, q_pca, f_pca, s, c, U,
orig_var, amp_var, phase_var, cost)
return out
def srsf_align(self,
method="mean",
omethod="DP",
smoothdata=False,
parallel=False,
lam=0.0,
cores=-1):
"""
This function aligns a collection of functions using the elastic
square-root slope (srsf) framework.
:param method: (string) warp calculate Karcher Mean or Median (options = "mean" or "median") (default="mean")
:param omethod: optimization method (DP, DP2) (default = DP)
:param smoothdata: Smooth the data using a box filter (default = F)
:param parallel: run in parallel (default = F)
:param lam: controls the elasticity (default = 0)
:param cores: number of cores for parallel (default = -1 (all))
:type lam: double
:type smoothdata: bool
Examples
>>> import tables
>>> fun=tables.open_file("../Data/simu_data.h5")
>>> f = fun.root.f[:]
>>> f = f.transpose()
>>> time = fun.root.time[:]
>>> obj = fs.fdawarp(f,time)
>>> obj.srsf_align()
"""
M = self.f.shape[0]
N = self.f.shape[1]
self.lam = lam
if M > 500:
parallel = True
elif N > 100:
parallel = True
eps = np.finfo(np.double).eps
f0 = self.f
self.method = omethod
methods = ["mean", "median"]
self.type = method
# 0 mean, 1-median
method = [i for i, x in enumerate(methods) if x == method]
if len(method) == 0:
method = 0
else:
method = method[0]
# Compute SRSF function from data
f, g, g2 = uf.gradient_spline(self.time, self.f, smoothdata)
q = g / np.sqrt(abs(g) + eps)
print("Initializing...")
mnq = q.mean(axis=1)
a = mnq.repeat(N)
d1 = a.reshape(M, N)
d = (q - d1)**2
dqq = np.sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
mq = q[:, min_ind]
mf = f[:, min_ind]
if parallel:
out = Parallel(n_jobs=cores)(delayed(uf.optimum_reparam)(
mq, self.time, q[:, n], omethod, lam, mf[0], f[0, n])
for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = np.zeros((M, N))
for k in range(0, N):
gam[:, k] = uf.optimum_reparam(mq, self.time, q[:, k], omethod,
lam, mf[0], f[0, k])
gamI = uf.SqrtMeanInverse(gam)
mf = np.interp((self.time[-1] - self.time[0]) * gamI + self.time[0],
self.time, mf)
mq = uf.f_to_srsf(mf, self.time)
# Compute Karcher Mean
if method == 0:
print("Compute Karcher Mean of %d function in SRSF space..." % N)
if method == 1:
print("Compute Karcher Median of %d function in SRSF space..." % N)
MaxItr = 20
ds = np.repeat(0.0, MaxItr + 2)
ds[0] = np.inf
qun = np.repeat(0.0, MaxItr + 1)
tmp = np.zeros((M, MaxItr + 2))
tmp[:, 0] = mq
mq = tmp
tmp = np.zeros((M, MaxItr + 2))
tmp[:, 0] = mf
mf = tmp
tmp = np.zeros((M, N, MaxItr + 2))
tmp[:, :, 0] = self.f
f = tmp
tmp = np.zeros((M, N, MaxItr + 2))
tmp[:, :, 0] = q
q = tmp
for r in range(0, MaxItr):
print("updating step: r=%d" % (r + 1))
if r == (MaxItr - 1):
print("maximal number of iterations is reached")
# Matching Step
if parallel:
out = Parallel(n_jobs=cores)(delayed(uf.optimum_reparam)(
mq[:, r], self.time, q[:, n,
0], omethod, lam, mf[0, r], f[0, n,
0])
for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
for k in range(0, N):
gam[:, k] = uf.optimum_reparam(mq[:, r], self.time,
q[:, k, 0], omethod, lam,
mf[0, r], f[0, k, 0])
gam_dev = np.zeros((M, N))
vtil = np.zeros((M, N))
dtil = np.zeros(N)
for k in range(0, N):
f[:, k, r + 1] = np.interp(
(self.time[-1] - self.time[0]) * gam[:, k] + self.time[0],
self.time, f[:, k, 0])
q[:, k, r + 1] = uf.f_to_srsf(f[:, k, r + 1], self.time)
gam_dev[:, k] = np.gradient(gam[:, k], 1 / float(M - 1))
v = q[:, k, r + 1] - mq[:, r]
d = np.sqrt(trapz(v * v, self.time))
vtil[:, k] = v / d
dtil[k] = 1.0 / d
mqt = mq[:, r]
a = mqt.repeat(N)
d1 = a.reshape(M, N)
d = (q[:, :, r + 1] - d1)**2
if method == 0:
d1 = sum(trapz(d, self.time, axis=0))
d2 = sum(trapz((1 - np.sqrt(gam_dev))**2, self.time, axis=0))
ds_tmp = d1 + lam * d2
ds[r + 1] = ds_tmp
# Minimization Step
# compute the mean of the matched function
qtemp = q[:, :, r + 1]
ftemp = f[:, :, r + 1]
mq[:, r + 1] = qtemp.mean(axis=1)
mf[:, r + 1] = ftemp.mean(axis=1)
qun[r] = norm(mq[:, r + 1] - mq[:, r]) / norm(mq[:, r])
if method == 1:
d1 = np.sqrt(sum(trapz(d, self.time, axis=0)))
d2 = sum(trapz((1 - np.sqrt(gam_dev))**2, self.time, axis=0))
ds_tmp = d1 + lam * d2
ds[r + 1] = ds_tmp
# Minimization Step
# compute the mean of the matched function
stp = .3
vbar = vtil.sum(axis=1) * (1 / dtil.sum())
qtemp = q[:, :, r + 1]
ftemp = f[:, :, r + 1]
mq[:, r + 1] = mq[:, r] + stp * vbar
tmp = np.zeros(M)
tmp[1:] = cumtrapz(mq[:, r + 1] * np.abs(mq[:, r + 1]),
self.time)
mf[:, r + 1] = np.median(f0[1, :]) + tmp
qun[r] = norm(mq[:, r + 1] - mq[:, r]) / norm(mq[:, r])
if qun[r] < 1e-2 or r >= MaxItr:
break
# Last Step with centering of gam
r += 1
if parallel:
out = Parallel(n_jobs=cores)(delayed(uf.optimum_reparam)(
mq[:, r], self.time, q[:, n,
0], omethod, lam, mf[0, r], f[0, n, 0])
for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
for k in range(0, N):
gam[:, k] = uf.optimum_reparam(mq[:, r], self.time, q[:, k, 0],
omethod, lam, mf[0, r], f[0, k,
0])
gam_dev = np.zeros((M, N))
for k in range(0, N):
gam_dev[:, k] = np.gradient(gam[:, k], 1 / float(M - 1))
gamI = uf.SqrtMeanInverse(gam)
gamI_dev = np.gradient(gamI, 1 / float(M - 1))
time0 = (self.time[-1] - self.time[0]) * gamI + self.time[0]
mq[:,
r + 1] = np.interp(time0, self.time, mq[:, r]) * np.sqrt(gamI_dev)
for k in range(0, N):
q[:, k, r +
1] = np.interp(time0, self.time, q[:, k, r]) * np.sqrt(gamI_dev)
f[:, k, r + 1] = np.interp(time0, self.time, f[:, k, r])
gam[:, k] = np.interp(time0, self.time, gam[:, k])
# Aligned data & stats
self.fn = f[:, :, r + 1]
self.qn = q[:, :, r + 1]
self.q0 = q[:, :, 0]
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mean_fn = self.fn.mean(axis=1)
std_fn = self.fn.std(axis=1)
self.gam = gam
self.mqn = mq[:, r + 1]
tmp = np.zeros(M)
tmp[1:] = cumtrapz(self.mqn * np.abs(self.mqn), self.time)
self.fmean = np.mean(f0[1, :]) + tmp
fgam = np.zeros((M, N))
for k in range(0, N):
time0 = (self.time[-1] - self.time[0]) * gam[:, k] + self.time[0]
fgam[:, k] = np.interp(time0, self.time, self.fmean)
var_fgam = fgam.var(axis=1)
self.orig_var = trapz(std_f0**2, self.time)
self.amp_var = trapz(std_fn**2, self.time)
self.phase_var = trapz(var_fgam, self.time)
return
def multiple_align_functions(self,
mu,
omethod="DP",
smoothdata=False,
parallel=False,
lam=0.0,
cores=-1):
"""
This function aligns a collection of functions using the elastic square-root
slope (srsf) framework.
Usage: obj.multiple_align_functions(mu)
obj.multiple_align_functions(lambda)
obj.multiple_align_functions(lambda, ...)
:param mu: vector of function to align to
:param omethod: optimization method (DP, DP2) (default = DP)
:param smoothdata: Smooth the data using a box filter (default = F)
:param parallel: run in parallel (default = F)
:param lam: controls the elasticity (default = 0)
:param cores: number of cores for parallel (default = -1 (all))
:type lam: double
:type smoothdata: bool
"""
M = self.f.shape[0]
N = self.f.shape[1]
self.lam = lam
if M > 500:
parallel = True
elif N > 100:
parallel = True
eps = np.finfo(np.double).eps
self.method = omethod
self.type = "multiple"
# Compute SRSF function from data
f, g, g2 = uf.gradient_spline(self.time, self.f, smoothdata)
q = g / np.sqrt(abs(g) + eps)
mq = uf.f_to_srsf(mu, self.time)
if parallel:
out = Parallel(n_jobs=cores)(delayed(uf.optimum_reparam)(
mq, self.time, q[:, n], omethod, lam, mu[0], f[0, n])
for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = np.zeros((M, N))
for k in range(0, N):
gam[:, k] = uf.optimum_reparam(mq, self.time, q[:, k], omethod,
lam, mu[0], f[0, k])
self.gamI = uf.SqrtMeanInverse(gam)
fn = np.zeros((M, N))
qn = np.zeros((M, N))
for k in range(0, N):
fn[:, k] = np.interp(
(self.time[-1] - self.time[0]) * gam[:, k] + self.time[0],
self.time, f[:, k])
qn[:, k] = uf.f_to_srsf(f[:, k], self.time)
# Aligned data & stats
self.fn = fn
self.qn = qn
self.q0 = q
mean_f0 = f.mean(axis=1)
std_f0 = f.std(axis=1)
mean_fn = self.fn.mean(axis=1)
std_fn = self.fn.std(axis=1)
self.gam = gam
self.mqn = mq
self.fmean = mu
fgam = np.zeros((M, N))
for k in range(0, N):
time0 = (self.time[-1] - self.time[0]) * gam[:, k] + self.time[0]
fgam[:, k] = np.interp(time0, self.time, self.fmean)
var_fgam = fgam.var(axis=1)
self.orig_var = trapz(std_f0**2, self.time)
self.amp_var = trapz(std_fn**2, self.time)
self.phase_var = trapz(var_fgam, self.time)
return
def predict(self, newdata=None):
"""
This function performs prediction on regression model on new data if available or current stored data in object
Usage: obj.predict()
obj.predict(newdata)
:param newdata: dict containing new data for prediction (needs the keys below, if None predicts on training data)
:type newdata: dict
:param f: (M,N) matrix of functions
:param time: vector of time points
:param y: truth if available
:param smooth: smooth data if needed
:param sparam: number of times to run filter
"""
omethod = self.warp_data.method
lam = self.warp_data.lam
m = self.n_classes
M = self.time.shape[0]
if newdata != None:
f = newdata['f']
time = newdata['time']
y = newdata['y']
sparam = newdata['sparam']
if newdata['smooth']:
f = fs.smooth_data(f, sparam)
q1 = fs.f_to_srsf(f, time)
n = q1.shape[1]
self.y_pred = np.zeros((n, m))
mq = self.warp_data.mqn
fn = np.zeros((M, n))
qn = np.zeros((M, n))
gam = np.zeros((M, n))
for ii in range(0, n):
gam[:, ii] = uf.optimum_reparam(mq, time, q1[:, ii], omethod)
fn[:, ii] = uf.warp_f_gamma(time, f[:, ii], gam[:, ii])
qn[:, ii] = uf.f_to_srsf(fn[:, ii], time)
m_new = np.sign(fn[self.pca.id, :]) * np.sqrt(
np.abs(fn[self.pca.id, :]))
qn1 = np.vstack((qn, m_new))
U = self.pca.U
no = U.shape[1]
if self.pca.__class__.__name__ == 'fdajpca':
C = self.pca.C
TT = self.time.shape[0]
mu_g = self.pca.mu_g
mu_psi = self.pca.mu_psi
vec = np.zeros((M, n))
psi = np.zeros((TT, n))
binsize = np.mean(np.diff(self.time))
for i in range(0, n):
psi[:, i] = np.sqrt(np.gradient(gam[:, i], binsize))
vec[:, i] = geo.inv_exp_map(mu_psi, psi[:, i])
g = np.vstack((qn1, C * vec))
a = np.zeros((n, no))
for i in range(0, n):
for j in range(0, no):
tmp = (g[:, i] - mu_g)
a[i, j] = dot(tmp.T, U[:, j])
elif self.pca.__class__.__name__ == 'fdavpca':
a = np.zeros((n, no))
for i in range(0, n):
for j in range(0, no):
tmp = (qn1[:, i] - self.pca.mqn)
a[i, j] = dot(tmp.T, U[:, j])
elif self.pca.__class__.__name__ == 'fdahpca':
a = np.zeros((n, no))
mu_psi = self.pca.psi_mu
vec = np.zeros((M, n))
TT = self.time.shape[0]
psi = np.zeros((TT, n))
binsize = np.mean(np.diff(self.time))
for i in range(0, n):
psi[:, i] = np.sqrt(np.gradient(gam[:, i], binsize))
vec[:, i] = geo.inv_exp_map(mu_psi, psi[:, i])
vm = self.pca.vec.mean(axis=1)
for i in range(0, n):
for j in range(0, no):
a[i, j] = np.sum(dot(vec[:, i] - vm, U[:, j]))
else:
raise Exception('Invalid fPCA Method')
for ii in range(0, n):
for jj in range(0, m):
self.y_pred[ii, jj] = self.alpha[jj] + np.sum(
a[ii, :] * self.b[:, jj])
if y == None:
self.y_pred = rg.phi(self.y_pred.reshape((1, n * m)))
self.y_pred = self.y_pred.reshape((n, m))
self.y_labels = np.argmax(self.y_pred, axis=1)
self.PC = np.nan
else:
self.y_pred = rg.phi(self.y_pred.reshape((1, n * m)))
self.y_pred = self.y_pred.reshape((n, m))
self.y_labels = np.argmax(self.y_pred, axis=1)
self.PC = np.zeros(m)
cls_set = np.arange(0, m)
for ii in range(0, m):
cls_sub = np.setdiff1d(cls_set, ii)
TP = np.sum(y[self.y_labels == ii] == ii)
FP = np.sum(y[np.in1d(self.y_labels, cls_sub)] == ii)
TN = np.sum(y[np.in1d(self.y_labels, cls_sub)] ==
self.y_labels[np.in1d(self.y_labels, cls_sub)])
FN = np.sum(np.in1d(y[self.y_labels == ii], cls_sub))
self.PC[ii] = (TP + TN) / (TP + FP + FN + TN)
self.PCo = np.sum(y == self.y_labels) / self.y_labels.shape[0]
else:
n = self.pca.coef.shape[1]
self.y_pred = np.zeros((n, m))
for ii in range(0, n):
for jj in range(0, m):
self.y_pred[ii, jj] = self.alpha[jj] + np.sum(
self.pca.coef[ii, :] * self.b[:, jj])
self.y_pred = rg.phi(self.y_pred.reshape((1, n * m)))
self.y_pred = self.y_pred.reshape((n, m))
self.y_labels = np.argmax(self.y_pred, axis=1)
self.PC = np.zeros(m)
cls_set = np.arange(0, m)
for ii in range(0, m):
cls_sub = np.setdiff1d(cls_set, ii)
TP = np.sum(self.y[self.y_labels == ii] == ii)
FP = np.sum(self.y[np.in1d(self.y_labels, cls_sub)] == ii)
TN = np.sum(self.y[np.in1d(self.y_labels, cls_sub)] ==
self.y_labels[np.in1d(self.y_labels, cls_sub)])
FN = np.sum(np.in1d(y[self.y_labels == ii], cls_sub))
self.PC[ii] = (TP + TN) / (TP + FP + FN + TN)
self.PCo = np.sum(y == self.y_labels) / self.y_labels.shape[0]
return
def align_fPCA(f, time, num_comp=3, showplot=True, smoothdata=False):
"""
aligns a collection of functions while extracting principal components.
The functions are aligned to the principal components
:param f: numpy ndarray of shape (M,N) of N functions with M samples
:param time: vector of size M describing the sample points
:param num_comp: number of fPCA components
:param showplot: Shows plots of results using matplotlib (default = T)
:param smooth_data: Smooth the data using a box filter (default = F)
:param sparam: Number of times to run box filter (default = 25)
:type sparam: double
:type smooth_data: bool
:type f: np.ndarray
:type time: np.ndarray
:rtype: tuple of numpy array
:return fn: aligned functions - numpy ndarray of shape (M,N) of N
functions with M samples
:return qn: aligned srvfs - similar structure to fn
:return q0: original srvf - similar structure to fn
:return mqn: srvf mean or median - vector of length M
:return gam: warping functions - similar structure to fn
:return q_pca: srsf principal directions
:return f_pca: functional principal directions
:return latent: latent values
:return coef: coefficients
:return U: eigenvectors
:return orig_var: Original Variance of Functions
:return amp_var: Amplitude Variance
:return phase_var: Phase Variance
"""
lam = 0.0
MaxItr = 50
coef = np.arange(-2., 3.)
Nstd = coef.shape[0]
M = f.shape[0]
N = f.shape[1]
if M > 500:
parallel = True
elif N > 100:
parallel = True
else:
parallel = False
eps = np.finfo(np.double).eps
f0 = f
if showplot:
plot.f_plot(time, f, title="Original Data")
# Compute SRSF function from data
f, g, g2 = uf.gradient_spline(time, f, smoothdata)
q = g / np.sqrt(abs(g) + eps)
print ("Initializing...")
mnq = q.mean(axis=1)
a = mnq.repeat(N)
d1 = a.reshape(M, N)
d = (q - d1) ** 2
dqq = np.sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
print("Aligning %d functions in SRVF space to %d fPCA components..."
% (N, num_comp))
itr = 0
mq = np.zeros((M, MaxItr + 1))
mq[:, itr] = q[:, min_ind]
fi = np.zeros((M, N, MaxItr + 1))
fi[:, :, 0] = f
qi = np.zeros((M, N, MaxItr + 1))
qi[:, :, 0] = q
gam = np.zeros((M, N, MaxItr + 1))
cost = np.zeros(MaxItr + 1)
while itr < MaxItr:
print("updating step: r=%d" % (itr + 1))
if itr == MaxItr:
print("maximal number of iterations is reached")
# PCA Step
a = mq[:, itr].repeat(N)
d1 = a.reshape(M, N)
qhat_cent = qi[:, :, itr] - d1
K = np.cov(qi[:, :, itr])
U, s, V = svd(K)
alpha_i = np.zeros((num_comp, N))
for ii in range(0, num_comp):
for jj in range(0, N):
alpha_i[ii, jj] = trapz(qhat_cent[:, jj] * U[:, ii], time)
U1 = U[:, 0:num_comp]
tmp = U1.dot(alpha_i)
qhat = d1 + tmp
# Matching Step
if parallel:
out = Parallel(n_jobs=-1)(
delayed(uf.optimum_reparam)(qhat[:, n], time, qi[:, n, itr],
lam) for n in range(N))
gam_t = np.array(out)
gam[:, :, itr] = gam_t.transpose()
else:
gam[:, :, itr] = uf.optimum_reparam(qhat, time, qi[:, :, itr], lam)
for k in range(0, N):
time0 = (time[-1] - time[0]) * gam[:, k, itr] + time[0]
fi[:, k, itr + 1] = np.interp(time0, time, fi[:, k, itr])
qi[:, k, itr + 1] = uf.f_to_srsf(fi[:, k, itr + 1], time)
qtemp = qi[:, :, itr + 1]
mq[:, itr + 1] = qtemp.mean(axis=1)
cost_temp = np.zeros(N)
for ii in range(0, N):
cost_temp[ii] = norm(qtemp[:, ii] - qhat[:, ii]) ** 2
cost[itr + 1] = cost_temp.mean()
if abs(cost[itr + 1] - cost[itr]) < 1e-06:
break
itr += 1
if itr >= MaxItr:
itrf = MaxItr
else:
itrf = itr+1
cost = cost[1:(itrf+1)]
# Aligned data & stats
fn = fi[:, :, itrf]
qn = qi[:, :, itrf]
q0 = qi[:, :, 0]
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mqn = mq[:, itrf]
gamf = gam[:, :, 0]
for k in range(1, itr):
gam_k = gam[:, :, k]
for l in range(0, N):
time0 = (time[-1] - time[0]) * gam_k[:, l] + time[0]
gamf[:, l] = np.interp(time0, time, gamf[:, l])
# Center Mean
gamI = uf.SqrtMeanInverse(gamf)
gamI_dev = np.gradient(gamI, 1 / float(M - 1))
time0 = (time[-1] - time[0]) * gamI + time[0]
mqn = np.interp(time0, time, mqn) * np.sqrt(gamI_dev)
for k in range(0, N):
qn[:, k] = np.interp(time0, time, qn[:, k]) * np.sqrt(gamI_dev)
fn[:, k] = np.interp(time0, time, fn[:, k])
gamf[:, k] = np.interp(time0, time, gamf[:, k])
mean_fn = fn.mean(axis=1)
std_fn = fn.std(axis=1)
# Get Final PCA
mididx = np.round(time.shape[0] / 2)
m_new = np.sign(fn[mididx, :]) * np.sqrt(np.abs(fn[mididx, :]))
mqn2 = np.append(mqn, m_new.mean())
qn2 = np.vstack((qn, m_new))
K = np.cov(qn2)
U, s, V = svd(K)
stdS = np.sqrt(s)
# compute the PCA in the q domain
q_pca = np.ndarray(shape=(M + 1, Nstd, num_comp), dtype=float)
for k in range(0, num_comp):
for l in range(0, Nstd):
q_pca[:, l, k] = mqn2 + coef[l] * stdS[k] * U[:, k]
# compute the correspondence in the f domain
f_pca = np.ndarray(shape=(M, Nstd, num_comp), dtype=float)
for k in range(0, num_comp):
for l in range(0, Nstd):
q_pca_tmp = q_pca[0:M, l, k] * np.abs(q_pca[0:M, l, k])
q_pca_tmp2 = np.sign(q_pca[M, l, k]) * (q_pca[M, l, k] ** 2)
f_pca[:, l, k] = uf.cumtrapzmid(time, q_pca_tmp, q_pca_tmp2)
N2 = qn.shape[1]
c = np.zeros((N2, num_comp))
for k in range(0, num_comp):
for l in range(0, N2):
c[l, k] = sum((np.append(qn[:, l], m_new[l]) - mqn2) * U[:, k])
if showplot:
CBcdict = {
'Bl': (0, 0, 0),
'Or': (.9, .6, 0),
'SB': (.35, .7, .9),
'bG': (0, .6, .5),
'Ye': (.95, .9, .25),
'Bu': (0, .45, .7),
'Ve': (.8, .4, 0),
'rP': (.8, .6, .7),
}
cl = sorted(CBcdict.keys())
# Align Plots
fig, ax = plot.f_plot(np.arange(0, M) / float(M - 1), gamf,
title="Warping Functions")
ax.set_aspect('equal')
plot.f_plot(time, fn, title="Warped Data")
tmp = np.array([mean_f0, mean_f0 + std_f0, mean_f0 - std_f0])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title="Original Data: Mean $\pm$ STD")
tmp = np.array([mean_fn, mean_fn + std_fn, mean_fn - std_fn])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title="Warped Data: Mean $\pm$ STD")
# PCA Plots
fig, ax = plt.subplots(2, num_comp)
for k in range(0, num_comp):
axt = ax[0, k]
for l in range(0, Nstd):
axt.plot(time, q_pca[0:M, l, k], color=CBcdict[cl[l]])
axt.hold(True)
axt.set_title('q domain: PD %d' % (k + 1))
plot.rstyle(axt)
axt = ax[1, k]
for l in range(0, Nstd):
axt.plot(time, f_pca[:, l, k], color=CBcdict[cl[l]])
axt.hold(True)
axt.set_title('f domain: PD %d' % (k + 1))
plot.rstyle(axt)
fig.set_tight_layout(True)
cumm_coef = 100 * np.cumsum(s) / sum(s)
idx = np.arange(0, M + 1) + 1
plot.f_plot(idx, cumm_coef, "Coefficient Cumulative Percentage")
plt.xlabel("Percentage")
plt.ylabel("Index")
plt.show()
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mean_fn = fn.mean(axis=1)
std_fn = fn.std(axis=1)
tmp = np.zeros(M)
tmp[1:] = cumtrapz(mqn * np.abs(mqn), time)
fmean = np.mean(f0[1, :]) + tmp
fgam = np.zeros((M, N))
for k in range(0, N):
time0 = (time[-1] - time[0]) * gamf[:, k] + time[0]
fgam[:, k] = np.interp(time0, time, fmean)
var_fgam = fgam.var(axis=1)
orig_var = trapz(std_f0 ** 2, time)
amp_var = trapz(std_fn ** 2, time)
phase_var = trapz(var_fgam, time)
K = np.cov(fn)
U, s, V = svd(K)
align_fPCAresults = collections.namedtuple('align_fPCA', ['fn', 'qn',
'q0', 'mqn', 'gam', 'q_pca',
'f_pca', 'latent', 'coef',
'U', 'orig_var', 'amp_var',
'phase_var', 'cost'])
out = align_fPCAresults(fn, qn, q0, mqn, gamf, q_pca, f_pca, s, c,
U, orig_var, amp_var, phase_var, cost)
return out
def srsf_align(f, time, method="mean", showplot=True, smoothdata=False,
lam=0.0):
"""
This function aligns a collection of functions using the elastic
square-root slope (srsf) framework.
:param f: numpy ndarray of shape (M,N) of N functions with M samples
:param time: vector of size M describing the sample points
:param method: (string) warp calculate Karcher Mean or Median
(options = "mean" or "median") (default="mean")
:param showplot: Shows plots of results using matplotlib (default = T)
:param smoothdata: Smooth the data using a box filter (default = F)
:param lam: controls the elasticity (default = 0)
:type lam: double
:type smoothdata: bool
:type f: np.ndarray
:type time: np.ndarray
:rtype: tuple of numpy array
:return fn: aligned functions - numpy ndarray of shape (M,N) of N
functions with M samples
:return qn: aligned srvfs - similar structure to fn
:return q0: original srvf - similar structure to fn
:return fmean: function mean or median - vector of length M
:return mqn: srvf mean or median - vector of length M
:return gam: warping functions - similar structure to fn
:return orig_var: Original Variance of Functions
:return amp_var: Amplitude Variance
:return phase_var: Phase Variance
Examples
>>> import tables
>>> fun=tables.open_file("../Data/simu_data.h5")
>>> f = fun.root.f[:]
>>> f = f.transpose()
>>> time = fun.root.time[:]
>>> out = srsf_align(f,time)
"""
M = f.shape[0]
N = f.shape[1]
if M > 500:
parallel = True
elif N > 100:
parallel = True
else:
parallel = False
eps = np.finfo(np.double).eps
f0 = f
methods = ["mean", "median"]
# 0 mean, 1-median
method = [i for i, x in enumerate(methods) if x == method]
if len(method) == 0:
method = 0
else:
method = method[0]
if showplot:
plot.f_plot(time, f, title="f Original Data")
# Compute SRSF function from data
f, g, g2 = uf.gradient_spline(time, f, smoothdata)
q = g / np.sqrt(abs(g) + eps)
print("Initializing...")
mnq = q.mean(axis=1)
a = mnq.repeat(N)
d1 = a.reshape(M, N)
d = (q - d1) ** 2
dqq = np.sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
mq = q[:, min_ind]
mf = f[:, min_ind]
if parallel:
out = Parallel(n_jobs=-1)(delayed(uf.optimum_reparam)(mq, time,
q[:, n], lam) for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = uf.optimum_reparam(mq, time, q, lam)
gamI = uf.SqrtMeanInverse(gam)
mf = np.interp((time[-1] - time[0]) * gamI + time[0], time, mf)
mq = uf.f_to_srsf(mf, time)
# Compute Karcher Mean
if method == 0:
print("Compute Karcher Mean of %d function in SRSF space..." % N)
if method == 1:
print("Compute Karcher Median of %d function in SRSF space..." % N)
MaxItr = 20
ds = np.repeat(0.0, MaxItr + 2)
ds[0] = np.inf
qun = np.repeat(0.0, MaxItr + 1)
tmp = np.zeros((M, MaxItr + 2))
tmp[:, 0] = mq
mq = tmp
tmp = np.zeros((M, N, MaxItr + 2))
tmp[:, :, 0] = f
f = tmp
tmp = np.zeros((M, N, MaxItr + 2))
tmp[:, :, 0] = q
q = tmp
for r in range(0, MaxItr):
print("updating step: r=%d" % (r + 1))
if r == (MaxItr - 1):
print("maximal number of iterations is reached")
# Matching Step
if parallel:
out = Parallel(n_jobs=-1)(delayed(uf.optimum_reparam)(mq[:, r],
time, q[:, n, 0], lam) for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = uf.optimum_reparam(mq[:, r], time, q[:, :, 0], lam)
gam_dev = np.zeros((M, N))
for k in range(0, N):
f[:, k, r + 1] = np.interp((time[-1] - time[0]) * gam[:, k]
+ time[0], time, f[:, k, 0])
q[:, k, r + 1] = uf.f_to_srsf(f[:, k, r + 1], time)
gam_dev[:, k] = np.gradient(gam[:, k], 1 / float(M - 1))
mqt = mq[:, r]
a = mqt.repeat(N)
d1 = a.reshape(M, N)
d = (q[:, :, r + 1] - d1) ** 2
if method == 0:
d1 = sum(trapz(d, time, axis=0))
d2 = sum(trapz((1 - np.sqrt(gam_dev)) ** 2, time, axis=0))
ds_tmp = d1 + lam * d2
ds[r + 1] = ds_tmp
# Minimization Step
# compute the mean of the matched function
qtemp = q[:, :, r + 1]
mq[:, r + 1] = qtemp.mean(axis=1)
qun[r] = norm(mq[:, r + 1] - mq[:, r]) / norm(mq[:, r])
if method == 1:
d1 = np.sqrt(sum(trapz(d, time, axis=0)))
d2 = sum(trapz((1 - np.sqrt(gam_dev)) ** 2, time, axis=0))
ds_tmp = d1 + lam * d2
ds[r + 1] = ds_tmp
# Minimization Step
# compute the mean of the matched function
dist_iinv = ds[r + 1] ** (-1)
qtemp = q[:, :, r + 1] / ds[r + 1]
mq[:, r + 1] = qtemp.sum(axis=1) * dist_iinv
qun[r] = norm(mq[:, r + 1] - mq[:, r]) / norm(mq[:, r])
if qun[r] < 1e-2 or r >= MaxItr:
break
# Last Step with centering of gam
r += 1
if parallel:
out = Parallel(n_jobs=-1)(delayed(uf.optimum_reparam)(mq[:, r], time, q[:, n, 0], lam) for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = uf.optimum_reparam(mq[:, r], time, q[:, :, 0], lam)
gam_dev = np.zeros((M, N))
for k in range(0, N):
gam_dev[:, k] = np.gradient(gam[:, k], 1 / float(M - 1))
gamI = uf.SqrtMeanInverse(gam)
gamI_dev = np.gradient(gamI, 1 / float(M - 1))
time0 = (time[-1] - time[0]) * gamI + time[0]
mq[:, r + 1] = np.interp(time0, time, mq[:, r]) * np.sqrt(gamI_dev)
for k in range(0, N):
q[:, k, r + 1] = np.interp(time0, time, q[:, k, r]) * np.sqrt(gamI_dev)
f[:, k, r + 1] = np.interp(time0, time, f[:, k, r])
gam[:, k] = np.interp(time0, time, gam[:, k])
# Aligned data & stats
fn = f[:, :, r + 1]
qn = q[:, :, r + 1]
q0 = q[:, :, 0]
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mean_fn = fn.mean(axis=1)
std_fn = fn.std(axis=1)
mqn = mq[:, r + 1]
tmp = np.zeros((1, M))
tmp = tmp.flatten()
tmp[1:] = cumtrapz(mqn * np.abs(mqn), time)
fmean = np.mean(f0[1, :]) + tmp
fgam = np.zeros((M, N))
for k in range(0, N):
time0 = (time[-1] - time[0]) * gam[:, k] + time[0]
fgam[:, k] = np.interp(time0, time, fmean)
var_fgam = fgam.var(axis=1)
orig_var = trapz(std_f0 ** 2, time)
amp_var = trapz(std_fn ** 2, time)
phase_var = trapz(var_fgam, time)
if showplot:
fig, ax = plot.f_plot(np.arange(0, M) / float(M - 1), gam,
title="Warping Functions")
ax.set_aspect('equal')
plot.f_plot(time, fn, title="Warped Data")
tmp = np.array([mean_f0, mean_f0 + std_f0, mean_f0 - std_f0])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title="Original Data: Mean $\pm$ STD")
tmp = np.array([mean_fn, mean_fn + std_fn, mean_fn - std_fn])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title="Warped Data: Mean $\pm$ STD")
plot.f_plot(time, fmean, title="$f_{mean}$")
plt.show()
align_results = collections.namedtuple('align', ['fn', 'qn', 'q0', 'fmean',
'mqn', 'gam', 'orig_var',
'amp_var', 'phase_var'])
out = align_results(fn, qn, q0, fmean, mqn, gam, orig_var, amp_var,
phase_var)
return out
def srsf_align(f, time, method="mean", showplot=True, smoothdata=False,
lam=0.0):
"""
This function aligns a collection of functions using the elastic
square-root slope (srsf) framework.
:param f: numpy ndarray of shape (M,N) of N functions with M samples
:param time: vector of size M describing the sample points
:param method: (string) warp calculate Karcher Mean or Median
(options = "mean" or "median") (default="mean")
:param showplot: Shows plots of results using matplotlib (default = T)
:param smoothdata: Smooth the data using a box filter (default = F)
:param lam: controls the elasticity (default = 0)
:type lam: double
:type smoothdata: bool
:type f: np.ndarray
:type time: np.ndarray
:rtype: tuple of numpy array
:return fn: aligned functions - numpy ndarray of shape (M,N) of N
functions with M samples
:return qn: aligned srvfs - similar structure to fn
:return q0: original srvf - similar structure to fn
:return fmean: function mean or median - vector of length M
:return mqn: srvf mean or median - vector of length M
:return gam: warping functions - similar structure to fn
:return orig_var: Original Variance of Functions
:return amp_var: Amplitude Variance
:return phase_var: Phase Variance
Examples
>>> import tables
>>> fun=tables.open_file("../Data/simu_data.h5")
>>> f = fun.root.f[:]
>>> f = f.transpose()
>>> time = fun.root.time[:]
>>> out = srsf_align(f,time)
"""
M = f.shape[0]
N = f.shape[1]
if M > 500:
parallel = True
elif N > 100:
parallel = True
else:
parallel = False
eps = np.finfo(np.double).eps
f0 = f
methods = ["mean", "median"]
# 0 mean, 1-median
method = [i for i, x in enumerate(methods) if x == method]
if len(method) == 0:
method = 0
else:
method = method[0]
if showplot:
plot.f_plot(time, f, title="f Original Data")
# Compute SRSF function from data
f, g, g2 = uf.gradient_spline(time, f, smoothdata)
q = g / np.sqrt(abs(g) + eps)
print("Initializing...")
mnq = q.mean(axis=1)
a = mnq.repeat(N)
d1 = a.reshape(M, N)
d = (q - d1) ** 2
dqq = np.sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
mq = q[:, min_ind]
mf = f[:, min_ind]
if parallel:
out = Parallel(n_jobs=-1)(delayed(uf.optimum_reparam)(mq, time,
q[:, n], lam) for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = uf.optimum_reparam(mq, time, q, lam)
gamI = uf.SqrtMeanInverse(gam)
mf = np.interp((time[-1] - time[0]) * gamI + time[0], time, mf)
mq = uf.f_to_srsf(mf, time)
# Compute Karcher Mean
if method == 0:
print("Compute Karcher Mean of %d function in SRSF space..." % N)
if method == 1:
print("Compute Karcher Median of %d function in SRSF space..." % N)
MaxItr = 20
ds = np.repeat(0.0, MaxItr + 2)
ds[0] = np.inf
qun = np.repeat(0.0, MaxItr + 1)
tmp = np.zeros((M, MaxItr + 2))
tmp[:, 0] = mq
mq = tmp
tmp = np.zeros((M, N, MaxItr + 2))
tmp[:, :, 0] = f
f = tmp
tmp = np.zeros((M, N, MaxItr + 2))
tmp[:, :, 0] = q
q = tmp
for r in range(0, MaxItr):
print("updating step: r=%d" % (r + 1))
if r == (MaxItr - 1):
print("maximal number of iterations is reached")
# Matching Step
if parallel:
out = Parallel(n_jobs=-1)(delayed(uf.optimum_reparam)(mq[:, r],
time, q[:, n, 0], lam) for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = uf.optimum_reparam(mq[:, r], time, q[:, :, 0], lam)
gam_dev = np.zeros((M, N))
for k in range(0, N):
f[:, k, r + 1] = np.interp((time[-1] - time[0]) * gam[:, k]
+ time[0], time, f[:, k, 0])
q[:, k, r + 1] = uf.f_to_srsf(f[:, k, r + 1], time)
gam_dev[:, k] = np.gradient(gam[:, k], 1 / float(M - 1))
mqt = mq[:, r]
a = mqt.repeat(N)
d1 = a.reshape(M, N)
d = (q[:, :, r + 1] - d1) ** 2
if method == 0:
d1 = sum(trapz(d, time, axis=0))
d2 = sum(trapz((1 - np.sqrt(gam_dev)) ** 2, time, axis=0))
ds_tmp = d1 + lam * d2
ds[r + 1] = ds_tmp
# Minimization Step
# compute the mean of the matched function
qtemp = q[:, :, r + 1]
mq[:, r + 1] = qtemp.mean(axis=1)
qun[r] = norm(mq[:, r + 1] - mq[:, r]) / norm(mq[:, r])
if method == 1:
d1 = np.sqrt(sum(trapz(d, time, axis=0)))
d2 = sum(trapz((1 - np.sqrt(gam_dev)) ** 2, time, axis=0))
ds_tmp = d1 + lam * d2
ds[r + 1] = ds_tmp
# Minimization Step
# compute the mean of the matched function
dist_iinv = ds[r + 1] ** (-1)
qtemp = q[:, :, r + 1] / ds[r + 1]
mq[:, r + 1] = qtemp.sum(axis=1) * dist_iinv
qun[r] = norm(mq[:, r + 1] - mq[:, r]) / norm(mq[:, r])
if qun[r] < 1e-2 or r >= MaxItr:
break
# Last Step with centering of gam
r += 1
if parallel:
out = Parallel(n_jobs=-1)(delayed(uf.optimum_reparam)(mq[:, r], time, q[:, n, 0], lam) for n in range(N))
gam = np.array(out)
gam = gam.transpose()
else:
gam = uf.optimum_reparam(mq[:, r], time, q[:, :, 0], lam)
gam_dev = np.zeros((M, N))
for k in range(0, N):
gam_dev[:, k] = np.gradient(gam[:, k], 1 / float(M - 1))
gamI = uf.SqrtMeanInverse(gam)
gamI_dev = np.gradient(gamI, 1 / float(M - 1))
time0 = (time[-1] - time[0]) * gamI + time[0]
mq[:, r + 1] = np.interp(time0, time, mq[:, r]) * np.sqrt(gamI_dev)
for k in range(0, N):
q[:, k, r + 1] = np.interp(time0, time, q[:, k, r]) * np.sqrt(gamI_dev)
f[:, k, r + 1] = np.interp(time0, time, f[:, k, r])
gam[:, k] = np.interp(time0, time, gam[:, k])
# Aligned data & stats
fn = f[:, :, r + 1]
qn = q[:, :, r + 1]
q0 = q[:, :, 0]
mean_f0 = f0.mean(axis=1)
std_f0 = f0.std(axis=1)
mean_fn = fn.mean(axis=1)
std_fn = fn.std(axis=1)
mqn = mq[:, r + 1]
tmp = np.zeros((1, M))
tmp = tmp.flatten()
tmp[1:] = cumtrapz(mqn * np.abs(mqn), time)
fmean = np.mean(f0[1, :]) + tmp
fgam = np.zeros((M, N))
for k in range(0, N):
time0 = (time[-1] - time[0]) * gam[:, k] + time[0]
fgam[:, k] = np.interp(time0, time, fmean)
var_fgam = fgam.var(axis=1)
orig_var = trapz(std_f0 ** 2, time)
amp_var = trapz(std_fn ** 2, time)
phase_var = trapz(var_fgam, time)
if showplot:
fig, ax = plot.f_plot(np.arange(0, M) / float(M - 1), gam,
title="Warping Functions")
ax.set_aspect('equal')
plot.f_plot(time, fn, title="Warped Data")
tmp = np.array([mean_f0, mean_f0 + std_f0, mean_f0 - std_f0])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title="Original Data: Mean $\pm$ STD")
tmp = np.array([mean_fn, mean_fn + std_fn, mean_fn - std_fn])
tmp = tmp.transpose()
plot.f_plot(time, tmp, title="Warped Data: Mean $\pm$ STD")
plot.f_plot(time, fmean, title="$f_{mean}$")
plt.show()
align_results = collections.namedtuple('align', ['fn', 'qn', 'q0', 'fmean',
'mqn', 'gam', 'orig_var',
'amp_var', 'phase_var'])
out = align_results(fn, qn, q0, fmean, mqn, gam, orig_var, amp_var,
phase_var)
return out
def predict(self, newdata=None):
"""
This function performs prediction on regression model on new data if available or current stored data in object
Usage: obj.predict()
obj.predict(newdata)
:param newdata: dict containing new data for prediction (needs the keys below, if None predicts on training data)
:type newdata: dict
:param f: (M,N) matrix of functions
:param time: vector of time points
:param y: truth if available
:param smooth: smooth data if needed
:param sparam: number of times to run filter
"""
omethod = self.warp_data.method
lam = self.warp_data.lam
M = self.time.shape[0]
if newdata != None:
f = newdata['f']
time = newdata['time']
y = newdata['y']
if newdata['smooth']:
sparam = newdata['sparam']
f = fs.smooth_data(f,sparam)
q1 = fs.f_to_srsf(f,time)
n = q1.shape[1]
self.y_pred = np.zeros(n)
mq = self.warp_data.mqn
fn = np.zeros((M,n))
qn = np.zeros((M,n))
gam = np.zeros((M,n))
for ii in range(0,n):
gam[:,ii] = uf.optimum_reparam(mq,time,q1[:,ii],omethod,lam)
fn[:,ii] = uf.warp_f_gamma(time,f[:,ii],gam[:,ii])
qn[:,ii] = uf.f_to_srsf(fn[:,ii],time)
U = self.pca.U
no = U.shape[1]
if self.pca.__class__.__name__ == 'fdajpca':
m_new = np.sign(fn[self.pca.id,:])*np.sqrt(np.abs(fn[self.pca.id,:]))
qn1 = np.vstack((qn, m_new))
C = self.pca.C
TT = self.time.shape[0]
mu_g = self.pca.mu_g
mu_psi = self.pca.mu_psi
vec = np.zeros((M,n))
psi = np.zeros((TT,n))
binsize = np.mean(np.diff(self.time))
for i in range(0,n):
psi[:,i] = np.sqrt(np.gradient(gam[:,i],binsize))
out, theta = geo.inv_exp_map(mu_psi, psi[:,i])
vec[:,i] = out
g = np.vstack((qn1, C*vec))
a = np.zeros((n,no))
for i in range(0,n):
for j in range(0,no):
tmp = (g[:,i]-mu_g)
a[i,j] = np.dot(tmp.T, U[:,j])
elif self.pca.__class__.__name__ == 'fdavpca':
m_new = np.sign(fn[self.pca.id,:])*np.sqrt(np.abs(fn[self.pca.id,:]))
qn1 = np.vstack((qn, m_new))
a = np.zeros((n,no))
for i in range(0,n):
for j in range(0,no):
tmp = (qn1[:,i]-self.pca.mqn)
a[i,j] = np.dot(tmp.T, U[:,j])
elif self.pca.__class__.__name__ == 'fdahpca':
a = np.zeros((n,no))
mu_psi = self.pca.psi_mu
vec = np.zeros((M,n))
TT = self.time.shape[0]
psi = np.zeros((TT,n))
binsize = np.mean(np.diff(self.time))
for i in range(0,n):
psi[:,i] = np.sqrt(np.gradient(gam[:,i],binsize))
out, theta = geo.inv_exp_map(mu_psi, psi[:,i])
vec[:,i] = out
vm = self.pca.vec.mean(axis=1)
for i in range(0,n):
for j in range(0,no):
a[i,j] = np.sum(np.dot(vec[:,i]-vm,U[:,j]))
else:
raise Exception('Invalid fPCA Method')
for ii in range(0,n):
self.y_pred[ii] = self.alpha + np.dot(a[ii,:],self.b)
if y is None:
self.SSE = np.nan
else:
self.SSE = np.sum((y-self.y_pred)**2)
else:
n = self.pca.coef.shape[0]
self.y_pred = np.zeros(n)
for ii in range(0,n):
self.y_pred[ii] = self.alpha + np.dot(self.pca.coef[ii,:],self.b)
self.SSE = np.sum((self.y-self.y_pred)**2)
return
