def generate_pair(Tij, sid, tid, vi, vj, Ti, Tj, idx1, idx2, gt, suffix): width = 640 height = 480 #assert width == mtgt.width #assert height == mtgt.height assert height == 480 assert width == 640 idx1 = idx1[0, :] idx2 = idx2[0, :] tree_tgt = NN(n_neighbors=1, algorithm='kd_tree').fit(vj.T) #Tij = icp(vi.T, vj.T, init_pose=Tij, dmax=0.2, tree_tgt = tree_tgt, numSamples=2000) Rij, tij = decompose(Tij) label = __get_label__(Rij, tij, Ti, Tj) vi = (Rij.dot(vi).T + tij).T #print(src, tgt, label) #""" Compute Dist Image for Image 1 """ #dist1, index1 = tree[tgt].kneighbors(v1) #dist2, index2 = tree[src].kneighbors(v2) #print([np.mean(sorted(dist1)[:10000*i]) for i in range(1, 8)]) #print([np.mean(sorted(dist2)[:10000*i]) for i in range(1, 8)]) tree_src = NN(n_neighbors=1, algorithm='kd_tree').fit(vi.T) #v2 = Rij.T.dot().T - Rij.T.dot(tij); idx2 = mtgt.validIdx dist1, index1 = tree_tgt.kneighbors(vi.T) dist2, index2 = tree_src.kneighbors(vj.T) #import ipdb; ipdb.set_trace() image1 = np.zeros(width * height) + dist1.max() #print(dist1.max()) image1[idx1] = dist1[:, 0] #image1 = (image1 - image1.min()) / (image1.max() - image1.min()) * 255.0 image1 = np.power(image1, 0.25) image1 = np.reshape(image1, [height, width]) #print('frac of hole = %f' % fracOfHole) """ Compute Dist Image for Image 2 """ #print(dist2.max()) image2 = np.zeros(width * height) + dist2.max() image2[idx2] = dist2[:, 0] #image2 = (image2 - image2.min()) / (image2.max() - image2.min()) * 255.0 image2 = np.power(image2, 0.25) image2 = np.reshape(image2, [height, width]) #print('frac of hole = %f' % fracOfHole) ####################################################################### #""" Save Figure """ #image_concat = np.concatenate((image1, image2), axis=1) # ##pathlib.Path('knn_images_%d_%d_%s' % (sid, tid, gt)).mkdir(parents=True, exist_ok=True) #plt.imshow(image_concat, cmap='hot') ##plt.colorbar() #if gt: # plt.savefig('knn_images/%d_%d_%d_%s_gt.png' % (label, sid, tid, suffix)) #else: # plt.savefig('knn_images/%d_%d_%d_%s_recover.png' % (label, sid, tid, suffix)) ####################################################################### image = np.stack((image1, image2), axis=0) assert image.shape == (2, height, width) return image, label, Tij
def eval_mesh2mesh(mesh_dataset, num_views, args, RESULT, pairs, PAIR_ERRORS): def get_result(mesh_id): ori_pos = [] pred_before_reg = [] pred_after_reg = [] mesh = mesh_dataset[mesh_id] mesh_points = mesh.pos.cpu().numpy() for view_id in range(num_views): idx = mesh_id * num_views + view_id res_dict = sio.loadmat(RESULT.format(idx)) ori_pos.append(res_dict['ori_pos']) pred_before_reg.append(res_dict['pred_before_reg']) pred_after_reg.append(res_dict['pred_after_reg']) ori_pos = np.concatenate(ori_pos, axis=0) tree = NN(n_neighbors=5, n_jobs=10).fit(ori_pos) dists, indices = tree.kneighbors(mesh_points) weights = (0.01**2) / (0.01**2 + dists**2) weights = weights / weights.sum(-1)[:, np.newaxis] pred_before_reg = np.concatenate(pred_before_reg, axis=0) pred_after_reg = np.concatenate(pred_after_reg, axis=0) mesh_pred_before_reg = (pred_before_reg[indices] * weights[:, :, np.newaxis]).sum(-2) mesh_pred_after_reg = (pred_after_reg[indices] * weights[:, :, np.newaxis]).sum(-2) return mesh_pred_before_reg, mesh_pred_after_reg result_dict = {} pairs, gt_indices_list = pairs for pair, gt_indices in zip(pairs, gt_indices_list): pair_0, pair_1 = pair mesh_0 = mesh_dataset[pair_0] mesh_1 = mesh_dataset[pair_1] if result_dict.get(pair_0, None) is not None: pred_before_reg_0, pred_after_reg_0 = result_dict[pair_0] else: pred_before_reg_0, pred_after_reg_0 = get_result(pair_0) result_dict[pair_0] = (pred_before_reg_0, pred_after_reg_0) if result_dict.get(pair_1, None) is not None: pred_before_reg_1, pred_after_reg_1 = result_dict[pair_1] else: pred_before_reg_1, pred_after_reg_1 = get_result(pair_1) result_dict[pair_1] = (pred_before_reg_1, pred_after_reg_1) tree1 = NN(n_neighbors=1, n_jobs=10).fit(pred_before_reg_1) _, indices_before_reg = tree1.kneighbors(pred_before_reg_0) indices_before_reg = indices_before_reg[:, 0] tree1 = NN(n_neighbors=1, n_jobs=10).fit(pred_after_reg_1) _, indices_after_reg = tree1.kneighbors(pred_after_reg_0) indices_after_reg = indices_after_reg[:, 0] mesh_points_1 = mesh_1.pos.cpu().numpy() errors_before_reg = np.linalg.norm(mesh_points_1[gt_indices] - mesh_points_1[indices_before_reg], 2, axis=-1) errors_after_reg = np.linalg.norm(mesh_points_1[gt_indices] - mesh_points_1[indices_after_reg], 2, axis=-1) errors = np.stack([errors_before_reg, errors_after_reg], axis=-1) np.savetxt(PAIR_ERRORS.format(pair_0, pair_1), errors, fmt='%.6f %.6f')
def fit(self, x, y=None): x = self._check(x) self.d0_max, self.d0_min = x[:, 0].max(), x[:, 0].min() self.d1_max, self.d1_min = x[:, 1].max(), x[:, 1].min() self.d2_max, self.d2_min = ( x[:, 2].max(), x[:, 2].min()) if self.dim == 3 else None, None self.feature_names = ['d0_square', 'd1_square'] self.feature_names += ['d2_square'] if self.dim == 3 else [] self.feature_names += ['square'] if self.n_regions: from sklearn.cluster import KMeans from sklearn.neighbors import NearestNeighbors as NN self.cluster = KMeans(n_clusters=self.n_regions).fit(x) self.feature_names += ['region'] if self.distance: nn = {} clusters = np.c_[self.cluster.predict(x)] for i in range(self.n_regions): if np.where(clusters == i)[0].shape[0] > 1: self.feature_names += [ 'nearest_dist_to_' + str(i) + '_region' ] nn[i] = NN(n_neighbors=2).fit( x[np.where(clusters == i)[0]]) else: nn[i] = None self.nn = nn if y is not None: from sklearn.neighbors import NearestNeighbors as NN y = self._check(y, y=True) if np.unique(y).shape[0] > 15: raise ValueError( "Y can use only for classification where nunique count less than 15" ) ys = {} for i, val in enumerate(np.unique(y)): if np.where(y == val)[0].shape[0] > 1: self.feature_names += [ 'nearest_dist_to_' + str(val) + '_y' ] ys[i] = NN(n_neighbors=2).fit(x[np.where(y == val)[0]]) else: ys[i] = None self.ys = ys return self
def get_param_from_hdf5(hdf5, param, cols, all_param): '''searches hdf5 lib for rows of intrest. uses a binary like search''' go_on = False query = hdf5.read_where('(%s == %f) & (%s == %f)' % (cols[0], param[0], cols[1], param[1])) if len(query) > 0: #found something check other params for i in query: for j, col in enumerate(cols): if not i[col] == param[j]: go_on = True break else: #match! return i['spec'] #not match try interp if len(query) == 0 or go_on: #found nothing get nearest neightbors Nei_clas = NN(len(param) * 2).fit(all_param) index = nu.ravel(Nei_clas.kneighbors(param)[1]) #get spec spec = [] for i in index: spec.append(hdf5.cols.spec[i][:, 1]) spec = nu.asarray(spec) #get spec and interp print 'interpolating' return nu.vstack((hdf5.cols.spec[i][:, 0], n_dim_interp(all_param[index], param, spec))).T return []
def skiki_NN(hdf5, col, param): '''Looks for with skit learn function the len(col)*2 nearest neighbors in an hdf5 database''' d = np.empty((rows * batches, )) for i in range(batches): nbrs = NN(n_neighbors=len(col) * 2, algorithm='ball_tree').fit( h5f.root.carray[i * rows:(i + 1) * rows]) distances, indices = nbrs.kneighbors(vec) # put in dict?
def visualize_correspondence_smoothness(points, correspondence, max_error, min_error): """ Visualize smoothness of predicted correspondences Args: points: o3d.geometry.TriangleMesh, contains N points. correspondence: [N] """ pcd = getPointCloud(points) model = helper.loadSMPLModels()[0] pcd.points = o3d.utility.Vector3dVector(np.array(pcd.points)+np.array([1.0,0,0]).reshape((1, 3))) v = np.array(pcd.points) N = v.shape[0] tree = NN(n_neighbors=20).fit(v) dists, indices = tree.kneighbors(v) target = model.verts[correspondence, :] # [N, 3] centers = target[indices, :].mean(axis=1) # [N, 3] diff_norms = np.square(target[indices, :] - centers[:, np.newaxis, :]).sum(axis=-1).mean(axis=1) # [N] diff_norms[np.where(diff_norms > max_error)] = max_error diff_norms[np.where(diff_norms < min_error)] = min_error import ipdb; ipdb.set_trace() max_indices = np.argsort(diff_norms)[-1000:] edges = getEdges(v[max_indices, :], target[max_indices, :]) colors = (diff_norms-min_error)/(max_error - min_error) r = np.outer(np.ones(N), np.array([1.0, 0, 0])) # [N, 3] b = np.outer(np.ones(N), np.array([0., 0, 1.0])) # [N, 3] colors = b*(1.0-colors[:, np.newaxis])+r*(colors[:, np.newaxis]) pcd.points = o3d.utility.Vector3dVector(colors) o3d.draw_geometries([pcd, getTriangleMesh(model.verts, model.faces), edges])
def predict_frame_pixel(data, def_param=(shared_v_data, shared_u_data)): y, x = data shared_delayed_v_data = create_0d_delay_coordinates(shared_v_data[:, y, x], ddim, tau=32) delayed_patched_v_data_train = shared_delayed_v_data[:trainLength] u_data_train = shared_u_data[:trainLength, y, x] delayed_patched_v_data_test = shared_delayed_v_data[ trainLength:trainLength + testLength] u_data_test = shared_u_data[trainLength:trainLength + testLength, y, x] flat_v_data_train = delayed_patched_v_data_train.reshape(-1, ddim) flat_u_data_train = u_data_train.reshape(-1, 1) flat_v_data_test = delayed_patched_v_data_test.reshape(-1, ddim) flat_u_data_test = u_data_test.reshape(-1, 1) neigh = NN(2, n_jobs=1) #n_jobs=26 neigh.fit(flat_v_data_train) distances, indices = neigh.kneighbors(flat_v_data_test) pred = ( (flat_u_data_train[indices[:, 0]] + flat_u_data_train[indices[:, 1]]) / 2.0).ravel() return pred
def masked_feature_averaging(points, features, rotations, target_points): """Average point features. Args: points: [N, N_points, 3], N point clouds. features: [N, N_points, d], point-wise features for each point cloud. rotations: [N, 3, 3], rotation of each point cloud. target_points: [M, 3], points to average features on. Returns: mask: [X] of range [0, 6890) target_features: [M, d] averaged features. """ N = points.shape[0] attached_points = [] for i in range(N): points_i = points[i, :, :] Ri = rotations[i] points_i = Ri.T.dot(points_i.T).T attached_points.append(points_i) attached_points = np.concatenate(attached_points, axis=0) # [N*N_points, 3] attached_features = features.reshape((-1, features.shape[-1])) # [N*N_points, d] tree = NN(n_neighbors=5).fit(attached_points) dists, indices = tree.kneighbors(target_points) # [M, 5] extracted_features = attached_features[indices, :] # [M, 5, d] average_features = extracted_features.mean(axis=1) # [M, d] mask = np.where(dists[:, 0] < 0.02)[0] return mask, average_features[mask, :]
def nearestNeighbor(): patientsArr, patients, geneTags, patientTags, meanGeneVals = makeArray() neigh = NN(n_neighbors=5, radius=1.0) neigh.fit(patientsArr) # ct = 0 print '# patients', len(patientTags) print '# genes', len(geneTags) for i in range(len(patientTags)): for j in range(len(geneTags)): if (patients[i][j] == 'NaN') or (patients[i][j] == 'NaN\n'): # ct+=1 # if ct>2: # sys.exit() # print 'patient ', i, ' has a missing value ' nbrs = neigh.kneighbors(patientsArr[i]) knbrs = nbrs[1] # print 'nearest neighbors are ', nbrs[0],' |||| ' ,nbrs[1] # print knbrs # print 'new value for patients [', i+1, '][', j+1,'] = ' patients[i][j] = retMissingVal(knbrs, patientsArr, j) #calculate the mean of the genevalues of these patients # pass # """fill in missing values""" # patients[i][j]=meanGeneVals[j] else: patients[i][j] = float(patients[i][j]) fh_pickle = open('imputed_data', 'w') pickle.dump(patients, fh_pickle) fh_pickle.close() return patients
def fit(self, x, y): # calculate sample ratio class_numsamples_dict = {} class_samples_counts = y.value_counts() max_samples = class_samples_counts.iloc[0] class_list = y.unique() for c in class_list: num_samples = class_samples_counts[c] class_numsamples_dict[c] = float(max_samples-num_samples)/max_samples sample_ratio = [] for index, value in y.iteritems(): c = value sample_ratio.append(class_numsamples_dict[c]) # calculate knn ratio x = x.reset_index() y = y.reset_index() nn = NN(n_neighbors=int(self.k)) nn.fit(x) knn_ratio = [] for index, value in x.iterrows(): if index % 100 == 0: print index num_sameclass = 0 distance, indices = nn.kneighbors(value) relevant_indices = indices[0][1:] for ri in relevant_indices: if y.loc[ri].values[1] == y.loc[index].values[1]: num_sameclass += 1 knn_ratio.append(num_sameclass / float(self.k)) plt.hist(knn_ratio) plt.show()
def update_correspondences(fixed_points, fixed_normals, moving_points, moving_normals, correspondences, weights, sigma=1e-2): """ Compute Nearest Neighbor Distances """ fixed = np.concatenate([fixed_points, 0.001 * fixed_normals], axis=-1) moving = np.concatenate([moving_points, 0.001 * moving_normals], axis=-1) tree = NN(n_neighbors=1).fit(moving) dists, indices = tree.kneighbors(fixed) dists = dists[:, 0] valid_idx = np.where(dists < 0.1)[0] dists = dists[valid_idx] indices = indices[valid_idx, 0].astype(np.int32) new_fixed_points = np.concatenate( [fixed_points, fixed_points[valid_idx, :]], axis=0) new_fixed_normals = np.concatenate( [fixed_normals, fixed_normals[valid_idx, :]], axis=0) new_correspondences = np.concatenate([correspondences, indices], axis=0) sigma2 = np.ones(dists.shape[0]) * sigma * sigma new_weights = np.concatenate( [weights, sigma2 / (sigma2 + np.square(dists))], axis=0) fixed_dict = { 'points': new_fixed_points, 'normals': new_fixed_normals, 'correspondences': new_correspondences, 'weights': new_weights } return fixed_dict
def smpl_align(points, correspondences, weights=None, max_iter=30): """ Args: points: [N, 3] numpy array correspondences: [N] Returns: indices: [N] updated correspondence """ N = points.shape[0] model = helper.loadSMPLModels()[0] if weights is None: weights = np.ones(N) pcd = o3d.geometry.PointCloud() pcd.points = o3d.utility.Vector3dVector(points) pcd.estimate_normals() normals = np.array(pcd.normals) params = align(points, correspondences, normals, model, weights, max_iter=max_iter) model.update_params(params) tree = NN(n_neighbors=1, n_jobs=10).fit(model.verts) dists, indices = tree.kneighbors(points) indices = indices[:, 0] return indices
def buildGraphSK(MatL,MatU,rbf_sigma=None,knn=0): nins=NN(knn,None,metric='euclidean').fit(np.vstack((MatL,MatU))) W=nins.kneighbors_graph(nins._fit_X,knn,mode='distance') W.data=np.exp(-W.data/rbf_sigma) affinity_UL=W[MatL.shape[0]:,:MatL.shape[0]]#.toarray() affinity_UU=W[MatL.shape[0]:,MatL.shape[0]:]#.toarray() return affinity_UL,affinity_UU
def create_smote_vectors(df, duplicate_ratio=1.0, proj_distance=1.0, filename='smote'): print 'Generating Synethic Vectors (SMOTE)...' # remember df column names to apply to smote df at the end df_colnames = df.columns # find the number of samples that need to be created for each class class_numsamples_dict = {} class_samples_counts = df.cl.value_counts() max_samples = class_samples_counts.iloc[0] class_list = df.cl.unique() for c in class_list: num_samples = class_samples_counts[c] class_numsamples_dict[c] = (max_samples-num_samples) / num_samples # fit the knn algorithm xtrain = df.drop(['cl','filepath'], axis=1) nn = NN(n_neighbors=2) nn.fit(xtrain) # find vector shape vshape = xtrain.loc[0].shape smote_vectors = [] # for each instance in the dataframe for index, value in df.iterrows(): # print status update if index % 250 == 0: print '%s row out of %s' % (str(index), str(df.shape[0])) # grab the class cl = value.cl # eliminate class and filepath to find nn x = value.drop(['cl','filepath']) # find the nearest neighbor distance, indices = nn.kneighbors(x) nn_x = df.loc[indices[0][1]].drop(['cl', 'filepath']) # generate class_numsamples_dict[class]*duplicate_ratio samples and write to list diff = x - nn_x for i in range(int(class_numsamples_dict[cl]*duplicate_ratio)): r = np.random.random(size=vshape)*proj_distance random_difference = diff*r v_smote = list(random_difference + x) v_smote.append(cl) v_smote.append('synthetic') v_smote.append(index) smote_vectors.append(v_smote) # turn smote list into data frame df_smote = pd.DataFrame(smote_vectors) df_smote.index = df_smote.ix[:,24] df_smote = df_smote.drop([24], axis=1) df_smote.columns = df_colnames # write dataframe to csv df_smote.to_csv(DATA_PATH + '%s.csv' % str(filename))
def nearestN(): X = [[125, 1], [200, 0], [70, 0], [240, 1], [114, 0], [120, 0], [264, 1], [85, 0], [150, 0], [90, 0]] # y = [ 0, 0, 0, 0, 1, 0, 0, 1, 0,1 ] model = NN(n_neighbors=1, radius=1) model.fit(X) y = [98., 0.] print model.kneighbors(y)
def __init__(self, X, d_max, gan_model=None): self.d_max = d_max self.gan_model = gan_model self.reachability_log = str( d_max) if gan_model is None else "Discriminator" # Use clean dataset print("Fitting node validator") self.nb = NN(n_neighbors=2).fit(X) return None
def predict_heads_by_graph(self, X, Y_nums, label_graph, heads, tail_space, head_space, model_path=None): if model_path: self.model.load_state_dict(torch.load(model_path)) self.model.eval() self.model.to(self.device) tail_nbrs = NN(n_neighbors=5, algorithm='auto').fit(tail_space) all_input_ids = torch.tensor(X) logits = np.zeros([len(X), tail_space.shape[1]]) bs=self.hypes.eval_batch_size for step in trange(int(len(X)/bs)-1): input_ids = all_input_ids[step*bs:(step+1)*bs].to(self.device) with torch.no_grad(): logit = self.model(input_ids) logits[step*bs:(step+1)*bs] = logit.cpu().detach().numpy() # print('Calculating Acccuracy...') preds_path = self.ds_path + '/knn_preds' if not os.path.exists(preds_path): _, preds = tail_nbrs.kneighbors(logits) with open(preds_path, 'wb') as f: pkl.dump(preds, f) else: with open(preds_path, 'rb') as f: preds = pkl.load(f) head_subs = {} num_corrects = np.zeros(5) for i, pred_tails in tqdm(enumerate(preds)): truth = Y_nums[i] for pred_tail in pred_tails: head_neis = [int(x) for x in list(label_graph.neighbors(str(pred_tail))) if int(x) in heads] if i in head_subs: head_subs[i] += head_neis else: head_subs[i] = head_neis if i in head_subs: voted_list = np.array(sorted(Counter(head_subs[i]).items(), reverse=True, key=lambda kv: kv[1]))[:,0] head_preds = voted_list[:5] # head_embs = head_space[head_subs[i]] # head_nbrs = NN(n_neighbors=5, algorithm='auto').fit(head_embs) # _, head_preds = head_nbrs.kneighbors([logits[i]]) # head_preds = head_preds[0] if len(set(truth) & set(head_preds)): for j in range(len(head_preds)): if head_preds[j] in truth: num_corrects[j:] += 1 else: print(i, 'does not have heads') for i in range(1, 6): num_corrects[i-1] /= i head_precision = np.round(num_corrects / len(X), 4) print('Head Precisions:', head_precision) return head_precision
def update_nn_correspondences(correspondences, model, raw_pc, max_nn_dist, nc_3d, visualize=False): w = 0.001 pcd = o3d.geometry.PointCloud() print(raw_pc.shape) pcd.points = o3d.utility.Vector3dVector(raw_pc) o3d.estimate_normals(pcd) signs = np.sign(np.array(pcd.normals).dot(np.array([1.0,0,0]))) pcd.normals = o3d.utility.Vector3dVector(signs[:, np.newaxis]*np.array(pcd.normals)) #o3d.io.write_point_cloud('hey.ply', pcd) #dirc = np.array([[a*1.0,0,0] for a in range(1000)])/100.0 #pcd0 = o3d.geometry.PointCloud() #pcd0.points = o3d.utility.Vector3dVector(dirc) #o3d.draw_geometries([pcd, pcd0]) raw = np.concatenate([raw_pc, w*np.array(pcd.normals)], axis=1) mesh = o3d.geometry.TriangleMesh() mesh.vertices = o3d.utility.Vector3dVector(model.verts) mesh.triangles = o3d.utility.Vector3iVector(model.faces) mesh.compute_vertex_normals() model_v = np.concatenate([model.verts, w*np.array(mesh.vertex_normals)], axis=1) """ Compute nearest neighbor correspondences from current mesh vertices to point cloud. """ tree = NN(n_neighbors=1).fit(model_v) dists, indices = tree.kneighbors(raw) indices = indices[:, 0] idx = np.where(dists < max_nn_dist)[0] nnmask = idx indices = indices[idx] dists = np.abs(np.sum(np.multiply(raw_pc[idx, :]-model_v[indices, :3], model_v[indices, 3:]), axis=1)) dists = np.square(dists) argmax = np.argmax(dists) nn_vertices = raw_pc[idx, :] #nn_vertices = model.verts[indices[idx], :] nn_vec = np.array(nn_vertices).reshape(-1) sigma2 = np.median(dists) #print('sigma2=%f' % sigma2) nn_weights=np.ones(dists.shape) # (np.ones(dists.shape)*sigma2/(np.ones(dists.shape)*sigma2+dists)) #np.exp(-dists/(2*sigma2)) if visualize: #print(dists[argmax]) #print(nn_weights[argmax]) #import ipdb; ipdb.set_trace() visualize_points([model.verts, raw_pc, connection(raw_pc[idx[argmax], :], model_v[indices[argmax], :3])]) indices3d = correspondences['indices3d'][:nc_3d] target3d = correspondences['target3d'][:nc_3d].reshape((-1, 3)) weights3d = correspondences['weights3d'][:nc_3d] indices3d = np.concatenate([indices3d, indices], axis=0) target3d = np.concatenate([target3d, raw_pc], axis=0) weights3d = np.concatenate([weights3d, nn_weights], axis=0) correspondences['indices3d'] = indices3d correspondences['target3d'] = target3d correspondences['weights3d'] = weights3d
def ball_tree(M): start = time.time() nbrs = NN(n_neighbors=k, algorithm='ball_tree', metric='pyfunc', metric_params={"func": js_distance}, leaf_size=100) nbrs.fit(M) print "ball tree elapsed time: ", time.time() - start return nbrs
def fit(self, X, y): self.X = np.array(X) self.y = np.array(y) self.classes = np.array(list(set(self.y))) if self.strategy != 'my_own': from sklearn.neighbors import NearestNeighbors as NN self.nn = NN(n_neighbors=self.k, algorithm=self.strategy, metric=self.metric) self.nn.fit(X, y)
def predict_inner_pixel(data, def_param=(shared_v_data, shared_u_data)): y, x = data shared_delayed_v_data = create_2d_delay_coordinates( shared_v_data[:, y - patcv_radius:y + patcv_radius + 1, x - patcv_radius:x + patcv_radius + 1][:, ::sigma_skip, ::sigma_skip], ddim, tau=119) shared_delayed_patched_v_data = np.empty( (ndata, 1, 1, ddim * eff_sigma * eff_sigma)) shared_delayed_patched_v_data[:, 0, 0] = shared_delayed_v_data.reshape( -1, ddim * eff_sigma * eff_sigma) delayed_patched_v_data_train = shared_delayed_patched_v_data[:trainLength, 0, 0] u_data_train = shared_u_data[:trainLength, y, x] delayed_patched_v_data_test = shared_delayed_patched_v_data[ trainLength:trainLength + testLength, 0, 0] u_data_test = shared_u_data[trainLength:trainLength + testLength, y, x] flat_v_data_train = delayed_patched_v_data_train.reshape( -1, shared_delayed_patched_v_data.shape[3]) flat_u_data_train = u_data_train.reshape(-1, 1) flat_v_data_test = delayed_patched_v_data_test.reshape( -1, shared_delayed_patched_v_data.shape[3]) flat_u_data_test = u_data_test.reshape(-1, 1) neigh = NN(k, n_jobs=1, algorithm='kd_tree') #n_jobs=26 neigh.fit(flat_v_data_train) distances, indices = neigh.kneighbors(flat_v_data_test) with np.errstate(divide='ignore'): weights = np.divide(1.0, distances) infinity_mask = np.isinf(weights) infinity_row_mask = np.any(infinity_mask, axis=1) weights[infinity_row_mask] = infinity_mask[infinity_row_mask] denominator = np.repeat(np.sum(weights, axis=1), k).reshape((-1, k)) weights /= denominator pred = 0 for i in range(k): pred += np.multiply(weights[:, i, np.newaxis], flat_u_data_train[indices[:, i]]) pred = pred.ravel() #pred = ((flat_u_data_train[indices[:, 0]] + flat_u_data_train[indices[:, 1]])/2.0).ravel() return pred
def check_link_deg(vecs, v, v_id, degrees): deg = degrees[str(v_id + 1)] # print(deg) nh = NN(n_neighbors=deg, algorithm='ball_tree') nh.fit(vecs) v = [list(v)] ng = nh.kneighbors(v, return_distance=False)[0] g = open('new_graph_deg.txt', 'a') for index in ng: g.write(str(v_id + 1) + ' ' + str(index + 1) + '\n') g.close()
def nearest_kdtree(probes, link_points, n=10, is_filter=True): _n = n * 3 if is_filter else n nn = NN(n_neighbors=_n, algorithm="kd_tree").fit(link_points) knn_candidates = nn.kneighbors(probes, return_distance=False) if not is_filter: return knn_candidates knns = [] for probe, cands in izip(probes, knn_candidates): ret = nearest_probe_force(probe, link_points[cands], n) knns.append(cands[ret]) return np.array(knns)
def get_minimum_eps(X, metric='euclidean'): """ Return the maximum value that should be used for minimum samples -- floor(0.15*len(X)) Return the minimum value such that at least 1 point has K neighbors for K = 1 .. floor(0.15*len(X)) """ minPts = int(np.floor(0.15 * len(X))) nn = NN(minPts + 1) nn.fit(X) knn, idx = nn.kneighbors(X) minEps = [knn[:, i].min() for i in range(1, minPts + 1)] return (minPts, minEps)
def parallel_check_link_dis(vecs, v, v_id, threshold): g = open('new_graph.txt', 'a') nhr = NN(radius=threshold) nhr.fit(vecs) v = [list(v)] rng = nhr.radius_neighbors(v, return_distance=False)[0] for index in rng: if v_id == index: continue # assume the graph is undirected. g.write(str(v_id + 1) + ' ' + str(index + 1) + '\n') g.close()
def icp(points1, points2_prime, M_init, threshold=0.021): M = M_init nn = NN(n_neighbors=1).fit(points1) for i in xrange(1000): dist, idx = find_nearest(nn, points2_prime, M) avg_dist = np.mean(dist) print "Iteration %d, average distance %f" % (i, avg_dist) if avg_dist < threshold: break M = np.dot(np.linalg.pinv(points2_prime), points1[idx, :]) dist, idx = find_nearest(nn, points2_prime, M) print "Final result, average distance %f" % (np.mean(dist)) print "M ", M print "M transpose", M.T
def icp_reweighted(source, target, sigma=0.01, max_iter=100, stopping_threshold=1e-4): """ If target has no normals, estimate """ if np.array(target.normals).shape[0] == 0: search_param = o3d.geometry.KDTreeSearchParamHybrid(radius=0.2, max_nn=30) o3d.estimate_normals(target, search_param=search_param) tree = NN(n_neighbors=1, algorithm='kd_tree', n_jobs=10) tree = tree.fit(np.array(target.points)) n = np.array(source.points).shape[0] normals = np.array(target.normals) points = np.array(target.points) weights = np.zeros(n) errors = [] transform = np.eye(4) for itr in range(max_iter): p = np.array(source.points) R, trans = gutil.unpack(transform) p = (R.dot(p.T) + trans.reshape((3, 1))).T _, indices = tree.kneighbors(p) """ (r X pi + pi + t - qi)^T ni """ """( <r, (pi X ni)> + <t, ni> + <pi-qi, ni> )^2""" """ (<(r; t), hi> + di)^2 """ nor = normals[indices[:, 0], :] q = points[indices[:, 0], :] d = np.sum(np.multiply(p - q, nor), axis=1) #[n] h = np.zeros((n, 6)) h[:, :3] = np.cross(p, nor) h[:, 3:] = nor weight = (sigma**2) / (np.square(d) + sigma**2) H = np.multiply(h.T, weight).dot(h) g = -h.T.dot(np.multiply(d, weight)) delta = np.linalg.solve(H, g) errors = np.abs(d) print('iter=%d, delta=%f, mean error=%f, median error=%f' % (itr, np.linalg.norm(delta, 2), np.mean(errors), np.median(errors))) if np.linalg.norm(delta, 2) < stopping_threshold: break trans = delta[3:] R = gutil.rodrigues(delta[:3]) T = gutil.pack(R, trans) transform = T.dot(transform) return transform
def query_nearest_neighbors(self, query): if not hasattr(self, 'nbrs_model'): print('No nearest neighbor model detected, running initial model.' 'This may take a minute.') self.nbrs_model = NN(n_neighbors=10, algorithm='ball_tree').fit( self.word_vecs_norm) vocab = list(self.tok2indx.keys()) if query in vocab: distances, indices = self.nbrs_model.kneighbors( self.word_vecs_norm[self.tok2indx[query], :].reshape(-1, 1).T) for dist, indx in zip(distances[0], indices[0]): print('{} : {} \n'.format(vocab[indx], dist)) else: print('query token does not exist in vocabulary')
def parallel_check_link_deg(V, vecs, degrees, fname): # print('3ㅅ3') v = array(V[0]) v_id = V[1][0] # print('vid: ', v_id+1) deg = degrees[str(v_id + 1)] # print(deg) nh = NN(n_neighbors=deg, algorithm='ball_tree') nh.fit(vecs) v = [list(v)] ng = nh.kneighbors(v, return_distance=False)[0] g = open(fname, 'a') for index in ng: g.write(str(v_id + 1) + ' ' + str(index + 1) + '\n') g.close()
def knn(self, vin, vout, thresh=None): nn = NN() nn.fit(vin) dist, ix = nn.kneighbors(vout, n_neighbors=1) if thresh: ix_out = np.array(np.where(dist.T[0] < thresh))[0] print(type(ix_out)) ix_in = ix.T[0][ix_out] else: ix_out = np.arange(len(ix)) ix_in = ix.T[0] print(ix_in.shape, ix_out.shape) return ix_in, ix_out