def get_permute(W_r, H_r, W, H, coeff):
T_0 = W_r.shape[1]
T = W.shape[1]
comp = zeros((T_0, T))
for t in xrange(T):
p = sqrt(W_r) - sqrt(tile(W[:, t], (T_0, 1))).T
comp[:, t] = sum(p ** 2, 0)
if T < T_0:
t = array(linear_assignment(comp.T))[:, [1, 0]]
# http://stackoverflow.com/questions/2828059/sorting-arrays-in-numpy-by-column
return t[t[:, 0].argsort()]
else:
return array(linear_assignment(comp))
def best_map(l1, l2):
"""
Permute labels of l2 to match l1 as much as possible
"""
if len(l1) != len(l2):
print "L1.shape must == L2.shape"
exit(0)
label1 = np.unique(l1)
n_class1 = len(label1)
label2 = np.unique(l2)
n_class2 = len(label2)
n_class = max(n_class1, n_class2)
G = np.zeros((n_class, n_class))
for i in range(0, n_class1):
for j in range(0, n_class2):
ss = l1 == label1[i]
tt = l2 == label2[j]
G[i, j] = np.count_nonzero(ss & tt)
A = la.linear_assignment(-G)
new_l2 = np.zeros(l2.shape)
for i in range(0, n_class2):
new_l2[l2 == label2[A[i][1]]] = label1[A[i][0]]
return new_l2.astype(int)
def syntax_similarity_conversation(self, documents1, average=False): #syntax similarity of each document with its before and after document
global numnodes
documents1parsed = []
for d1 in range(len(documents1)):
sys.stderr.write(str(d1)+"\n")
# print documents1[d1]
tempsents = (self.sent_detector.tokenize(documents1[d1].strip()))
for s in tempsents:
if len(s.split())>100:
documents1parsed.append("NA")
break
else:
temp = list(self.parser.raw_parse_sents((tempsents)))
for i in range(len(temp)):
temp[i] = list(temp[i])[0]
temp[i] = ParentedTree.convert(temp[i])
documents1parsed.append(list(temp))
results = OrderedDict()
for d1 in range(len(documents1parsed)):
d2 = d1+1
if d2 == len(documents1parsed):
break
if documents1parsed[d1] == "NA" or documents1parsed[d2]=="NA":
continue
costMatrix = []
for i in range(len(documents1parsed[d1])):
numnodes = 0
tempnode = Node(documents1parsed[d1][i].root().label())
new_sentencedoc1 = self.convert_mytree(documents1parsed[d1][i],tempnode)
temp_costMatrix = []
sen1nodes = numnodes
for j in range(len(documents1parsed[d2])):
numnodes=0.0
tempnode = Node(documents1parsed[d2][j].root().label())
new_sentencedoc2 = self.convert_mytree(documents1parsed[d2][j],tempnode)
ED = simple_distance(new_sentencedoc1, new_sentencedoc2)
ED = ED / (numnodes + sen1nodes)
temp_costMatrix.append(ED)
costMatrix.append(temp_costMatrix)
costMatrix = np.array(costMatrix)
if average==True:
return 1-np.mean(costMatrix)
else:
indexes = su.linear_assignment(costMatrix)
total = 0
rowMarked = [0] * len(documents1parsed[d1])
colMarked = [0] * len(documents1parsed[d2])
for row, column in indexes:
total += costMatrix[row][column]
rowMarked[row] = 1
colMarked [column] = 1
for k in range(len(rowMarked)):
if rowMarked[k]==0:
total+= np.min(costMatrix[k])
for c in range(len(colMarked)):
if colMarked[c]==0:
total+= np.min(costMatrix[:,c])
maxlengraph = max(len(documents1parsed[d1]),len(documents1parsed[d2]))
results[(d1,d2)] = 1-total/maxlengraph#, minWeight/minlengraph, randtotal/lengraph
return results
def get_indexList(coord, coord_prev, indexListPrev, totWorms, max_allow_dist = 10.0):
#get the indexes of the next worms from their nearest neightbors using the hungarian algorithm
if coord_prev.size!=0:
costMatrix = cdist(coord_prev, coord);
assigment = linear_assignment(costMatrix)
indexList = np.zeros(coord.shape[0]);
speed = np.zeros(coord.shape[0])
for row, column in assigment: #ll = 1:numel(indexList)
if costMatrix[row,column] < max_allow_dist:
indexList[column] = indexListPrev[row];
speed[column] = costMatrix[row][column];
elif column < coord.shape[0]:
totWorms = totWorms +1;
indexList[column] = totWorms;
for rep_ind in list_duplicates(indexList):
totWorms = totWorms +1; #assign new worm_index to joined trajectories
indexList[rep_ind] = totWorms;
else:
indexList = totWorms + np.arange(1,coord.shape[0]+1);
totWorms = indexList[-1]
speed = totWorms*[None]
#print costMatrix[-1,-1]
return (totWorms, indexList, speed)
def assignment(costMatrix, costOfNonAssignment=140):
Assignment = namedtuple('Assignment', 'trackIndex detectionIndex')
assignments = []
unmatchedTracks = []
unmatchedDetections = []
# print(costMatrix)
# If matrix is rectangular, then pad
rows, cols = costMatrix.shape
diff = rows - cols
if diff != 0:
padValue = costOfNonAssignment + 1
if diff < 0:
pad_width = [(0, np.abs(diff)), (0, 0)]
if diff > 0:
pad_width = [(0, 0), (0, diff)]
costMatrix = np.pad(costMatrix, pad_width, mode='constant',
constant_values=(padValue, padValue))
# Compute the optimal assignment
assign = linear_assignment(costMatrix)
# Throw out any assignments that cost more than the costOfNonAssingment
for row in assign:
trackIndex = row[0]
detectionIndex = row[1]
if costMatrix[trackIndex, detectionIndex] > costOfNonAssignment:
if trackIndex < rows:
unmatchedTracks.append(trackIndex)
if detectionIndex < cols:
unmatchedDetections.append(detectionIndex)
else:
assignments.append(Assignment(trackIndex, detectionIndex))
return assignments, unmatchedTracks, unmatchedDetections
def track(self, original_img, filtered_img, prev_data):
n_objects = self.nObjectsSpinBox.value()
distance_threshold = self.distanceThresholdSpinBox.value()
if self.k_means is None:
self.k_means = cluster.KMeans(n_clusters=n_objects)
non_zero_pos = np.transpose(np.nonzero(filtered_img.T))
try:
center_pos = self.k_means.fit(non_zero_pos).cluster_centers_
except:
if self.ret_pos_old is None:
return {'position': np.full((n_objects, 2), np.nan)}
else:
return {'position': self.ret_pos_old}
if self.ret_pos_old is None:
self.ret_pos_old = center_pos.copy()
self.ret_pos = center_pos
else:
ret_pos_old_repeated = np.repeat(self.ret_pos_old, n_objects, axis=0)
center_pos_tiled = np.tile(center_pos, (n_objects, 1))
cost_mtx = np.linalg.norm(ret_pos_old_repeated - center_pos_tiled, axis=1)
cost_mtx = cost_mtx.reshape((n_objects, n_objects))
idx = linear_assignment(cost_mtx)
idx = idx[cost_mtx[idx[:,0], idx[:,1]]<=distance_threshold]
self.ret_pos[:] = self.ret_pos_old[:]
self.ret_pos[idx[:, 0], :] = center_pos[idx[:, 1], :]
self.ret_pos_old[:] = self.ret_pos[:].copy()
return {'position': self.ret_pos}
def syntax_similarity_two_documents(self, doc1, doc2, average=False): #syntax similarity of two single documents
global numnodes
doc1sents = self.sent_detector.tokenize(doc1.strip())
doc2sents = self.sent_detector.tokenize(doc2.strip())
for s in doc1sents: # to handle unusual long sentences.
if len(s.split())>100:
return "NA"
for s in doc2sents:
if len(s.split())>100:
return "NA"
try: #to handle parse errors. Parser errors might happen in cases where there is an unsuall long word in the sentence.
doc1parsed = self.parser.raw_parse_sents((doc1sents))
doc2parsed = self.parser.raw_parse_sents((doc2sents))
except Exception as e:
sys.stderr.write(str(e))
return "NA"
costMatrix = []
doc1parsed = list(doc1parsed)
for i in range(len(doc1parsed)):
doc1parsed[i] = list(doc1parsed[i])[0]
doc2parsed = list(doc2parsed)
for i in range(len(doc2parsed)):
doc2parsed[i] = list(doc2parsed[i])[0]
for i in range(len(doc1parsed)):
numnodes = 0
sentencedoc1 = ParentedTree.convert(doc1parsed[i])
tempnode = Node(sentencedoc1.root().label())
new_sentencedoc1 = self.convert_mytree(sentencedoc1,tempnode)
temp_costMatrix = []
sen1nodes = numnodes
for j in range(len(doc2parsed)):
numnodes=0.0
sentencedoc2 = ParentedTree.convert(doc2parsed[j])
tempnode = Node(sentencedoc2.root().label())
new_sentencedoc2 = self.convert_mytree(sentencedoc2,tempnode)
ED = simple_distance(new_sentencedoc1, new_sentencedoc2)
ED = ED / (numnodes + sen1nodes)
temp_costMatrix.append(ED)
costMatrix.append(temp_costMatrix)
costMatrix = np.array(costMatrix)
if average==True:
return 1-np.mean(costMatrix)
else:
indexes = su.linear_assignment(costMatrix)
total = 0
rowMarked = [0] * len(doc1parsed)
colMarked = [0] * len(doc2parsed)
for row, column in indexes:
total += costMatrix[row][column]
rowMarked[row] = 1
colMarked [column] = 1
for k in range(len(rowMarked)):
if rowMarked[k]==0:
total+= np.min(costMatrix[k])
for c in range(len(colMarked)):
if colMarked[c]==0:
total+= np.min(costMatrix[:,c])
maxlengraph = max(len(doc1parsed),len(doc2parsed))
return 1-(total/maxlengraph)
def get_deci_map(self, state_map, w, dnum, tnum):
score_mat = state_map.dot(w)
match_idxs = linear_assignment(-score_mat)
deci_map = np.zeros_like(score_mat)
for m in match_idxs:
if m[0]<dnum or m[1]<tnum:
deci_map[m[0],m[1]] = 1
return match_idxs, deci_map
def accuracy(l,lg):
profitMatrix = confusion_matrix(lg,l)
costMatrix = np.iinfo(np.int64).max - profitMatrix
ind = linear_assignment(costMatrix)
total = 0.0
for i in ind:
total += profitMatrix[tuple(i)]
return total / lg.shape[0]
def calcAssignMtx(self):
idx = linear_assignment(self.costMtx)
if self.assignMtx is None:
self.assignMtx = np.zeros((self.N, self.M))
else:
self.assignMtx[:] = 0
self.assignMtx[idx[:, 0], idx[:,1]] = 1
def accuracy(l,lg):
profitMatrix = confusion_matrix(lg, l)
costMatrix = lg.shape[0] - profitMatrix
ind = linear_assignment(costMatrix)
total = 0.0
for i in ind:
total += profitMatrix[i[0],i[1]]
return total / lg.shape[0]
def ceafe(clusters, gold_clusters):
clusters = [c for c in clusters if len(c) != 1]
scores = np.zeros((len(gold_clusters), len(clusters)))
for i in range(len(gold_clusters)):
for j in range(len(clusters)):
scores[i, j] = phi4(gold_clusters[i], clusters[j])
matching = linear_assignment(-scores)
similarity = sum(scores[matching[:, 0], matching[:, 1]])
return similarity, len(clusters), similarity, len(gold_clusters)
def cluster_acc(Y_pred, Y):
from sklearn.utils.linear_assignment_ import linear_assignment
assert Y_pred.size == Y.size
D = max(Y_pred.max(), Y.max())+1
w = np.zeros((D,D), dtype=np.int64)
for i in range(Y_pred.size):
w[Y_pred[i], Y[i]] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i,j] for i,j in ind])*1.0/Y_pred.size, w
def match_detections(self, old_dets, new_dets, iou_threshold):
if len(old_dets) == 0 or len(new_dets) == 0:
return []
iou_cost = np.array(
[[iou(old, new) for new in new_dets] for old in old_dets],
'float32'
)
match_pairs = linear_assignment(-iou_cost)
return match_pairs
def linear_assignment(df):
"""Wrapper of sklearn linear assignment algorithm for DataFrame cost matrix. Returns
DataFrame with columns for matched labels. Minimizes cost.
"""
from sklearn.utils.linear_assignment_ import linear_assignment
x = linear_assignment(df.as_matrix())
y = zip(df.index[x[:, 0]], df.columns[x[:, 1]])
df_out = pd.DataFrame(y, columns=[df.index.name, df.columns.name])
return df_out
def solve_matching(num_cluster, old_cluster, new_cluster):
"""Solves the hungarian matching based on the non-overlapping words."""
cost_matrix = np.array([[.0]*num_cluster]*num_cluster)
# cost_matrix = cost_matrix.astype(np.float32)
for i in old_cluster:
for j in new_cluster:
cost_matrix[i][j] = count_non_overlapping(old_cluster[i], new_cluster[j])
# import ipdb; ipdb.set_trace()
assignments = hungarian.linear_assignment(cost_matrix)
mapping = {}
for i in xrange(assignments.shape[0]):
# mapping[i] = assignments[i, 1]
mapping[assignments[i, 1]] = i
return mapping
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(trackers) == 0):
return np.empty((0, 2), dtype=int), np.arange(len(detections)), \
np.empty((0, 5), dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# filter out matched with low IOU
matches = []
for m in matched_indices:
is_matched = (iou_matrix[m[0], m[1]] < iou_threshold)
# @mhsung
if (detections.shape[1] >= 6 and trackers.shape[1] >= 6):
# det: [x0, y0, x1, y2, score, class_index, ...]
# If class indices are given, bboxes with the same class index are
# only matched.
det_cls = detections[m[0], 5]
trk_cls = trackers[m[0], 5]
is_matched = is_matched and (det_cls == trk_cls)
if is_matched:
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
def associate_detections_to_trackers(
detections, trackers, distance_threshold=0.3):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if(len(trackers) == 0):
return np.empty((0, 2), dtype=int), np.arange(
len(detections)), np.empty((0, 6), dtype=int)
distance_matrix = np.zeros(
(len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
distance_matrix[d, t] = distance(det, trk)
print('distance of new det:{} to tracker {} = {}'.format(
d, t, distance_matrix[d, t]))
# warnings.warn(str(distance_matrix))
# warnings.warn('tracking')
matched_indices = linear_assignment(-distance_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if(d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if(t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# filter out matched with low distance
matches = []
for m in matched_indices:
if(distance_matrix[m[0], m[1]] < distance_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if(len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(
unmatched_detections), np.array(unmatched_trackers)
def __init__(self, boxes1, boxes2, labels1=None, labels2=None):
self._boxes1 = boxes1
self._boxes2 = boxes2
if len(boxes1) == 0 or len(boxes2) == 0:
pass
else:
if labels1 is None or labels2 is None:
self._iou_matrix = self._calc(boxes1,
boxes2,
np.ones((len(boxes1),)),
np.ones((len(boxes2),)))
else:
self._iou_matrix = self._calc(boxes1, boxes2, labels1, labels2)
self._match_pairs = linear_assignment(-1*self._iou_matrix)
def ceafe(clusters, gold_clusters):
"""
Computes the Constrained EntityAlignment F-Measure (CEAF) for evaluating coreference.
Gold and predicted mentions are aligned into clusterings which maximise a metric - in
this case, the F measure between gold and predicted clusters.
<https://www.semanticscholar.org/paper/On-Coreference-Resolution-Performance-Metrics-Luo/de133c1f22d0dfe12539e25dda70f28672459b99>
"""
clusters = [cluster for cluster in clusters if len(cluster) != 1]
scores = np.zeros((len(gold_clusters), len(clusters)))
for i, gold_cluster in enumerate(gold_clusters):
for j, cluster in enumerate(clusters):
scores[i, j] = Scorer.phi4(gold_cluster, cluster)
matching = linear_assignment(-scores)
similarity = sum(scores[matching[:, 0], matching[:, 1]])
return similarity, len(clusters), similarity, len(gold_clusters)
def get_optimal_permutation(a, b, k):
"""Finds an optimal permutation `p` of the elements in b to match a,
using the Hungarian algorithm, such that `a ~ p(b)`. `k` specifies the
number of possible labels, in case they're not all present in `a` or `b`.
"""
assert(a.shape == b.shape)
# if we're testing against ground truth, then we need to store a bigger
# matrix
n = max(len(np.unique(a)), len(np.unique(b)), k)
w = np.zeros((n, n), dtype=int)
for i, j in zip(a, b):
w[i, j] += 1
# make it a cost matrix
w = np.max(w) - w
# minimize the cost -- transpose because we want a map from `b` to `a`
permutation = linear_assignment(w.T)
return permutation[:, 1]
def cluster_acc(y_true, y_pred):
'''
Uses the hungarian algorithm to find the best permutation mapping and then calculates the accuracy wrt
Implementation inpired from https://github.com/piiswrong/dec, since scikit does not implement this metric
this mapping and true labels
:param y_true: True cluster labels
:param y_pred: Predicted cluster labels
:return: accuracy score for the clustering
'''
D = int(max(y_pred.max(), y_true.max()) + 1)
w = np.zeros((D, D), dtype=np.int32)
for i in range(y_pred.size):
idx1 = int(y_pred[i])
idx2 = int(y_true[i])
w[idx1, idx2] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / y_pred.size
def extract_gt_decision(self,gt,dets,img,appl=True,thres=0.05):
dnum, tnum = len(dets), len(self.targetlst)
deci_map = np.zeros((dnum+2*tnum,tnum+2*dnum))
gtnum = len(gt)
det_gt_mat = np.empty((dnum,gtnum))
for i in range(dnum):
for j in range(gtnum):
det_gt_mat[i,j] = iou(dets[i],gt[j][2:6])
det_gt_matches = linear_assignment(-det_gt_mat)
det_gt_matches = [m for m in det_gt_matches if det_gt_mat[m[0],m[1]]>thres]
gt_taridx_lst = gt[:,1].tolist()
gt_idxs, det_idxs = range(gtnum), range(dnum)
### match or initialize
curlst = [t.idx for t in self.targetlst]
for m in det_gt_matches:
#x1,y1,x2,y2 = gt[m[1],2:6]
x1,y1,x2,y2 = dets[m[0],:4]
x1,y1,x2,y2 = int(x1), int(y1),int(x2),int(y2)
if gt[m[1],1] in curlst: ### match
tidx = curlst.index(gt[m[1],1])
deci_map[m[0],tidx] = 1
if appl: self.targetlst[tidx].update([x1,y1,x2,y2], img[y1:y2,x1:x2])
else: ### initialize
targetidx = gt[m[1],1]
target = TrackedTarget(targetidx, [x1,y1,x2,y2], patch=img[y1:y2,x1:x2])
if appl: self.targetlst.append(target)
deci_map[m[0],tnum+dnum+m[0]] = 1
matched_det_lst = [m[0] for m in det_gt_matches]
for i in range(dnum):
if i not in matched_det_lst: ### drop
deci_map[i,tnum+i] = 1
matched_gt_lst = [m[1] for m in det_gt_matches]
for j,gtidx in enumerate(gt_taridx_lst):
if j not in matched_gt_lst: ### miss
if gtidx in curlst:
i = curlst.index(gtidx)
deci_map[dnum+i,i] = 1
#if not in curlst: forget it, initialize it next frame
for i,tidx in enumerate(curlst):
if tidx not in gt_taridx_lst:
self.targetlst[i].state = 'gone'
deci_map[dnum+tnum+i,i] = 1
if appl: self.targetlst = [target for target in self.targetlst if target.state!='gone']
return deci_map
def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if(len(trackers)==0):
return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)
iou_matrix = np.zeros((len(detections),len(trackers)),dtype=np.float32)
id_matrix = np.zeros((len(detections),len(trackers)),dtype=np.float32)
scale_id = 0.5
for d,det in enumerate(detections):
for t,trk in enumerate(trackers):
trackBox = convert_kfx_to_bbox(trk.kf.x[:4])[0]
iou_matrix[d,t] = bbox_iou(trackBox, det)
id_matrix[d,t] = scale_id*det[4]
matched_indices = linear_assignment(-iou_matrix-id_matrix)
unmatched_detections = []
for d,det in enumerate(detections):
if(d not in matched_indices[:,0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t,trk in enumerate(trackers):
if(t not in matched_indices[:,1]):
unmatched_trackers.append(t)
#filter out matched with low probability
matches = []
for m in matched_indices:
if(iou_matrix[m[0],m[1]]<iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1,2))
if(len(matches)==0):
matches = np.empty((0,2),dtype=int)
else:
matches = np.concatenate(matches,axis=0)
return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
def mean_recall(gt_groups, groups):
"""
Compute the mean recall.
:param gt_groups: set of ground truth groups
:param groups: set of tested groups
:return: mean recall
"""
if not groups:
return 0, 0
conf = confusion_matrix(gt_groups, groups)
idx = hungarian.linear_assignment(conf.max() - conf)
matches = np.array([conf[i[0], i[1]] for i in idx])
gt_sizes = np.array([size(gt_groups[i[0]]) for i in idx])
recall = matches / gt_sizes
return np.sum(recall) / len(gt_groups)
def k_means_algo(data_no_label, label_values, k):
try:
data_no_label = data_no_label.transpose()
k_means = KMeans(n_clusters=k)
k_means.fit(data_no_label)
labels_from_kmeans = k_means.labels_
print('K means labels', labels_from_kmeans)
C = confusion_matrix(y_true=label_values, y_pred=labels_from_kmeans)
print('Confusion matrix is: ', C)
C = C.T
ind = linear_assignment(-C)
C_opt = C[:, ind[:, 1]]
print('re ordered matrix', C_opt)
acc_opt = np.trace(C_opt) / np.sum(C_opt)
accuracy = cluster_acc(label_values, labels_from_kmeans)
print('accuracy of k means is:', accuracy * 100)
except Exception as e:
print(e)
def allignCLus2(cl1, cl2):
y_true, y_pred = cl1, cl2
Y_pred = y_pred
Y = y_true
from sklearn.utils.linear_assignment_ import linear_assignment
assert Y_pred.size == Y.size
D = max(Y_pred.max(), Y.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(Y_pred.size):
w[Y_pred[i], Y[i]] += 1
ind = linear_assignment(w.max() - w)
DD = {}
for i, j in ind:
DD[j] = i
newCl = []
for i in cl1:
newCl.append(DD[i])
return np.array(newCl)
def evaluate_clusters(self, gold_clusters, auto_clusters):
def phi4(c1, c2):
return 2 * len([m for m in c1 if m in c2
]) / float(len(c1) + len(c2))
# enable ceaf to deal with singletons
# auto_clusters = [c for c in auto_clusters if len(c) != 1]
scores = np.zeros((len(gold_clusters), len(auto_clusters)))
for i in range(len(gold_clusters)):
for j in range(len(auto_clusters)):
scores[i, j] = phi4(gold_clusters[i], auto_clusters[j])
matching = linear_assignment(-scores)
similarity = float(sum(scores[matching[:, 0], matching[:, 1]]))
p = similarity / len(auto_clusters) if similarity else 0.0
r = similarity / len(gold_clusters) if similarity else 0.0
return p, r, self.f1_score(p, r)
def cluster_acc(y_true, y_pred):
"""
Calculate clustering accuracy. Require scikit-learn installed
# Arguments
y: true labels, numpy.array with shape `(n_samples,)`
y_pred: predicted labels, numpy.array with shape `(n_samples,)`
# Return
accuracy, in [0,1]
"""
y_true = y_true.astype(np.int64)
assert y_pred.size == y_true.size
D = max(y_pred.max(), y_true.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(y_pred.size):
w[y_pred[i], y_true[i]] += 1
from sklearn.utils.linear_assignment_ import linear_assignment
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / y_pred.size
def match_detections_to_trackers(trackers, detections, min_iou=0.25):
IOU_mat = np.zeros((len(trackers), len(detections)), dtype=np.float32)
for t, trk in enumerate(trackers):
#trk = convert_to_cv2bbox(trk)
for d, det in enumerate(detections):
# det = convert_to_cv2bbox(det)
IOU_mat[t, d] = src.helpers.box_iou2(trk, det)
# Produces matches
# Solve the maximizing the sum of IOU assignment problem using the
# Hungarian algorithm (also known as Munkres algorithm)
matched_idx = linear_assignment(-IOU_mat)
unmatched_trackers, unmatched_detections = [], []
for t, trk in enumerate(trackers):
if (t not in matched_idx[:, 0]):
unmatched_trackers.append(t)
for d, det in enumerate(detections):
if (d not in matched_idx[:, 1]):
unmatched_detections.append(d)
matches = []
# For creating trackers we consider any detection with an
# overlap less than min_iou to signifiy the existence of
# an untracked object
for m in matched_idx:
if (IOU_mat[m[0], m[1]] < min_iou):
unmatched_trackers.append(m[0])
unmatched_detections.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.25):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(trackers) == 0):
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5),
dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
'''The linear assignment module tries to minimise the total assignment cost.
In our case we pass -iou_matrix as we want to maximise the total IOU between track predictions and the frame detection.'''
print(iou_matrix)
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# filter out matched with low IOU
matches = []
for m in matched_indices:
if (iou_matrix[m[0], m[1]] < iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def match_detections_to_trackers(trackers, detections, min_iou=0.25):
# Initialize 'iou_matrix'
iou_matrix = np.zeros((len(trackers), len(detections)),
dtype=np.float32)
# Populate 'iou_matrix'
for t, tracker in enumerate(trackers):
for d, detection in enumerate(detections):
iou_matrix[t, d] = box_iou_ratio(tracker, detection)
# Produce matches by using the Hungarian algorithm to maximize the sum of IOU
matched_index = linear_assignment(-iou_matrix)
# Populate 'unmatched_trackers'
unmatched_trackers = []
for t in np.arange(len(trackers)):
if t not in matched_index[:, 0]:
unmatched_trackers.append(t)
# Populate 'unmatched_detections'
unmatched_detections = []
for d in np.arange(len(detections)):
if d not in matched_index[:, 1]:
unmatched_detections.append(d)
# Populate 'matches'
matches = []
for m in matched_index:
# Create tracker if IOU is greater than 'min_iou'
if iou_matrix[m[0], m[1]] > min_iou:
matches.append(m.reshape(1, 2))
else:
unmatched_trackers.append(m[0])
unmatched_detections.append(m[1])
if matches:
# Concatenate arrays on the same axis
matches = np.concatenate(matches, axis=0)
else:
matches = np.empty((0, 2), dtype=int)
# Return matches, unmatched detection and unmatched trackers
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def associate_detections_to_trackers(detections,trackers,iou_threshold=0.1):
# def associate_detections_to_trackers(detections,trackers,iou_threshold=0.01): # ablation study
# def associate_detections_to_trackers(detections,trackers,iou_threshold=0.25):
"""
Assigns detections to tracked object (both represented as bounding boxes)
detections: N x 8 x 3
trackers: M x 8 x 3
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if(len(trackers)==0):
return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,8,3),dtype=int)
iou_matrix = np.zeros((len(detections),len(trackers)),dtype=np.float32)
for d,det in enumerate(detections):
for t,trk in enumerate(trackers):
iou_matrix[d,t] = iou3d(det,trk)[0] # det: 8 x 3, trk: 8 x 3
# print(iou_matrix)
matched_indices = linear_assignment(-iou_matrix) # hougarian algorithm
unmatched_detections = []
for d,det in enumerate(detections):
if(d not in matched_indices[:,0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t,trk in enumerate(trackers):
if(t not in matched_indices[:,1]):
unmatched_trackers.append(t)
#filter out matched with low IOU
matches = []
for m in matched_indices:
if(iou_matrix[m[0],m[1]]<iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1,2))
if(len(matches)==0):
matches = np.empty((0,2),dtype=int)
else:
matches = np.concatenate(matches,axis=0)
return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
"""Assigns detections to tracked object with
Apply Hungarian algorithm by linear_assignment from sklearn
Returns (matches, unmatched_detections, unmatched_tackers)
"""
if len(trackers) == 0:
return (np.empty((0, 2), dtype=int), np.arange(len(detections)),
np.empty((0, 5), dtype=int))
# row: detection, col: trackers
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
matched_indices = linear_assignment(-iou_matrix)
# records unmatched detection indices
unmatched_detections = []
for d, det in enumerate(detections):
if d not in matched_indices[:, 0]:
unmatched_detections.append(d)
# records unmatched trackers indices
unmatched_trackers = []
for t, trk in enumerate(trackers):
if t not in matched_indices[:, 1]:
unmatched_trackers.append(t)
# filter out matched with low IOU
matches = []
for m in matched_indices:
if iou_matrix[m[0], m[1]] < iou_threshold:
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if len(matches) == 0:
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return (matches, np.array(unmatched_detections),
np.array(unmatched_trackers))
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
"""(numpy.array, numpy.array, int) -> numpy.array, numpy.array, numpy.array
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(trackers) == 0):
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 4),
dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
matches = []
for m in matched_indices:
if (iou_matrix[m[0], m[1]] < iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def associate_detections_to_trackers_embedding(self,
detections,
track_list,
distance_threshold=2):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(track_list) == 0):
return np.empty((0, 2),
dtype=int), np.arange(len(detections)), np.empty(
(0, 5), dtype=int)
distance_matrix = np.zeros((len(detections), len(track_list)),
dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(track_list):
distance_matrix[d, t] = self.distance(det, trk)
matched_indices = linear_assignment(distance_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_track_list = []
for t, trk in enumerate(track_list):
if (t not in matched_indices[:, 1]):
unmatched_track_list.append(t)
#filter out matched with high distance
matches = []
for m in matched_indices:
if (distance_matrix[m[0], m[1]] > distance_threshold):
unmatched_detections.append(m[0])
unmatched_track_list.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_track_list)
def data_association(
self,
detections,
frame,
iou_threshold=0
): #人愈小 threshold值要愈小，總之threshold值愈小就辨識新物體更難，threshold值愈大辨識到新物體更容易
iou_matrix = np.zeros((len(detections), len(self.trackers)),
dtype=np.float32)
# self.predict_update(frame)
for o, obj in enumerate(detections):
for t, trk in enumerate(self.trackers):
iou_matrix[o, t] = self.IOU(
obj, trk.bbox) #計算每個trk與obj的IOU並且將值存在iou_matrix裡面(依編號存)
# print("iou_matrix")
# print(iou_matrix)
matched_indices = linear_assignment(-iou_matrix)
# print("matched_indices")
# print(matched_indices)
usedDections = set()
usedTrackers = set()
matches = []
for m in matched_indices: #m [dect, trk]
if (iou_matrix[m[0], m[1]] > iou_threshold):
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0) #令matches作為一個個row排序這樣
assignment = list()
for i in range(len(self.trackers)):
# print("i:{}".format(i))
assignment.append(-1)
for match in matches:
if match[1] in usedTrackers or match[0] in usedDections:
continue
assignment[match[1]] = match[0]
usedDections.add(match[0])
usedTrackers.add(match[1])
unusedTrackers = set(range(0, len(
self.trackers))).difference(usedTrackers)
for ID in unusedTrackers:
self.trackers[ID].skipped_frames += 1
return assignment
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(trackers) == 0):
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5),
dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
# Solve assignment problem via Hungarian algo.
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# Filter out matched with low IOU
matches = []
for m in matched_indices:
# print(iou_matrix[m[0],m[1]])
if (iou_matrix[m[0], m[1]] < iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.2):
"""
将检测框BBox和卡尔曼的预测框BBox进行匹配
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(trackers) == 0):
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5),
dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections): # 遍历每个检测框BBox，每个BBox标识为d
for t, trk in enumerate(trackers): # 遍历卡尔曼预测框BBox，每个BBox标识为t
iou_matrix[d, t] = iou(det, trk)
matched_indices = linear_assignment(-iou_matrix) # 通过匈牙利匹配算法进行匹配，得对成功匹配的对
unmatched_detections = []
for d, det in enumerate(
detections): # 没能成功匹配的检测框BBox放入unmatched_detections，用于判断目标新增
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = [] # 没能成功匹配的预测框BBox放入unmatched_trackers，用于判断目标删除
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# filter out matched with low IOU，将匹配的IOU过小的检测框和预测框进行过滤
matches = [] # 最终成功匹配的放入matches
for m in matched_indices:
if (iou_matrix[m[0], m[1]] < iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def match(self, tracks, detections):
""" """
if(len(tracks) == 0):
return np.empty((0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5), dtype=int)
# Create the cost matrix
C = np.zeros((len(detections), len(tracks)), dtype=np.float32)
# Compute the cost matrix
for d, det in enumerate(detections):
for t, trk in enumerate(tracks):
C[d, t] = self.cost_metric(det, trk)
# Run the optimization problem
M = linear_assignment(C)
unmatched_detections = []
for d, det in enumerate(detections):
if(d not in M[:, 0]):
unmatched_detections.append(d)
unmatched_tracks = []
for t, trk in enumerate(tracks):
if(t not in M[:, 1]):
unmatched_tracks.append(t)
matches = []
for m in M:
if self.max_distance is None:
matches.append(m.reshape(1, 2))
else:
if(C[m[0], m[1]] > self.max_distance):
unmatched_detections.append(m[0])
unmatched_tracks.append(m[1])
else:
matches.append(m.reshape(1, 2))
if(len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(unmatched_tracks)
def associate_detections_to_trackers(detections,
trackers,
conf_threshold=0.95):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if (len(trackers) == 0):
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5),
dtype=int)
dist_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
dist_matrix[d, t] = mahab_dist(trk, det)
matched_indices = linear_assignment(dist_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# filter out matched with low IOU
matches = []
gate = chi2.ppf(conf_threshold, df=2)
for m in matched_indices:
if dist_matrix[m[0], m[1]] > gate:
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def start(filename, k):
data = []
with open(filename) as f:
for line in f:
row = line[:-1].split(',')
data.append(row)
Y = np.array(data[0], dtype='int')
X = np.array(data[1:]).transpose().tolist()
predicted_labels = form_cluster(X, k)
C = confusion_matrix(Y, predicted_labels)
C = C.T
ind = linear_assignment(-C)
C_opt = C[:, ind[:, 1]]
acc_opt = np.trace(C_opt) / np.sum(C_opt)
print(acc_opt)
def cluster_acc(y_true, y_pred):
"""
Computes clustering accuracy.
Args:
y_true ([type]): [description]
y_pred ([type]): [description]
Returns:
[type]: [description]
"""
y_true = y_true.astype(np.int64)
assert y_pred.size == y_true.size
D = max(y_pred.max(), y_true.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(y_pred.size):
w[y_pred[i], y_true[i]] += 1
from sklearn.utils.linear_assignment_ import linear_assignment
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / y_pred.size
def unsupervised_clustering_accuracy(y, y_pred):
"""
Unsupervised Clustering Accuracy
Author: scVI
https://github.com/YosefLab/scVI/blob/a585f7d096f04ab0d50cadfdf8c2c9f78d907c19/scvi/inference/posterior.py#L637
"""
# from scipy.optimize import linear_sum_assignment
from sklearn.utils.linear_assignment_ import linear_assignment
assert len(y_pred) == len(y)
u = np.unique(np.concatenate((y, y_pred)))
n_clusters = len(u)
mapping = dict(zip(u, range(n_clusters)))
reward_matrix = np.zeros((n_clusters, n_clusters), dtype=np.int64)
for y_pred_, y_ in zip(y_pred, y):
if y_ in mapping:
reward_matrix[mapping[y_pred_], mapping[y_]] += 1
cost_matrix = reward_matrix.max() - reward_matrix
ind = linear_assignment(cost_matrix)
return sum([reward_matrix[i, j] for i, j in ind]) * 1.0 / y_pred.size, ind
def _hungarian_match(flat_preds, flat_targets, num_samples, class_num):
num_k = class_num
num_correct = np.zeros((num_k, num_k))
for c1 in range(0, num_k):
for c2 in range(0, num_k):
# elementwise, so each sample contributes once
votes = int(((flat_preds == c1) * (flat_targets == c2)).sum())
num_correct[c1, c2] = votes
# num_correct is small
match = linear_assignment(num_samples - num_correct)
# return as list of tuples, out_c to gt_c
res = []
for out_c, gt_c in match:
res.append((out_c, gt_c))
return res
def acc(y_true, y_pred):
"""
https://github.com/XifengGuo/DEC-keras/blob/master/metrics.py
Calculate clustering accuracy. Require scikit-learn installed
# Arguments
y: true labels, numpy.array with shape `(n_samples,)`
y_pred: predicted labels, numpy.array with shape `(n_samples,)`
# Return
accuracy, in [0,1]
"""
y_true = y_true.astype(np.int64)
assert y_pred.size == y_true.size
D = max(y_pred.max(), y_true.max()) + 1
w = np.zeros((D, D), dtype=np.int64)
for i in range(y_pred.size):
w[y_pred[i], y_true[i]] += 1
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / y_pred.size
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
"""
tracking object(둘 다 bounding box)에 detection을 지정합니다.
unmatched_detections 및 unmatched_trackers와 match 3 개의 목록을 반환합니다.
"""
# 추적 하는게 없다면 반환
if (len(trackers) == 0) or (len(detections) == 0):
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5),
dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
# Hungarian Algorithm
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
#filter out matched with low IOU
matches = []
for m in matched_indices:
if (iou_matrix[m[0], m[1]] < iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def LAP_iou_sklearn(detections, trackers, threshold):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Hungarian algorithm
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
# todo delete line
val = False
if (len(trackers) == 0):
return np.empty((0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5), dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou(det, trk)
matched_indices = linear_assignment(-iou_matrix) # [row,col]
unmatched_detections = []
for d, det in enumerate(detections):
if (d not in matched_indices[:, 0]):
unmatched_detections.append(d)
unmatched_trackers = []
for t, trk in enumerate(trackers):
if (t not in matched_indices[:, 1]):
unmatched_trackers.append(t)
# filter out matched with low IOU
matches = []
for m in matched_indices:
if (iou_matrix[m[0], m[1]] < threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if (len(matches) == 0):
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
if len(trackers) == 0:
return np.empty(
(0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5),
dtype=int)
iou_matrix = np.zeros((len(detections), len(trackers)), dtype=np.float32)
for d, det in enumerate(detections):
for t, trk in enumerate(trackers):
iou_matrix[d, t] = iou_tracker(trk, det)
# Solve the linear assignment problem using the Hungarian algorithm
# The problem is also known as maximum weight matching in bipartite graphs. The method is also known as the
# Munkres or Kuhn-Munkres algorithm.
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d, det in enumerate(detections):
if d not in matched_indices[:, 0]:
unmatched_detections.append(d) # store index
unmatched_trackers = []
for t, trk in enumerate(trackers):
if t not in matched_indices[:, 1]:
unmatched_trackers.append(t) # store index
matches = []
for m in matched_indices:
if iou_matrix[m[0], m[1]] < iou_threshold:
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1, 2))
if len(matches) == 0:
matches = np.empty((0, 2), dtype=int)
else:
matches = np.concatenate(matches, axis=0)
return matches, np.array(unmatched_detections), np.array(
unmatched_trackers)
def rarUdet(udet, q1=1, q2=0):
iomatrix = np.zeros((len(udet), len(udet)))
for i in range(len(udet)):
for j in range(len(udet)):
if udet[i, q1, 0] != 0 and udet[j, q2, 0] != 0 and udet[
i, q2, 0] == 0 and udet[j, q1, 0] == 0:
iomatrix[i, j] = bbox_iou2(udet[i, q1, :4], udet[j, q2, :4])
iomatrix[iomatrix[:, :] < 0.6] = 0
matched_indices = linear_assignment(-iomatrix)
dop_1a = np.count_nonzero(iomatrix, 1)
dop_1b = np.count_nonzero(iomatrix, 0)
dop_2 = np.nonzero(iomatrix)
list_to_del = []
if len(dop_2) > 0:
num = len(dop_2[0])
for i in range(num):
ind_i = dop_2[0][i]
ind_j = dop_2[1][i]
if dop_1a[ind_i] == 1 and dop_1b[ind_j] == 1:
udet[ind_j, q1, :] = udet[ind_i, q1, :]
#udet[ind_i, q2, :] = udet[ind_j, q2, :]
list_to_del.append(ind_i)
if dop_1a[ind_i] > 1:
j = matched_indices[np.where(matched_indices[:,
0] == ind_i)[0],
1]
udet[j, q1, :] = udet[ind_i, q1, :]
list_to_del.append(ind_i)
# if dop_1b[ind_j] > 1:
# i = matched_indices[np.where(matched_indices[:, 1] == ind_j)[0], 0]
# udet[j, q1, :] = udet[ind_i, q1, :]
# list_to_del.append(ind_i)
ls = list(set(list_to_del))
ls.sort()
for i in ls[::-1]:
udet = np.delete(udet, i, 0)
return udet
def optimal_permutation(X, Y):
"""Compute the optmal permutation matrix of X toward Y
Parameters
----------
X: (n_samples, n_features) nd array
source data
Y: (n_samples, n_features) nd array
target data
Returns
----------
permutation : (n_features, n_features) nd array
transformation matrix
"""
dist = pairwise_distances(X.T, Y.T)
u = linear_assignment(dist)
permutation = scipy.sparse.csr_matrix(
(np.ones(X.shape[1]), (u[:, 0], u[:, 1]))).T
return permutation
def unsupervised_clustering_accuracy(labels_true, labels_pred):
"""
Calculate the unsupervised clustering accuracy.
# Arguments
labels_true: true labels, numpy.array with shape `(n_samples,)`
labels_pred: predicted labels, numpy.array with shape `(n_samples,)`
# Return
accuracy, in [0,1]
Adapted from https://github.com/XifengGuo/DEC-keras/blob/master/metrics.py
"""
y_true = relabel(labels_true)
y_pred = relabel(labels_pred)
assert y_true.size == y_pred.size
D = max(y_pred.max(), y_true.max()) + 1
w = numpy.zeros((D, D), dtype=numpy.int64)
for i in range(y_pred.size):
w[y_pred[i], y_true[i]] += 1
from sklearn.utils.linear_assignment_ import linear_assignment
ind = linear_assignment(w.max() - w)
return sum([w[i, j] for i, j in ind]) * 1.0 / y_pred.size
def mention2GoldClusterIds_ceafe(clusters, gold_clusters):
clusters = [c for c in clusters]
scores = np.zeros((len(gold_clusters), len(clusters)))
for i in range(len(gold_clusters)):
for j in range(len(clusters)):
scores[i, j] = phi4(gold_clusters[i], clusters[j])
matching = linear_assignment(-scores)
p2g = {m[1]: m[0] for m in matching if scores[m[0]][m[1]] > 0}
extra_ids = len(gold_clusters) + 1
mention2gcid = {}
for pid, cl in enumerate(clusters):
if pid in p2g:
gid = p2g[pid] + 1
else:
gid = extra_ids
extra_ids += 1
for m in cl:
mention2gcid[m] = gid
return mention2gcid
def assign(dist_map, pair_dist, pair_velocity, pre_num, post_num):
cost_mat = np.full((pre_num, post_num), 100, dtype='float32')
for i in range(pre_num):
for j, x in enumerate(dist_map[i]):
if x is None:
continue
if pair_velocity[i][j] is None:
cost_mat[i, x] = pair_dist[i][j] + 10
if pair_velocity[i][j] is not None:
cost_mat[i, x] = pair_dist[i][j] + pair_velocity[i][j]
assign_result_holder = sk_assignment.linear_assignment(cost_mat)
assign_result = dict([i, None] for i in range(pre_num))
for i in range(assign_result_holder.shape[0]):
pre, post = assign_result_holder[i]
if cost_mat[pre, post] < 20: # meaning both distance and velocity pair requirment are not met
assign_result[pre] = post
return assign_result
def data_associate(score_mat, match_thres=0.3):
detnum,targetnum = score_mat.shape
matched_indices = linear_assignment(-score_mat)
#print score_mat
unm_dets = []
for d in range(detnum):
if(d not in matched_indices[:,0]):
unm_dets.append(d)
unm_targets = []
for t in range(targetnum):
if(t not in matched_indices[:,1]):
unm_targets.append(t)
matches = []
for m in matched_indices:
if(score_mat[m[0],m[1]])<match_thres:
unm_dets.append(m[0])
unm_targets.append(m[1])
else: matches.append(m)
return matches, unm_dets, unm_targets
def consensus_score(a, b, similarity="jaccard"):
"""The similarity of two sets of biclusters.
Similarity between individual biclusters is computed. Then the
best matching between sets is found using the Hungarian algorithm.
The final score is the sum of similarities divided by the size of
the larger set.
Read more in the :ref:`User Guide <biclustering>`.
Parameters
----------
a : (rows, columns)
Tuple of row and column indicators for a set of biclusters.
b : (rows, columns)
Another set of biclusters like ``a``.
similarity : string or function, optional, default: "jaccard"
May be the string "jaccard" to use the Jaccard coefficient, or
any function that takes four arguments, each of which is a 1d
indicator vector: (a_rows, a_columns, b_rows, b_columns).
References
----------
* Hochreiter, Bodenhofer, et. al., 2010. `FABIA: factor analysis
for bicluster acquisition
<https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2881408/>`__.
"""
if similarity == "jaccard":
similarity = _jaccard
matrix = _pairwise_similarity(a, b, similarity)
indices = linear_assignment(1. - matrix)
n_a = len(a[0])
n_b = len(b[0])
return matrix[indices[:, 0], indices[:, 1]].sum() / max(n_a, n_b)
def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):
"""
Assigns detections to tracked object (both represented as bounding boxes)
Returns 3 lists of matches, unmatched_detections and unmatched_trackers
"""
if(len(trackers)==0):
return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)
iou_matrix = np.zeros((len(detections),len(trackers)),dtype=np.float32)
for d,det in enumerate(detections):
for t,trk in enumerate(trackers):
iou_matrix[d,t] = iou(det,trk)
matched_indices = linear_assignment(-iou_matrix)
unmatched_detections = []
for d,det in enumerate(detections):
if(d not in matched_indices[:,0]):
unmatched_detections.append(d)
unmatched_trackers = []
for d,det in enumerate(trackers):
if(d not in matched_indices[:,1]):
unmatched_trackers.append(d)
#filter out matched with low IOU
matches = []
for m in matched_indices:
if(iou_matrix[m[0],m[1]]<iou_threshold):
unmatched_detections.append(m[0])
unmatched_trackers.append(m[1])
else:
matches.append(m.reshape(1,2))
if(len(matches)==0):
matches = np.empty((0,2),dtype=int)
else:
matches = np.concatenate(matches,axis=0)
return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
def acc(ypred, y):
"""
Calculating the clustering accuracy. The predicted result must have the same number of clusters as the ground truth.
ypred: 1-D numpy vector, predicted labels
y: 1-D numpy vector, ground truth
The problem of finding the best permutation to calculate the clustering accuracy is a linear assignment problem.
This function construct a N-by-N cost matrix, then pass it to scipy.optimize.linear_sum_assignment to solve the assignment problem.
"""
assert len(y) > 0
assert len(np.unique(ypred)) == len(np.unique(y))
s = np.unique(ypred)
t = np.unique(y)
N = len(np.unique(ypred))
C = np.zeros((N, N), dtype = np.int32)
for i in range(N):
for j in range(N):
idx = np.logical_and(ypred == s[i], y == t[j])
C[i][j] = np.count_nonzero(idx)
# convert the C matrix to the 'true' cost
Cmax = np.amax(C)
C = Cmax - C
#
indices = linear_assignment(C)
row = indices[:][:, 0]
col = indices[:][:, 1]
# calculating the accuracy according to the optimal assignment
count = 0
for i in range(N):
idx = np.logical_and(ypred == s[row[i]], y == t[col[i]] )
count += np.count_nonzero(idx)
return 1.0*count/len(y)
def accuracy(true_row_labels, predicted_row_labels):
"""Get the best accuracy.
Parameters
----------
true_row_labels: array-like
The true row labels, given as external information
predicted_row_labels: array-like
The row labels predicted by the model
Returns
-------
float
Best value of accuracy
"""
cm = confusion_matrix(true_row_labels, predicted_row_labels)
indexes = linear_assignment(_make_cost_m(cm))
total = 0
for row, column in indexes:
value = cm[row][column]
total += value
return (total * 1. / np.sum(cm))
def assign(observed, predicted, max_dist):
'''
Assigns observed locations of bees based on predicted locations using the
Hungarian algorithm.
Args:
observed - numpy array with shape (3, n) containing observed coordinates
and a third row containing weights for assignment in the case
where more than 2 bees are coassigned and then split.
predicted - numpy array with first two lines containing predicted coords
max_dist - maximum distance between predicted and observed
Returns:
an nx3 array of indices (predicted_index, observed_index, non_linear)
'''
costs = cdist(predicted[0:2, :].transpose(), observed[0:2, :].transpose(),
'euclidean')
l = linear_assignment(costs)
rm_list = []
# Remove assignments which make the distance between observed and predicted
# greater than max_dist
for row in range(l.shape[0]):
if costs[l[row, 0], l[row, 1]] > max_dist \
and (predicted[0:2, ] != 0).all():
rm_list.append(row)
l = np.delete(l, rm_list, axis=0)
l = reassign(l, predicted.shape[1], costs, max_dist,
observed[2, :])
# Calculate co-assignments
l = np.hstack([l, np.zeros((l.shape[0], 1), dtype=l.dtype)])
u, u_counts = np.unique(l[:, 1], return_counts=True)
for i in range(l.shape[0]):
u_idx = np.where(u == l[i, 1])[0]
l[i, 2] = u_counts[u_idx]
return l
