mask = np.zeros(num, dtype=np.bool)

for _, indices in ids_dict.items():

i = np.random.choice(indices)

mask[i] = True

query_cams=None, gallery_cams=None, topk=100,

separate_camera_set=False,

single_gallery_shot=False,

first_match_break=False):

m, n = distmat.shape

# Fill up default values

if query_ids is None:

query_ids = np.arange(m)

if gallery_ids is None:

gallery_ids = np.arange(n)

if query_cams is None:

query_cams = np.zeros(m).astype(np.int32)

if gallery_cams is None:

gallery_cams = np.ones(n).astype(np.int32)

# Ensure numpy array

query_ids = np.asarray(query_ids)

gallery_ids = np.asarray(gallery_ids)

query_cams = np.asarray(query_cams)

gallery_cams = np.asarray(gallery_cams)

# Sort and find correct matches

indices = np.argsort(distmat, axis=1)

matches = (gallery_ids[indices] == query_ids[:, np.newaxis])

# Compute CMC for each query

ret = np.zeros(topk)

num_valid_queries = 0

for i in range(m):

# Filter out the same id and same camera

valid = ((gallery_ids[indices[i]] != query_ids[i]) |

(gallery_cams[indices[i]] != query_cams[i]))

if separate_camera_set:

# Filter out samples from same camera

valid &= (gallery_cams[indices[i]] != query_cams[i])

if not np.any(matches[i, valid]):

continue

if single_gallery_shot:

repeat = 10

gids = gallery_ids[indices[i][valid]]

inds = np.where(valid)[0]

ids_dict = defaultdict(list)

for j, x in zip(inds, gids):

ids_dict[x].append(j)

else:

repeat = 1

for _ in range(repeat):

if single_gallery_shot:

# Randomly choose one instance for each id

sampled = (valid & _unique_sample(ids_dict, len(valid)))

index = np.nonzero(matches[i, sampled])[0]

else:

index = np.nonzero(matches[i, valid])[0]

delta = 1. / (len(index) * repeat)

for j, k in enumerate(index):

if k - j >= topk:

break

if first_match_break:

ret[k - j] += 1

break

ret[k - j] += delta

num_valid_queries += 1

if num_valid_queries == 0:

raise RuntimeError("No valid query")

query_cams=None, gallery_cams=None):

m, n = distmat.shape

# Fill up default values

if query_ids is None:

query_ids = np.arange(m)

if gallery_ids is None:

gallery_ids = np.arange(n)

if query_cams is None:

query_cams = np.zeros(m).astype(np.int32)

if gallery_cams is None:

gallery_cams = np.ones(n).astype(np.int32)

# Ensure numpy array

query_ids = np.asarray(query_ids)

gallery_ids = np.asarray(gallery_ids)

query_cams = np.asarray(query_cams)

gallery_cams = np.asarray(gallery_cams)

# Sort and find correct matches

indices = np.argsort(distmat, axis=1)

matches = (gallery_ids[indices] == query_ids[:, np.newaxis])

# Compute AP for each query

aps = []

for i in range(m):

# Filter out the same id and same camera

valid = ((gallery_ids[indices[i]] != query_ids[i]) |

(gallery_cams[indices[i]] != query_cams[i]))

y_true = matches[i, valid]

y_score = -distmat[i][indices[i]][valid]

if not np.any(y_true):

continue

aps.append(average_precision_score(y_true, y_score))

if len(aps) == 0:

raise RuntimeError("No valid query")

forward_k_neigh_index = initial_rank[i, :k1 + 1]

backward_k_neigh_index = initial_rank[forward_k_neigh_index, :k1 + 1]

fi = np.where(backward_k_neigh_index == i)[0]

# The following naming, e.g. gallery_num, is different from outer scope.

# Don't care about it.

original_dist = np.concatenate(

[np.concatenate([q_q_dist, q_g_dist], axis=1),

np.concatenate([q_g_dist.T, g_g_dist], axis=1)],

axis=0)

original_dist = 2. - 2 * original_dist # np.power(original_dist, 2).astype(np.float32)

original_dist = np.transpose(1. * original_dist / np.max(original_dist, axis=0))

V = np.zeros_like(original_dist).astype(np.float32)

# initial_rank = np.argsort(original_dist).astype(np.int32)

# top K1+1

initial_rank = np.argpartition(original_dist, range(1, k1 + 1))

query_num = q_g_dist.shape[0]

all_num = original_dist.shape[0]

for i in range(all_num):

# k-reciprocal neighbors

k_reciprocal_index = k_reciprocal_neigh(initial_rank, i, k1)

k_reciprocal_expansion_index = k_reciprocal_index

for j in range(len(k_reciprocal_index)):

candidate = k_reciprocal_index[j]

candidate_k_reciprocal_index = k_reciprocal_neigh(initial_rank, candidate, int(np.around(k1 / 2)))

if len(np.intersect1d(candidate_k_reciprocal_index, k_reciprocal_index)) > 2. / 3 * len(

candidate_k_reciprocal_index):

k_reciprocal_expansion_index = np.append(k_reciprocal_expansion_index, candidate_k_reciprocal_index)

k_reciprocal_expansion_index = np.unique(k_reciprocal_expansion_index)

weight = np.exp(-original_dist[i, k_reciprocal_expansion_index])

V[i, k_reciprocal_expansion_index] = 1. * weight / np.sum(weight)

original_dist = original_dist[:query_num, ]

if k2 != 1:

V_qe = np.zeros_like(V, dtype=np.float32)

for i in range(all_num):

V_qe[i, :] = np.mean(V[initial_rank[i, :k2], :], axis=0)

V = V_qe

del V_qe

del initial_rank

invIndex = []

for i in range(all_num):

invIndex.append(np.where(V[:, i] != 0)[0])

jaccard_dist = np.zeros_like(original_dist, dtype=np.float32)

for i in range(query_num):

temp_min = np.zeros(shape=[1, all_num], dtype=np.float32)

indNonZero = np.where(V[i, :] != 0)[0]

indImages = []

indImages = [invIndex[ind] for ind in indNonZero]

for j in range(len(indNonZero)):

temp_min[0, indImages[j]] = temp_min[0, indImages[j]] + np.minimum(V[i, indNonZero[j]],

V[indImages[j], indNonZero[j]])

jaccard_dist[i] = 1 - temp_min / (2. - temp_min)

final_dist = jaccard_dist * (1 - lambda_value) + original_dist * lambda_value

del original_dist

del V

del jaccard_dist

final_dist = final_dist[:query_num, query_num:]