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"))
