def train(self, X_train, y_train):
distinct_labels = np.array(list(distinct_labels))
label_means = []
sds = []
label_variances = []
for l in distinct_labels:
Xl = [x for x, y in zip(X_train, y_train) if y == l] # examples labeled l
mean_l = np.mean(Xl, axis=0)
label_means.append(mean_l)
# Compute S.D. for each examples of each label
s_l = np.std([norm2(x - mean_l) for x in Xl])
label_variances.append(s_l)
# Check how far away means are from each other.
for i, mi in enumerate(label_means):
d2i = [(j, norm2(mi - mj)) for j, mj in enumerate(label_means) if i!=j]
j, dij = min(d2i, key=itemgetter(1))
si, sj = np.sqrt(label_variances[i]), np.sqrt(label_variances[j])
print("label {} :: nearest label = {} :: dist = {}) :: "
"sd_{} = {} :: sd_{} = {}"
"".format(i, j, dij, i, si, j, sj))
self.means = np.array(label_means)
self.sds = np.sqrt(np.array(label_variances))
self.ordered_labels = distinct_labels
def set_corrected_dofs_helper_imp_sampling(self, node, transform,
noise_std):
transform_new = dc(transform)
node.corrected_transform = transform_new
# node.corrected_position = node.corrected_transform.dot(vec3tovec4(node.offset))
if (node.name == "End Site"):
return
threshold = 10
while True:
length = norm2(node.children[0].offset)
transform_new = dc(
node.corrected_transform.dot(translation(node.offset)))
if (len(node.dof_values) != 6):
node.corrected_dof_values = np.random.normal(
node.dof_values, np.rad2deg(noise_std / length))
else:
node.corrected_dof_values = node.dof_values[:]
for i in range(len(node.dofs)):
dof = node.dofs[i]
dof_val = node.corrected_dof_values[i]
if (dof == "Xposition"):
trans = translation((dof_val, 0, 0))
transform_new = transform_new.dot(trans)
elif (dof == "Yposition"):
trans = translation((0, dof_val, 0))
transform_new = transform_new.dot(trans)
elif (dof == "Zposition"):
trans = translation((0, 0, dof_val))
transform_new = transform_new.dot(trans)
elif (dof == "Xrotation"):
rot = rotation_x(dof_val)
transform_new = transform_new.dot(rot)
elif (dof == "Yrotation"):
rot = rotation_y(dof_val)
transform_new = transform_new.dot(rot)
elif (dof == "Zrotation"):
rot = rotation_z(dof_val)
transform_new = transform_new.dot(rot)
break_signal = True
for child in node.children:
if (not norm2(
vec4tovec3(transform_new.dot(vec3tovec4(child.offset)))
- child.corrected_position) < threshold):
break_signal = False
else:
print(child.name)
print(
vec4tovec3(transform_new.dot(vec3tovec4(
child.offset))))
print(child.corrected_position)
if (break_signal):
break
for child in node.children:
self.set_corrected_dofs_helper(child, dc(transform_new), noise_std)
def taylor(self, uv):
# convention: fprime[i, k] = df_i / dx_k
f = empty((3, 3))
fprime = empty((3, 3, 2, 3))
lu = norm2(uv[0])
# lv = norm2 (uv[1])
# Orthogonal to UV plane, this will be zero-vector if uv[0] ||
# uv[1] as e.g. derived from the three points on the line:
w = cross(uv[1], uv[0])
lw = norm2(w)
# u and v are probably collinear:
if (lw == 0.0):
raise ZeroDivisionError()
#
# Unit vectors for local coordiante system:
#
# unit vector in U-direciton:
f[2, :] = uv[0] / lu
# unit vector orthogonal to UV-plane:
f[1, :] = w / lw
# in UV-plane, orthogonal to U:
f[0, :] = cross(f[2, :], f[1, :]) # FIXME: not cross(j, k)!
# dk/du:
fprime[2, :, 0, :] = _M(f[2, :]) / lu
# dk/dv:
fprime[2, :, 1, :] = 0.0 # zeros((3,3))
# dj/dw
jw = _M(f[1, :]) / lw
# dj/du:
fprime[1, :, 1, :] = dot(jw, E(uv[0]))
# dj/dv:
fprime[1, :, 0, :] = dot(jw, E(-uv[1]))
# di/du = di/dk * dk/du + di/dj * dj/du:
fprime[0, :, 0, :] = dot (E ( f[1, :]), fprime[2, :, 0, :]) \
+ dot (E (-f[2, :]), fprime[1, :, 0, :])
# di/du = di/dj * dj/du:
fprime[0, :, 1, :] = dot(E(-f[2, :]), fprime[1, :, 1, :])
return f, fprime
def taylor (self, uv):
# convention: fprime[i, k] = df_i / dx_k
f = empty ((3, 3))
fprime = empty ((3, 3, 2, 3))
lu = norm2 (uv[0])
# lv = norm2 (uv[1])
# Orthogonal to UV plane, this will be zero-vector if uv[0] ||
# uv[1] as e.g. derived from the three points on the line:
w = cross (uv[1], uv[0])
lw = norm2 (w)
# u and v are probably collinear:
if (lw == 0.0):
raise ZeroDivisionError ()
#
# Unit vectors for local coordiante system:
#
# unit vector in U-direciton:
f[2, :] = uv[0] / lu
# unit vector orthogonal to UV-plane:
f[1, :] = w / lw
# in UV-plane, orthogonal to U:
f[0, :] = cross (f[2, :], f[1, :]) # FIXME: not cross(j, k)!
# dk/du:
fprime[2, :, 0, :] = _M (f[2, :]) / lu
# dk/dv:
fprime[2, :, 1, :] = 0.0 # zeros((3,3))
# dj/dw
jw = _M(f[1, :]) / lw
# dj/du:
fprime[1, :, 1, :] = dot (jw, E (uv[0]))
# dj/dv:
fprime[1, :, 0, :] = dot (jw, E (-uv[1]))
# di/du = di/dk * dk/du + di/dj * dj/du:
fprime[0, :, 0, :] = dot (E ( f[1, :]), fprime[2, :, 0, :]) \
+ dot (E (-f[2, :]), fprime[1, :, 0, :])
# di/du = di/dj * dj/du:
fprime[0, :, 1, :] = dot (E(-f[2, :]), fprime[1, :, 1, :])
return f, fprime
def set_corrected_position_helper(self, node):
# if(not (node.name=="ROOT hip" or node.name=="JOINT abdomen")):
if (not (node.depth == 0 or node.depth == 1)):
diff = np.array(node.noised_position) - np.array(
node.parent.corrected_position)
lengthratio = norm2(diff) / norm2(node.offset)
diff = diff / lengthratio
diff = diff + np.array(node.parent.corrected_position)
node.corrected_position = diff.tolist()
else:
node.corrected_position = node.position[:3]
for child in node.children:
self.set_corrected_position_helper(child)
def getPerps(self, offset):
if (mod(offset[0]) < 0.0001 and mod(offset[1]) < 0.0001):
v1 = [offset[2], 0, 0]
elif (mod(offset[0]) > mod(offset[1])):
v1 = [-offset[1] / offset[0], 1, 0]
else:
v1 = [1, -offset[0] / offset[1], 0]
v0 = np.array(offset)
normv0 = norm2(v0)
v0 = v0 / normv0
v1 = np.array(v1)
normv1 = norm2(v1)
v1 = v1 / normv1
v2 = np.cross(v0, v1)
v0 = v0 * normv0
v1 = v1 * normv0
v2 = v2 * normv0
return [v1.tolist(), v2.tolist()]
def rotm2eul(self, rotm):
x = np.arcsin(rotm[2, 1])
x = [x]
if (x[-1] > 0):
x.append(x[-1] - np.pi)
else:
x.append(x[-1] + np.pi)
# print(x)
y = []
for X in x:
y.append(np.arcsin(-rotm[2, 0] / np.cos(X)))
if (y[-1] > 0):
y.append(y[-1] - np.pi)
else:
y.append(y[-1] + np.pi)
z = []
for X in x:
val = rotm[1, 1] / np.cos(X)
if (val > 1):
val = 0.99999999999999999999
if (val < -1):
val = -0.99999999999999999999
z.append(np.arccos(val))
z.append(-np.arccos(val))
xyz = []
for Y in y:
for Z in z:
for X in x:
mat = rotation_z(np.rad2deg(Z)).dot(
rotation_x(np.rad2deg(X)).dot(rotation_y(
np.rad2deg(Y))))[:3, :3]
if (norm2(mat - rotm) < 0.0001):
xyz.append(
(np.rad2deg(X), np.rad2deg(Y), np.rad2deg(Z)))
return xyz[0]
def predict(X):
pred_indices = np.argmin([norm2(X - m, axis=1) for m in self.means], axis=0)
return ordered_labels[pred_indices]
def unit(v):
"Normalize a vector"
n = norm2(v)
# numpy will just return NaNs:
if n == 0.0: raise Exception("divide by zero")
return v / n
def unit(v):
"Normalize a vector"
n = norm2 (v)
# numpy will just return NaNs:
if n == 0.0: raise Exception("divide by zero")
return v / n
Q = 1.0 + sp.zeros((brain.faces.shape[0], 1))
Q = (1.0 / 3.0) * Tri * Q
Q = Q[:, 0]
br_face_area = face_areas(brain)
Q = 1.0 + sp.zeros(brain.vertices.shape[0])
# Q=0.0*Q
# Q[1800]=1
# Q=smooth_surf_function(brain,Q,10,10)
area_v = (1.0 / 3.0) * Tri * br_face_area
v = sp.zeros(skull.vertices.shape[0]) # eq 8 from Sarvas
v_aaj = sp.zeros(skull.vertices.shape[0]) # joshi
view_patch(brain, attrib=Q, opacity=1)
for i in range(skull.vertices.shape[0]):
r0 = brain.vertices
r_r0 = skull.vertices[i, ] - r0
norm_r_r0 = norm2(r_r0, ord=2, axis=1)
den = norm_r_r0**3.0
num = r_r0
v1 = num / sp.expand_dims(den, axis=1)
Qvec = sp.expand_dims(Q, axis=1) * brain.normals
v1_aaj = (2.0 * m) / norm_r_r0
v1 = sp.sum(v1 * Qvec, axis=1)
# v1_aaj=v1_aaj*sp.sign(v1)
v[i] = sp.sum(v1 * area_v)
v_aaj[i] = sp.sum(Q * v1_aaj * area_v)
if sp.mod(i, 100) == 0:
print 'i=' + str(i)
# In[15]:
view_patch(skull, attrib=v, show=1)
def calc_err_norm2(sum_stat, sumstat_true):
return norm2(sum_stat - sumstat_true)
def set_corrected_dofs_helper_fixedy(self, node, transform):
transform_new = dc(transform)
node.corrected_transform = transform_new
# node.corrected_position = node.corrected_transform.dot(vec3tovec4(node.offset))
transform_new = dc(
node.corrected_transform.dot(translation(node.offset)))
if (node.name == "End Site"):
node.corrected_dof_values = []
return
if (node.depth == 0):
# if(True):
inter_transform = np.identity(4)
for i in range(len(node.dofs)):
dof = node.dofs[i]
dof_val = node.dof_values[i]
rot = np.identity(4)
if (dof == "Xposition"):
rot = translation((dof_val, 0, 0))
elif (dof == "Yposition"):
rot = translation((0, dof_val, 0))
elif (dof == "Zposition"):
rot = translation((0, 0, dof_val))
elif (dof == "Xrotation"):
rot = rotation_x(dof_val)
elif (dof == "Yrotation"):
rot = rotation_y(dof_val)
elif (dof == "Zrotation"):
rot = rotation_z(dof_val)
inter_transform = inter_transform.dot(rot)
# transform_new = transform_new.dot(rot)
transform_new = transform_new.dot(inter_transform)
node.corrected_dof_values = node.dof_values[:]
node.noised_position = node.position[:3]
node.corrected_position = node.noised_position[:]
for child in node.children:
child.noised_position = child.position[:3]
child.corrected_position = child.noised_position[:]
# print(inter_transform)
# transform_new2 = transform_new
# print(inter_transform)
# print("inter_transform",inter_transform)
# if(True):
else:
TA = np.empty((len(node.children), 3))
i = 0
for child in node.children:
vec = vec4tovec3(
np.linalg.inv(transform_new).dot(
vec3tovec4(child.corrected_position)))
vec = vec / np.linalg.norm(vec)
rot = np.array(child.offset)
rot = rot / np.linalg.norm(rot)
ta, ret_val = find_transform(rot, vec, node.dof_values[-1],
node.dof_values)
if (ret_val == -1):
child.noised_position = child.position[:3]
diff = np.array(child.noised_position) - np.array(
node.corrected_position)
lengthratio = norm2(diff) / norm2(child.offset)
diff = diff / lengthratio
diff = diff + np.array(node.corrected_position)
child.corrected_position = diff.tolist()
TA[i, :] = np.array([ta[0], ta[1], ta[2]])
i += 1
ta = np.mean(TA, axis=0)
trans = rotation_z(ta[0]).dot(rotation_x(ta[1])).dot(
rotation_y(ta[2]))
transform_new = transform_new.dot(trans)
node.corrected_dof_values = [ta[0], ta[1], ta[2]]
for child in node.children:
self.set_corrected_dofs_helper(child, dc(transform_new))
def stationcharacteristics(xsensors_m, lisaz_deg):
M = size(xsensors_m,0)
combi = M*(M-1)/2;
rangecombi=range(combi)
regresscombi = array([ones(combi), rangecombi]);
HtH_d = dot(regresscombi,regresscombi.transpose());
HtHm1Ht = dot(inv(HtH_d),regresscombi);
z = xsensors_m[:,0:2]
HtH = M*dot(z.transpose(),z)
eigHtH = eigh(HtH)
RR=eigHtH[0][1] / eigHtH[0][0]
HtHproduct = eigHtH[0][1] * eigHtH[0][0]
areaCov = 1.0 / HtHproduct
distance=zeros(combi)
orient=zeros(combi)
cp=0;
for im1 in range(M-1):
for im2 in range(im1+1,M):
distance[cp]=norm2(z[im1,:]-z[im2,:]);
diffz = z[im1,:]+1j*z[im2,:]
orient[cp]=angle(diffz[0]+1j*diffz[1]);
cp=cp+1;
dmin = min(distance)
dmax = max(distance)
dsort = sort(distance)
diffsort_d = diff(dsort)
dispersionratio_d = std(diffsort_d)/mean(diffsort_d)
alpha_d = dot(HtHm1Ht,dsort)
residu_d = dsort-dot(regresscombi.transpose(),alpha_d)
SSE_d = dot(residu_d,residu_d)
SST_d = norm2(dsort-mean(dsort))**2;
SSR_d=SST_d-SSE_d;
R2_d = SSR_d/SST_d;
osort = sort(orient)
diffsort_o = diff(osort)
dispersionratio_o = std(diffsort_o)/mean(diffsort_o)
alpha_o = dot(HtHm1Ht,osort)
residu_o = osort-dot(regresscombi.transpose(),alpha_o)
SSE_o = dot(residu_o,residu_o)
SST_o = norm2(osort-mean(osort))**2;
SSR_o=SST_o-SSE_o;
R2_o = SSR_o/SST_o;
histd=histogram(distance, bins=combi);
histdnorm = histd[0]/float(combi);
Hentropy_d = 0;
for ic in range(combi):
if not(histdnorm[ic]==0):
Hentropy_d = Hentropy_d-histdnorm[ic]*log2(histdnorm[ic]);
histo=histogram(orient, bins=combi);
histonorm = histo[0]/float(combi);
Hentropy_o = 0;
for ic in range(combi):
if not(histonorm[ic]==0):
Hentropy_o = Hentropy_o-histonorm[ic]*log2(histonorm[ic]);
HtH3d = dot(xsensors_m.transpose(),xsensors_m)
invHtH3d = inv(HtH3d)
La = len(lisaz_deg)
STDCRBaz_deg = zeros(La);
for ia in range(La):
aec = struct(a_deg=lisaz_deg[ia],e_deg=45.0,c_mps=340);
Jacobaec = jacobian3D(z, aec);
invJacobaec = inv(Jacobaec);
aux = dot(dot(invJacobaec,invHtH3d),\
invJacobaec.transpose());
STDCRBaz_deg[ia] = sqrt(aux[0,0])*180.0/pi;
return RR, areaCov, R2_d, R2_o, dmin, dmax, distance, \
orient, Hentropy_d, Hentropy_o, dispersionratio_d, \
dispersionratio_o, STDCRBaz_deg
def stationcharacteristics(xsensors_m, lisaz_deg):
M = size(xsensors_m, 0)
combi = M * (M - 1) / 2
rangecombi = range(combi)
regresscombi = array([ones(combi), rangecombi])
HtH_d = dot(regresscombi, regresscombi.transpose())
HtHm1Ht = dot(inv(HtH_d), regresscombi)
z = xsensors_m[:, 0:2]
HtH = M * dot(z.transpose(), z)
eigHtH = eigh(HtH)
RR = eigHtH[0][1] / eigHtH[0][0]
HtHproduct = eigHtH[0][1] * eigHtH[0][0]
areaCov = 1.0 / HtHproduct
distance = zeros(combi)
orient = zeros(combi)
cp = 0
for im1 in range(M - 1):
for im2 in range(im1 + 1, M):
distance[cp] = norm2(z[im1, :] - z[im2, :])
diffz = z[im1, :] + 1j * z[im2, :]
orient[cp] = angle(diffz[0] + 1j * diffz[1])
cp = cp + 1
dmin = min(distance)
dmax = max(distance)
dsort = sort(distance)
diffsort_d = diff(dsort)
dispersionratio_d = std(diffsort_d) / mean(diffsort_d)
alpha_d = dot(HtHm1Ht, dsort)
residu_d = dsort - dot(regresscombi.transpose(), alpha_d)
SSE_d = dot(residu_d, residu_d)
SST_d = norm2(dsort - mean(dsort))**2
SSR_d = SST_d - SSE_d
R2_d = SSR_d / SST_d
osort = sort(orient)
diffsort_o = diff(osort)
dispersionratio_o = std(diffsort_o) / mean(diffsort_o)
alpha_o = dot(HtHm1Ht, osort)
residu_o = osort - dot(regresscombi.transpose(), alpha_o)
SSE_o = dot(residu_o, residu_o)
SST_o = norm2(osort - mean(osort))**2
SSR_o = SST_o - SSE_o
R2_o = SSR_o / SST_o
histd = histogram(distance, bins=combi)
histdnorm = histd[0] / float(combi)
Hentropy_d = 0
for ic in range(combi):
if not (histdnorm[ic] == 0):
Hentropy_d = Hentropy_d - histdnorm[ic] * log2(histdnorm[ic])
histo = histogram(orient, bins=combi)
histonorm = histo[0] / float(combi)
Hentropy_o = 0
for ic in range(combi):
if not (histonorm[ic] == 0):
Hentropy_o = Hentropy_o - histonorm[ic] * log2(histonorm[ic])
HtH3d = dot(xsensors_m.transpose(), xsensors_m)
invHtH3d = inv(HtH3d)
La = len(lisaz_deg)
STDCRBaz_deg = zeros(La)
for ia in range(La):
aec = struct(a_deg=lisaz_deg[ia], e_deg=45.0, c_mps=340)
Jacobaec = jacobian3D(z, aec)
invJacobaec = inv(Jacobaec)
aux = dot(dot(invJacobaec,invHtH3d),\
invJacobaec.transpose())
STDCRBaz_deg[ia] = sqrt(aux[0, 0]) * 180.0 / pi
return RR, areaCov, R2_d, R2_o, dmin, dmax, distance, \
orient, Hentropy_d, Hentropy_o, dispersionratio_d, \
dispersionratio_o, STDCRBaz_deg
