def enlace(self, nos_np, pkt): pkt_enviado = [] enviaram = [] while True: for i in nos_np: i.busy_tone = 0 count = 0 for i in nos_np: if distance.seuclidean(self.pos, i.pos, [1, 1]) == 1: if enviaram.count(i): count += 1 else: pkt_send = pk.Packet(pkt.id, pkt.content[:], pkt.header[0], pkt.header[1]) if pkt.flooding == 1: pkt_send.set_flooding() if pkt.flooding_response == 1: pkt_send.set_flooding_response() count += 1 pkt_send.link_header([self.id, i.id]) nos_send = i if nos_np[pkt_send.mac_header[0][0]].busy_tone == 0: print("PKT MAC HEADER --> " + str(pkt_send.mac_header[0])) no = nos_np[pkt_send.mac_header[0][0]].id #print("Nó = " + str(no) + " ----> Enviando pacote " + str(i.content)) enviou = nos_np[no].link_send(nos_send, pkt_send) if enviou: pkt_enviado.append(nos_send) enviaram.append(nos_send) else: pkt_enviado.clear() else: print("BUSY TONE: " + str(nos_np[ pkt_send.mac_header[0][0]].busy_tone)) print("#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#") #print(str(pkt_enviado)) for i in pkt_enviado: pkt_copia = pk.Packet(pkt.id, pkt.content[:], pkt.header[0], pkt.header[1]) pkt_copia.link_header(pkt.mac_header[:]) pkt_copia.net_header = pkt.net_header[:] if pkt.flooding == 1: pkt_copia.set_flooding() if pkt.flooding_response == 1: pkt_copia.set_flooding_response() i.recieve(pkt_copia, i.id, nos_np) i.busy_tone = 0 #print("VIZINHOS: " + str(nos_np[pkt[i].mac_header[0][0]].vizinhos)) #if len(nos_np[pkt.mac_header[0][0]].vizinhos): # for j in nos_np[pkt.mac_header[0][0]].vizinhos: # no_recieve = j # nos_np[no_recieve].recieve(pkt, no_recieve,nos_np) #nos_np[pkt.mac_header[0][0]].busy_tone = 0 pkt_enviado.clear() #print("ENVIADOS ---> " + str(teste) + " COUNT ---> " + count) if len(enviaram) == count: break
def Dist(array1, array2, dist): if dist == 'braycurtis': return distance.braycurtis(array1, array2) elif dist == 'correlation': return distance.correlation(array1, array2) elif dist == 'mahalanobis': return distance.mahalanobis(array1, array2) elif dist == 'minkowski': return distance.minkowski(array1, array2) elif dist == 'seuclidean': return distance.seuclidean(array1, array2) elif dist == 'sqeuclidean': return distance.sqeuclidean(array1, array2) elif dist == 'pearsonp': r, p = pearsonr(array1, array2) return p elif dist == 'pearsonr': r, p = pearsonr(array1, array2) return r elif dist == 'spearmanp': r, p = spearmanr(array1, array2) return p elif dist == 'spearmanr': r, p = spearmanr(array1, array2) return r
def distance(vector1, vector2, alpha=2, metric='euclidean'): ''' Helper function that calculates the alpha :param vector1: a vector :type vector1: list of doubles :param vector2: a vector :type vector2: list of doubles :param metric: euclidean, mahalanobis, seuclidean, cityblock :type metric: string :rtype: norm between vectors A and B ''' mp.dps = 50 alpha = mpf(1.0 * alpha) vector1 = matrix(numpy.array(vector1)) vector2 = matrix(numpy.array(vector2)) if metric == 'euclidean': vector_norm = distances.euclidean(vector1, vector2) elif metric == 'mahalanobis': vi = numpy.linalg.inv( numpy.cov(numpy.concatenate((vector1, vector2)).T)) vector_norm = distances.mahalanobis(vector1, vector2, vi) elif metric == 'seuclidean': vector_norm = distances.seuclidean(vector1, vector2) elif metric == 'cityblock': vector_norm = distances.cityblock(vector1, vector2) elif metric == 'hamming': vector_norm = distances.hamming(vector1, vector2) else: print "Unknown metric" return None return vector_norm
def seuclidean(self, x, y): assert len(x) == len(y), "x, y with different dimentionality." dim = len(x) V = np.array([np.var([x[i], y[i]]) for i in range(dim)]) # correction for 0 V[V<1] = 1 # print(x) # print(y) # print(V) return dist.seuclidean(x, y, V)
def __call__(self, input, target): """ :input: The predictions from the network (BS*C*D*H*W) :target: The ground truth passed to the network (BS*C*D*H*W) :return: Number of matched peaks """ # look for local max within fixed range between input and target # Get input and predictions in required format input, target = convert_to_numpy(input, target) # pass the original gt coordinates here #original_gt = # # Take the peaks from the predictions local_max = skimage.feature.peak_local_max(input[0][0], min_distance=4) # Take the foreground pixels from ground truth foreground = np.where(target[0][0] == 1.0) foreground_coords = [] for idx, val in enumerate(foreground[0]): foreground_coords.append( [foreground[0][idx], foreground[1][idx], foreground[2][idx]]) eval_dict = {} # Matching procedure for coord in local_max: z, y, x = coord[0], coord[1], coord[2] eval_dict[(z, y, x)] = {} for coord in foreground_coords: gt_z, gt_y, gt_x = coord[0], coord[1], coord[2] # Taking anisotropy into account std_euc = distance.seuclidean([z, y, x], [gt_z, gt_y, gt_x], [3.0, 1.3, 1.3]) # Keeping a threshold for matching if std_euc <= 8.0: eval_dict[(z, y, x)][gt_z, gt_y, gt_x] = std_euc n_count = 0 for k, v in eval_dict.items(): if v != {}: #vsorted = {k2: v2 for k2, v2 in sorted(v.items(), key=lambda item: item[1])} n_count += 1 #print(k, dict(itertools.islice(vsorted.items(), 1))) print(n_count) return torch.tensor(n_count)
def standardized_euclidean(self, v, x=None, y=None): """ 标准化欧氏距离是针对简单欧氏距离的缺点(量纲差异)而作的一种改进方案 x = [2, 0, 0] y = [0, 1, 0] v = [0.1, 0.1, 0.1] """ x = x or self.x y = y or self.y return distance.seuclidean(x, y, v)
def weighted_distances_from_center(self): """ Calculate the covariance-weighted distances from the current maximum-weight sample. N.B. Using normalized Euclid instead of Mahalanobis if we're just going to diagonalize anyways. """ max_weight_sample = self.gaussian_centers[-1] V = self.prior_covariance if self.prior_covariance.size == 1 else np.diag(self.prior_covariance) distances = [seuclidean(s, max_weight_sample, V=V) for s in self.samples] logger.debug('Distances:\n%s', distances) return distances
def test_eu(train_axis, train_labels, test_axis, dev, train_metr): centroid = np.mean(train_axis, axis=0) test_md = [] outl_ind = [] for x in range(len(test_axis)): if len(test_axis.shape) > 1: test_md.append(distance.euclidean(test_axis[x, :], centroid)) else: test_md.append(distance.seuclidean(test_axis[x], centroid)) if (test_md[-1] * dev > train_metr): outl_ind.append(x) return outl_ind, np.mean(test_md)
def Dist(array1, array2, dist): if dist == 'braycurtis': return distance.braycurtis(array1, array2) elif dist == 'correlation': return distance.correlation(array1, array2) elif dist == 'mahalanobis': return distance.mahalanobis(array1, array2) elif dist == 'minkowski': return distance.minkowski(array1, array2) elif dist == 'seuclidean': return distance.seuclidean(array1, array2) elif dist == 'sqeuclidean': return distance.sqeuclidean(array1, array2)
def matching(peaks_list_a, peaks_list_b): eval_dict = {} for pid_a, peak_a in enumerate(peaks_list_a): z, y, x = peak_a[0], peak_a[1], peak_a[2] eval_dict[(z, y, x)] = {} for pid_b, peak_b in peaks_list_b: pz, py, px = peak_b[0], peak_b[1], peak_b[2] std_euc = distance.seuclidean([z, y, x], [pz, py, px], [3.0, 1.3, 1.3]) if std_euc <= 6.0: eval_dict[z, y, x][(pz, py, px)] = std_euc return eval_dict
def SpatialDistanceEval(csvfile): """ csvfile: csv with peaks and labels (GT) """ # Read file as dataframe data_file = pd.read_csv(csvfile) # Ground truth coordinates GT_x = list(data_file['Gtx']) GT_y = list(data_file['Gty']) GT_z = list(data_file['Gtz']) # Prediction peak coordinates Pred_x = list(data_file['PredX']) Pred_y = list(data_file['PredY']) Pred_z = list(data_file['PredZ']) # Dict to store matching pairs eval_dict = {} # Check peaks for each label coordinate for x, y, z in zip(GT_x, GT_y, GT_z): eval_dict[(x, y, z)] = [] for px, py, pz in zip(Pred_x, Pred_y, Pred_z): # Take the standardized euclidean distance std_euc_distance = distance.seuclidean([x, y, z], [px, py, pz], [1.3, 1.3, 3.0]) # Take the euclidean distance #dist = distance.euclidean([x,y,z], [px, py, pz]) #Check for threshold if std_euc_distance <= 8.0: eval_dict[(x, y, z)].append((px, py, pz, std_euc_distance)) # Count the unmatched label coordinates unmatched_count = 0 for each_label in eval_dict.values(): if each_label == []: unmatched_count += 1 return unmatched_count, eval_dict
def match_routine(peak_set_a, peak_set_b, neighbor_threshold): eval_dict = {} for id1, coord_a in enumerate(peak_set_a): z_pos_a, y_pos_a, x_pos_a = coord_a[0], coord_a[1], coord_a[2] eval_dict[(z_pos_a, y_pos_a, x_pos_a)] = {} for id2, coord_b in enumerate(peak_set_b): z_pos_b, y_pos_b, x_pos_b = coord_b[0], coord_b[1], coord_b[2] std_euc = distance.seuclidean([z_pos_a, y_pos_a, x_pos_a], [z_pos_b, y_pos_b, x_pos_b], [3.0, 1.3, 1.3]) if std_euc <= neighbor_threshold: instance_label = watershed_output[0][wshed_peaks[id2][0]][ wshed_peaks[id2][1]][wshed_peaks[id2][2]] #eval_dict[gt_z, gt_y, gt_x][(z,y,x)] = {instance_label, std_euc} eval_dict[z_pos_a, y_pos_a, x_pos_a][(z_pos_b, y_pos_b, x_pos_b)] = std_euc return eval_dict
def main(): opt = parser.parse_args() rf = np.load(opt.ref) hf = np.load(opt.hyp) if opt.type == 'mahalanobis': ic = np.linalg.inv(np.cov(rf, rowvar=False)) if opt.type == 'seuclidean': v = np.var(rf, 0) for i, j in zip(rf, hf): if opt.type == 'L1': print("Distance:", L1(i, j)) elif opt.type == 'L2': print("Distance:", L2(i, j)) elif opt.type == 'cos': print("Distance:", cos(i, j)) elif opt.type == 'braycurtis': print("Distance:", braycurtis(i, j)) elif opt.type == 'canberra': print("Distance:", canberra(i, j)) elif opt.type == 'chebyshev': print("Distance:", chebyshev(i, j)) elif opt.type == 'cityblock': print("Distance:", cityblock(i, j)) elif opt.type == 'correlation': print("Distance:", correlation(i, j)) elif opt.type == 'mahalanobis': print("Distance:", mahalanobis(i, j, ic)) elif opt.type == 'minkowski': print("Distance:", minkowski(i, j, 3)) elif opt.type == 'mulsum': print('Distance:', mulsum(i, j)) elif opt.type == 'seuclidean': print("Distance:", seuclidean(i, j, v)) elif opt.type == 'sqeuclidean': print("Distance:", sqeuclidean(i, j))
def similarity(self, vec1, vec2, variance): return seuclidean(vec1, vec2, variance) #后面是一维向量,属性的方差
ctrfpr = 0 dumctr = 0 totacc = atdat.shape[0] totval = vadat.shape[0] # euclidian distance radius barr1 = 10 # normal data neighbours thresshold barr2 = 20 # determine attack detection accuracy for it1 in atdat: for it2 in trdat: if math.pow(seuclidean(it1, it2, datavar), 2) <= barr1: dumctr += 1 if dumctr < barr2: ctracc += 1 dumctr = 0 myprint( "With {} Standardised square Euclidean distance limit and {} neighbours\ limit we get:".format(barr1, barr2)) myprint("Attack detection accuracy: {}".format(ctracc / totacc)) # only need to be done once. # it's the same across attacks if atdatselector == 1:
def evaluate_metric(X_query, y_query, X_gallery, y_gallery, metric='euclidian', parameters=None): rank_accuracies = [] AP = [] I, K = X_query.shape u = X_query.astype(np.float64) v = X_gallery.astype(np.float64) # u = X_query # v = X_gallery y_query = y_query.flatten() y_gallery = y_gallery.flatten() for query, y_q in zip(range(0, K), y_query): q_g_dists = [] y_valid = [] for gallery, y_g in zip(range(0, K), y_gallery): if query == gallery: continue else: if metric == 'euclidian': dist = distance.euclidean(u[:, query], v[:, gallery]) elif metric == 'sqeuclidean': dist = distance.sqeuclidean(u[:, query], v[:, gallery]) elif metric == 'seuclidean': dist = distance.seuclidean(u[:, query], v[:, gallery]) elif metric == 'minkowski': dist = distance.minkowski(u[:, query], v[:, gallery], parameters) elif metric == 'chebyshev': dist = distance.chebyshev(u[:, query], v[:, gallery]) elif metric == 'chi2': dist = -pairwise.additive_chi2_kernel( u[:, query].reshape(1, -1), v[:, gallery].reshape( 1, -1))[0][0] elif metric == 'braycurtis': dist = distance.braycurtis(u[:, query], v[:, gallery]) elif metric == 'canberra': dist = distance.canberra(u[:, query], v[:, gallery]) elif metric == 'cosine': dist = distance.cosine(u[:, query], v[:, gallery]) elif metric == 'correlation': dist = distance.correlation(u[:, query], v[:, gallery]) elif metric == 'mahalanobis': dist = distance.mahalanobis(u[:, query], v[:, gallery], parameters) else: raise NameError('Specified metric not supported') q_g_dists.append(dist) y_valid.append(y_g) tot_label_occur = y_valid.count(y_q) q_g_dists = np.array(q_g_dists) y_valid = np.array(y_valid) _indexes = np.argsort(q_g_dists) # Sorted distances and labels q_g_dists, y_valid = q_g_dists[_indexes], y_valid[_indexes] AP_, rank_A = get_acc_score(y_valid, y_q, tot_label_occur) AP.append(AP_) rank_accuracies.append(rank_A) rank_accuracies = np.array(rank_accuracies) total = rank_accuracies.shape[0] rank_accuracies = rank_accuracies.sum(axis=0) rank_accuracies = np.divide(rank_accuracies, total) i = 0 print('Accuracies by Rank:') while i < rank_accuracies.shape[0]: print('Rank ', i + 1, ' = %.2f%%' % (rank_accuracies[i] * 100), '\t', 'Rank ', i + 2, ' = %.2f%%' % (rank_accuracies[i + 1] * 100), '\t', 'Rank ', i + 3, ' = %.2f%%' % (rank_accuracies[i + 2] * 100), '\t', 'Rank ', i + 4, ' = %.2f%%' % (rank_accuracies[i + 3] * 100), '\t', 'Rank ', i + 5, ' = %.2f%%' % (rank_accuracies[i + 4] * 100)) i = i + 5 AP = np.array(AP) mAP = AP.sum() / AP.shape[0] print('mAP = %.2f%%' % (mAP * 100)) return rank_accuracies, mAP
print("Learned object 3") if keyPressed == ord('4'): protos[:, 3] = output print("Learned object 4") if keyPressed == ord('5'): protos[:, 4] = output print("Learned object 5") if keyPressed == 27: # ESC to stop break # compute distance between output and protos: if args.usevar: for i in range(5): dists[i] = distance.seuclidean( output, protos[:, i], outvar ) # uses a testset variance for better distance computations else: for i in range(5): dists[i] = distance.cosine(output, protos[:, i]) # print(dists) winner = np.argmin(dists) text2 = "" if dists[winner] < np.max(dists) * args.threshold: text2 = " / Detected: " + str(winner + 1) # compute time and final info: endt = time.time() text = "fps: " + '{0:.2f}'.format(1 / (endt - startt)) + text2
def evaluate_metric(X_query, camId_query, y_query, X_gallery, camId_gallery, y_gallery, metric = 'euclidian', parameters = None): rank_accuracies = [] AP = [] # Break condition for testing #q = 0 for query, camId_q, y_q in zip(X_query, camId_query, y_query): q_g_dists = [] y_valid = [] for gallery, camId_g, y_g in zip(X_gallery, camId_gallery, y_gallery): if ((camId_q == camId_g) and (y_q == y_g)): continue else: if metric == 'euclidian': dist = distance.euclidean(query, gallery) elif metric == 'sqeuclidean': dist = distance.sqeuclidean(query, gallery) elif metric == 'seuclidean': dist = distance.seuclidean(query, gallery) elif metric == 'minkowski': dist = distance.minkowski(query, gallery, parameters) elif metric == 'chebyshev': dist = distance.chebyshev(query, gallery) elif metric == 'braycurtis': dist = distance.braycurtis(query, gallery) elif metric == 'canberra': dist = distance.canberra(query, gallery) elif metric == 'cosine': dist = distance.cosine(query, gallery) elif metric == 'correlation': dist = distance.correlation(query, gallery) elif metric == 'mahalanobis': dist = distance.mahalanobis(query, gallery, parameters) else: raise NameError('Specified metric not supported') q_g_dists.append(dist) y_valid.append(y_g) tot_label_occur = y_valid.count(y_q) q_g_dists = np.array(q_g_dists) y_valid = np.array(y_valid) _indexes = np.argsort(q_g_dists) # Sorted distances and labels q_g_dists, y_valid = q_g_dists[_indexes], y_valid[_indexes] if tot_label_occur != 0: AP_, rank_A = get_acc_score(y_valid, y_q, tot_label_occur) AP.append(AP_) rank_accuracies.append(rank_A) #if q > 5: # break #q = q+1 rank_accuracies = np.array(rank_accuracies) total = rank_accuracies.shape[0] rank_accuracies = rank_accuracies.sum(axis = 0) rank_accuracies = np.divide(rank_accuracies, total) i = 0 print ('Accuracies by Rank:') while i < rank_accuracies.shape[0]: print('Rank ', i+1, ' = %.2f%%' % (rank_accuracies[i] * 100), '\t', 'Rank ', i+2, ' = %.2f%%' % (rank_accuracies[i+1] * 100), '\t', 'Rank ', i+3, ' = %.2f%%' % (rank_accuracies[i+2] * 100), '\t', 'Rank ', i+4, ' = %.2f%%' % (rank_accuracies[i+3] * 100), '\t', 'Rank ', i+5, ' = %.2f%%' % (rank_accuracies[i+4] * 100)) i = i+5 AP = np.array(AP) mAP = AP.sum()/AP.shape[0] print('mAP = %.2f%%' % (mAP * 100)) return rank_accuracies, mAP
def standard_euclidean_dist(x, y, V): return distance.seuclidean(x, y, V)
import numpy as np from numpy import dot from scipy.spatial import distance A=np.array([200,10000,20]) B=np.array([150,20000,40]) x=np.vstack([A,B]) # # print(x.T.mean(axis=1)) s=np.std(x.T,axis=1,ddof=1) ##标准差 print(np.sqrt(np.sum(np.square((A-B)/s)))) print(distance.pdist(x,metric="seuclidean")) print(distance.cdist(np.array([A]),np.array([B]),metric="seuclidean")) print(distance.seuclidean(A,B,s**2))
def model_train(inp_file_train): train_axis, pca, scaler1, scaler2 = input_scale_pca_train(inp_file_train) # Find best number of clusters num_of_clusters = 2 + np.argmax( [silhouette_sc_kmeans(train_axis, i) for i in range(2, 10)]) print("KMeans training with {} clusters".format(num_of_clusters)) # Train model = KMeans(n_clusters=num_of_clusters, n_init=40) train_labels = model.fit_predict(train_axis) print("SS1 is {}".format( silhouette_score(train_axis, train_labels, metric='euclidean'))) # Preprocessing clusters train_axis, train_labels, num_of_clusters, outl_removed = pre_c( train_axis, train_labels, num_of_clusters) # Retrain model = KMeans(n_clusters=num_of_clusters, n_init=40) train_labels = model.fit_predict(train_axis) if num_of_clusters > 1: train_metr = silhouette_score(train_axis, train_labels, metric='euclidean') print("SS2 is {}".format(train_metr)) else: centroid = np.mean(train_axis, axis=0) train_md_samples = [] covmx = np.var(train_axis, axis=0) mi = covmx[covmx != 0].min() covmx = np.where(covmx == 0, mi, covmx) for x in range(len(train_axis)): train_md_samples.append( distance.seuclidean(train_axis[x, :], centroid, covmx)) train_md = np.mean(train_md_samples) train_metr = train_md print("Standrdized Euclidean distance is {}".format(train_md)) # Preprocessing outliers train_axis, train_labels, dev = pre_o(train_axis, train_labels, outl_removed, num_of_clusters, train_metr) num_of_clusters = len(set(train_labels)) # Retrain model = KMeans(n_clusters=num_of_clusters, n_init=40) train_labels = model.fit_predict(train_axis) if num_of_clusters > 1: train_metr = silhouette_score(train_axis, train_labels, metric='euclidean') print("SS3 is {}".format(train_metr)) else: centroid = np.mean(train_axis, axis=0) train_md_samples = [] covmx = np.var(train_axis, axis=0) mi = covmx[covmx != 0].min() covmx = np.where(covmx == 0, mi, covmx) for x in range(len(train_axis)): train_md_samples.append( distance.seuclidean(train_axis[x, :], centroid, covmx)) train_md = np.mean(train_md_samples) # std_md = np.std(train_md_samples) train_metr = train_md print("Standrdized Euclidean distance 3 is {}".format(train_md)) return num_of_clusters, train_axis, train_labels,\ model, dev, train_metr, pca, scaler1, scaler2
def exec_similarity(dct, algorithm): if validate_similarity_algorithms(dct, algorithm): return {} if algorithm == 'braycurtis': return [ answer.update({ algorithm: braycurtis(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'canberra': return [ answer.update({ algorithm: canberra(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'chebyshev': return [ answer.update({ algorithm: chebyshev(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'cityblock': return [ answer.update({ algorithm: cityblock(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'correlation': return [ answer.update({ algorithm: correlation(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'cosine': return [ answer.update({ algorithm: cosine(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'euclidean': return [ answer.update({ algorithm: euclidean(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'mahalanobis': return [ answer.update({ algorithm: mahalanobis(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] #elif algorithm is 'minkowski': #return [answer.update({algorithm:minkowski(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf']))}) for answer in dct['answers']] elif algorithm == 'seuclidean': return [ answer.update({ algorithm: seuclidean(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'sqeuclidean': return [ answer.update({ algorithm: sqeuclidean(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'wminkowski': return [ answer.update({ algorithm: wminkowski(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'dice': return [ answer.update({ algorithm: dice(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'hamming': return [ answer.update({ algorithm: hamming(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'jaccard': return [ answer.update({ algorithm: jaccard(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'kulsinski': return [ answer.update({ algorithm: kulsinski(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'rogerstanimoto': return [ answer.update({ algorithm: rogerstanimoto(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'russellrao': return [ answer.update({ algorithm: russellrao(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'sokalmichener': return [ answer.update({ algorithm: sokalmichener(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'sokalsneath': return [ answer.update({ algorithm: sokalsneath(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ] elif algorithm == 'yule': return [ answer.update({ algorithm: yule(ndarray_dict(dct['tf_idf']), ndarray_dict(answer['tf_idf'])) }) for answer in dct['answers'] ]
def findNeighbors(self, id, nos): for no in nos: if (distance.seuclidean(nos[id].position, no.position, [1, 1]) <= 1.5) and (nos[id].position is not no.position): nos[id].neighbors.append(no) pass
def evaluateTest(wv, reference, wordList): """Evaluate wv against reference, return (rho, count) where rwo is Spearman's rho and count is the number of reference word pairs that could be evaluated against. """ count = 0 counter = 0 gold, predicted = [], [] a = numpy.array(wv.values()) variance = numpy.var(a, axis=0) for words, sim in sorted(reference, key=lambda ws: ws[1]): try: v1, v2 = wv[words[0]], wv[words[1]] #print words[0],words[1] ,"\t",v1[0],"\t",v2[0] except KeyError: count += 1 continue gold.append((words, sim)) #print len(variance) weight = [0.5, 0.5] newSim = (cosine(v1, v2)) * weight[0] + 1 / distance.seuclidean( v1, v2, variance) * weight[1] predicted.append((words, cosine( v1, v2))) # this function have problem when v1 v2 are very similar # for i in range(1): # newSim=(cosine(v1, v2)) * weight[0] + 1/distance.seuclidean(v1,v2,variance) * weight[1] # dict1["newSim"].append((words, newSim)) # # # newSim=1/distance.seuclidean(v1,v2,variance) # dict1["seuclidean"].append((words, newSim)) # # newSim=1/distance.minkowski(v1,v2,3) # dict1["minkowski"].append((words, newSim)) # # newSim=1/distance.chebyshev(v1,v2) # dict1["chebyshev"].append((words, newSim)) # # newSim=1/distance.canberra(v1,v2) # dict1["canberra"].append((words, newSim)) # # newSim=1/distance.braycurtis(v1,v2) # dict1["braycurtis"].append((words, newSim)) # # newSim=1/distance.cityblock(v1,v2) # dict1["cityblock"].append((words, newSim)) # # newSim=(1-distance.correlation(v1,v2))/2 # dict1["correlation"].append((words, newSim)) # # newSim=1/distance.cosine(v1,v2) # dict1["cosine"].append((words, newSim)) # # newSim=1/distance.hamming(v1,v2) # dict1["hamming"].append((words, newSim)) # newSim=1/distance.euclidean(v1,v2) # dict1["Euclidean"].append((words, newSim)) # print words, newSim, distance.seuclidean(v1,v2,variance), cosine(v1, v2)\ # , distance.minkowski(v1,v2,3),distance.chebyshev(v1,v2) , distance.canberra(v1,v2),\ # distance.braycurtis(v1,v2),distance.cityblock(v1,v2),(1-distance.correlation(v1,v2))/2,\ # distance.cosine(v1,v2),distance.hamming(v1,v2),distance.euclidean(v1,v2) #print words[0],words[1],cosine(v1, v2) # if words[0].strip() in wordList.keys(): # words[0]= word in eva, wordList = word retrofitted # #print " intersection between keys:",words[0] # counter+=1 # targetList=wordList[words[0].strip()] # if words[1] in targetList: # print words[0],words[1],targetList #print words[0],"\t","\t".join(str(e) for e in wordList[words[0]]) print "intersection between updated word vector and Eva.Set: ", counter simlist = lambda ws: [s for w, s in ws] # for word,sim in gold: # print word,sim # for key,value in dict1.items(): # rho1, p = spearmanr(simlist(gold), simlist(value)) # print key,rho1 rho, p = spearmanr(simlist(gold), simlist(predicted)) print "Eva.item not found in WordVector:", count return (rho, len(gold))
def __call__(self, input, target): predictions, target = convert_to_numpy(input, target) predictions = predictions[0] target = target[0] global_thresh = threshold_otsu(predictions[0]) foreground = predictions > global_thresh local_max = skimage.feature.peak_local_max(predictions[0], min_distance=2) temp_max = np.zeros((1,48,128,128)) for i, each in enumerate(local_max): temp_max[0][each[0], each[1], each[2]] = i+1 inv_temp_max = np.logical_not(temp_max) dist_tr = ndimage.distance_transform_edt(inv_temp_max) # Thresh val. thresh_tr = dist_tr > 3 thresh_temp = np.logical_not(thresh_tr).astype(np.float64) extra = np.where(thresh_temp != foreground) thresh_temp[extra] = 0 watershed_output = watershed(thresh_temp, temp_max, mask=thresh_temp).astype(np.uint16) wshed_peaks = [] wshed = np.where(watershed_output[0]!=0) for wid, wval in enumerate(wshed[0]): wshed_peaks.append([wshed[0][wid], wshed[1][wid], wshed[2][wid]]) intersection_peaks = [] for each in local_max: z,y,x = each[0], each[1], each[2] for ws in wshed_peaks: wsz, wsy, wsx = ws[0], ws[1], ws[2] if z == wsz and y == wsy and x == wsx: intersection_peaks.append(ws) gt_foreground = np.where(target[0]==1.0) gt_coords = [] for idx, val in enumerate(gt_foreground[0]): gt_coords.append([gt_foreground[0][idx], gt_foreground[1][idx], gt_foreground[2][idx]]) eval_dict = {} for gtc in gt_coords: gt_z, gt_y, gt_x = gtc[0], gtc[1], gtc[2] eval_dict[(gt_z, gt_y, gt_x)] = {} for a, peak in enumerate(intersection_peaks): z, y, x = peak[0], peak[1], peak[2] std_euc = distance.seuclidean([gt_z, gt_y, gt_x], [z,y,x], [3.0,1.3,1.3]) if std_euc <= 6.0: #instance_label = watershed_output[0][wshed_peaks[a][0]][wshed_peaks[a][1]][wshed_peaks[a][2]] #eval_dict[gt_z, gt_y, gt_x][(z,y,x)] = {instance_label, std_euc} eval_dict[gt_z, gt_y, gt_x][(z,y,x)] = std_euc tp_count = 0 fn_count = 0 for k1, v1 in eval_dict.items(): if v1 != {}: tp_count += 1 #v1sorted = {k:v for k,v in sorted(v1.items(), key=lambda item: item[1])} #print(k1, v1sorted) else: fn_count += 1 print('Total GT peaks: 79') print('Prediction peaks after thresholding: ' + str(len(intersection_peaks))) print('Matched GT and peaks (TP): ' + str(tp_count)) # fn count -> print('No prediction peak for GT (FN): ' + str(fn_count)) # for k, v in eval_dict.items(): # print(k, v) eval_dict = {} fp_count = 0 tp_count = 0 for a, peak in enumerate(intersection_peaks): z, y, x = peak[0], peak[1], peak[2] eval_dict[(z, y, x)] = {} for gtc in gt_coords: gt_z, gt_y, gt_x = gtc[0], gtc[1], gtc[2] std_euc = distance.seuclidean([z,y,x], [gt_z, gt_y, gt_x], [3.0,1.3,1.3]) if std_euc <= 6.0: #instance_label = watershed_output[0][wshed_peaks[a][0]][wshed_peaks[a][1]][wshed_peaks[a][2]] #eval_dict[gt_z, gt_y, gt_x][(z,y,x)] = {instance_label, std_euc} eval_dict[z, y, x][(gt_z,gt_y,gt_x)] = std_euc for k1, v1 in eval_dict.items(): if v1 != {}: tp_count += 1 #v1sorted = {k:v for k,v in sorted(v1.items(), key=lambda item: item[1])} #print(k1, v1sorted) else: fp_count += 1 #print(k1) #print('' + tp_count) print('No GT for a peak (FP): ' + str(fp_count)) precision_val = self.precision(tp_count, fp_count) recall_val = self.recall(tp_count, fn_count) F1_score = 2 * precision_val * recall_val / (precision_val + recall_val) return torch.tensor(F1_score)
def main(): from scipy.spatial import distance a = np.array([1, 2, 43]) b = np.array([3, 2, 1]) d = Distance() print('-----------------------------------------------------------------') print('My braycurtis: {}'.format(d.braycurtis(a, b))) print('SciPy braycurtis: {}'.format(distance.braycurtis(a, b))) print('-----------------------------------------------------------------') print('My canberra: {}'.format(d.canberra(a, b))) print('SciPy canberra: {}'.format(distance.canberra(a, b))) print('-----------------------------------------------------------------') print('My chebyshev: {}'.format(d.chebyshev(a, b))) print('SciPy chebyshev: {}'.format(distance.chebyshev(a, b))) print('-----------------------------------------------------------------') print('My cityblock: {}'.format(d.cityblock(a, b))) print('SciPy cityblock: {}'.format(distance.cityblock(a, b))) print('-----------------------------------------------------------------') print('My correlation: {}'.format(d.correlation(a, b))) print('SciPy correlation: {}'.format(distance.correlation(a, b))) print('-----------------------------------------------------------------') print('My euclidean: {}'.format(d.euclidean(a, b))) print('SciPy euclidean: {}'.format(distance.euclidean(a, b))) print('-----------------------------------------------------------------') print('My hamming: {}'.format(d.hamming(a, b))) print('SciPy hamming: {}'.format(distance.hamming(a, b))) print('-----------------------------------------------------------------') print('My jaccard: {}'.format(d.jaccard(a, b))) print('SciPy jaccard: {}'.format(distance.jaccard(a, b))) print('-----------------------------------------------------------------') print('My manhattan: {}'.format(d.cityblock(a, b))) print('SciPy manhattan: {}'.format(distance.cityblock(a, b))) print('-----------------------------------------------------------------') print('My cosine: {}'.format(d.cosine(a, b))) print('SciPy cosine: {}'.format(distance.cosine(a, b))) print('-----------------------------------------------------------------') print('My dice: {}'.format(d.dice(a, b))) print('SciPy dice: {}'.format(distance.dice(a, b))) print('-----------------------------------------------------------------') print('My kulsinski: {}'.format(d.kulsinski(a, b))) print('SciPy kulsinski: {}'.format(distance.kulsinski(a, b))) print('-----------------------------------------------------------------') iv = np.array([[1, 0.5, 0.5], [0.5, 1, 0.5], [0.5, 0.5, 1]]) print('My mahalanobis: {}'.format(d.mahalanobis(a, b, iv))) print('SciPy mahalanobis: {}'.format(distance.mahalanobis(a, b, iv))) print('-----------------------------------------------------------------') print('My seuclidean: {}'.format( d.seuclidean(a, b, np.array([0.1, 0.1, 0.1])))) print('SciPy seuclidean: {}'.format( distance.seuclidean(a, b, [0.1, 0.1, 0.1]))) print('-----------------------------------------------------------------') print('My sokalmichener: {}'.format(d.sokalmichener(a, b))) print('SciPy sokalmichener: {}'.format(distance.sokalmichener(a, b))) print('-----------------------------------------------------------------') print('My sokal_sneath: {}'.format(d.sokalsneath(a, b))) print('SciPy sokal_sneath: {}'.format(distance.sokalsneath(a, b))) print('-----------------------------------------------------------------') print('My sqeuclidean: {}'.format(d.sqeuclidean(a, b))) print('SciPy sqeuclidean: {}'.format(distance.sqeuclidean(a, b))) print('-----------------------------------------------------------------') print('My minkowski: {}'.format(d.minkowski(a, b, 2))) print('SciPy minkowski: {}'.format(distance.minkowski(a, b, 2))) print('-----------------------------------------------------------------') print('My rogerstanimoto: {}'.format(d.rogerstanimoto(a, b))) print('SciPy rogerstanimoto: {}'.format(distance.rogerstanimoto(a, b))) print('-----------------------------------------------------------------') print('My russellrao: {}'.format(d.russellrao(a, b))) print('SciPy russellrao: {}'.format(distance.russellrao(a, b))) print('-----------------------------------------------------------------') print('My wminkowski: {}'.format(d.wminkowski(a, b, 2, np.ones(3)))) print('SciPy wminkowski: {}'.format( distance.wminkowski(a, b, 2, np.ones(3)))) print('-----------------------------------------------------------------') print('My yule: {}'.format(d.yule(a, b))) print('SciPy yule: {}'.format(distance.yule(a, b))) print('-----------------------------------------------------------------')
def evaluateTest(wv, reference,wordList): """Evaluate wv against reference, return (rho, count) where rwo is Spearman's rho and count is the number of reference word pairs that could be evaluated against. """ count=0 counter=0 gold, predicted = [], [] a = numpy.array(wv.values()) variance = numpy.var(a,axis=0) for words, sim in sorted(reference, key=lambda ws: ws[1]): try: v1, v2 = wv[words[0]], wv[words[1]] #print words[0],words[1] ,"\t",v1[0],"\t",v2[0] except KeyError: count+=1 continue gold.append((words, sim)) #print len(variance) weight=[0.5,0.5] newSim=(cosine(v1, v2)) * weight[0] + 1/distance.seuclidean(v1,v2,variance) * weight[1] predicted.append((words, cosine(v1, v2))) # this function have problem when v1 v2 are very similar # for i in range(1): # newSim=(cosine(v1, v2)) * weight[0] + 1/distance.seuclidean(v1,v2,variance) * weight[1] # dict1["newSim"].append((words, newSim)) # # # newSim=1/distance.seuclidean(v1,v2,variance) # dict1["seuclidean"].append((words, newSim)) # # newSim=1/distance.minkowski(v1,v2,3) # dict1["minkowski"].append((words, newSim)) # # newSim=1/distance.chebyshev(v1,v2) # dict1["chebyshev"].append((words, newSim)) # # newSim=1/distance.canberra(v1,v2) # dict1["canberra"].append((words, newSim)) # # newSim=1/distance.braycurtis(v1,v2) # dict1["braycurtis"].append((words, newSim)) # # newSim=1/distance.cityblock(v1,v2) # dict1["cityblock"].append((words, newSim)) # # newSim=(1-distance.correlation(v1,v2))/2 # dict1["correlation"].append((words, newSim)) # # newSim=1/distance.cosine(v1,v2) # dict1["cosine"].append((words, newSim)) # # newSim=1/distance.hamming(v1,v2) # dict1["hamming"].append((words, newSim)) # newSim=1/distance.euclidean(v1,v2) # dict1["Euclidean"].append((words, newSim)) # print words, newSim, distance.seuclidean(v1,v2,variance), cosine(v1, v2)\ # , distance.minkowski(v1,v2,3),distance.chebyshev(v1,v2) , distance.canberra(v1,v2),\ # distance.braycurtis(v1,v2),distance.cityblock(v1,v2),(1-distance.correlation(v1,v2))/2,\ # distance.cosine(v1,v2),distance.hamming(v1,v2),distance.euclidean(v1,v2) #print words[0],words[1],cosine(v1, v2) # if words[0].strip() in wordList.keys(): # words[0]= word in eva, wordList = word retrofitted # #print " intersection between keys:",words[0] # counter+=1 # targetList=wordList[words[0].strip()] # if words[1] in targetList: # print words[0],words[1],targetList #print words[0],"\t","\t".join(str(e) for e in wordList[words[0]]) print "intersection between updated word vector and Eva.Set: ", counter simlist = lambda ws: [s for w,s in ws] # for word,sim in gold: # print word,sim # for key,value in dict1.items(): # rho1, p = spearmanr(simlist(gold), simlist(value)) # print key,rho1 rho, p = spearmanr(simlist(gold), simlist(predicted)) print "Eva.item not found in WordVector:",count return (rho, len(gold))
inv_cov = np.linalg.pinv(sample_cov) condition_number = np.linalg.norm(sample_cov) * np.linalg.norm( inv_cov) # calc mahalanobis and SED distance to every reference vector mahal_dists = [] sed_dists = [] for ref in range(netvlad_ref_descriptors.shape[0]): # Vectorize! m_d = distance.mahalanobis(sample_mean, netvlad_ref_descriptors[ref], inv_cov) mahal_dists.append(m_d) # Standardized Euclidean Distance (SED) sed_dists.append( distance.seuclidean(sample_mean, netvlad_ref_descriptors[ref], np.var(samples, axis=0))) mahalanobis_distances.append(mahal_dists) sed_distances.append(sed_dists) if opt.netvlad: # netvlad mean images matching print('Euclidean Ranking: netvlad_mean_images') netvlad_mean_images = np.vstack(netvlad_mean_images) scores = np.dot(netvlad_ref_descriptors, netvlad_mean_images.T) ranks = np.argsort(-scores, axis=0) plt.matshow(scores) plt.savefig( os.path.join(opt.results_dir, "euclidean_similarities_images_mean.jpg"))