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