def fusion_heat(fusion_param):
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
rand_camera_deltas = pickle_load(
fusion_param['rand_distribution_pickle_path'])
delta_width = 3000.0
delta_cnt = 10
interval_width = delta_width / delta_cnt
delta_stripe = delta_width / delta_cnt
delta_range = map(lambda x: x * delta_stripe - delta_width / 2,
range(delta_cnt))
# delta_range = map(lambda x: x*1.0 - 60.0, range(120))
viz_deltas = list()
viz_camera_pairs = list()
viz_values = list()
for i in range(6):
for j in range(i + 1, 6):
for k in range(len(delta_range)):
match_track_score = track_score(camera_delta_s,
i + 1,
0,
j + 1,
delta_range[k],
interval=interval_width)
rand_track_score = track_score(rand_camera_deltas,
i + 1,
0,
j + 1,
delta_range[k],
interval=interval_width)
if rand_track_score < 0.00002:
# print rand_track_score
rand_track_score = 0.00002
else:
print match_track_score / rand_track_score
# raw_probs[i][j].append(match_track_score)
# rand_probs[i][j].append(rand_track_score)
viz_deltas.append(delta_range[k])
viz_camera_pairs.append('c%d-c%d' % (i + 1, j + 1))
viz_values.append(match_track_score)
break
df = pd.DataFrame({
'transfer_time': viz_deltas,
'camera_pair': viz_camera_pairs,
'values': viz_values
})
pt = df.pivot_table(index='camera_pair',
columns='transfer_time',
values='values',
aggfunc=np.sum)
return pt
def main():
opt = arg_parse()
cluster_tracks = pickle_load(opt.track_path)
score = purity_score_for_track(cluster_tracks)
print('score %f' % score)
write(
opt.result_path, 'cluster task: %s \t\tscore: %f\n' %
(opt.track_path.split('/')[-1], score))
def simple_fusion_st_gallery_ranker(fusion_param):
ep = fusion_param['ep']
en = fusion_param['en']
log_path = fusion_param['eval_fusion_path']
map_score_path = fusion_param['fusion_normal_score_path'] # fusion_param = get_fusion_param()
# answer path is probe path
answer_path = fusion_param['answer_path']
answer_lines = read_lines(answer_path)
query_tracks = list()
for answer in answer_lines:
info = answer.split('_')
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
query_tracks.append([info[0], int(info[1][0]), int(info[2])])
elif 'f' in info[2]:
query_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
else:
query_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
gallery_path = fusion_param['gallery_path']
gallery_lines = read_lines(gallery_path)
gallery_tracks = list()
for gallery in gallery_lines:
info = gallery.split('_')
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
gallery_tracks.append([info[0], int(info[1][0]), int(info[2])])
elif 'f' in info[2]:
gallery_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
else:
gallery_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
print 'probe and gallery tracks ready'
persons_ap_scores = predict_img_scores(fusion_param)
persons_ap_pids = predict_pids(fusion_param)
print 'read vision scores and pids ready'
if fusion_param['gt_fusion']:
scale = 6.
else:
scale = 3.
# if 'market_market' in log_path:
if True:
# if 'market_market' in log_path:
for i, person_ap_scores in enumerate(persons_ap_scores):
cur_max_vision = max(person_ap_scores)
cur_min_vision = min(person_ap_scores)
persons_ap_scores[i] = (persons_ap_scores[i] - cur_min_vision) / (cur_max_vision - cur_min_vision)
persons_ap_scores[i] = np.exp(persons_ap_scores[i] * scale)
cur_max_vision = max(persons_ap_scores[i])
cur_min_vision = min(persons_ap_scores[i])
persons_ap_scores[i] = (persons_ap_scores[i] - cur_min_vision) / (cur_max_vision - cur_min_vision)
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
# camera_delta_s = pickle_load('true_market_probe.pck')
print 'load track deltas ready'
smooth = '_grid' in log_path
# smooth = True
persons_track_scores = gallery_track_scores(query_tracks, gallery_tracks, camera_delta_s, fusion_param, smooth=smooth)
print 'track scores ready'
persons_cross_scores = list()
safe_remove(map_score_path)
safe_remove(log_path)
for i, person_ap_pids in enumerate(persons_ap_pids):
cross_scores = list()
for j, person_ap_pid in enumerate(person_ap_pids):
cur_track_score = persons_track_scores[i][j]
cross_score = cur_track_score * persons_ap_scores[i][j]
cross_scores.append(cross_score)
if max(cross_scores) == 0:
print 'max_cross_scores %d is 0' % i
persons_cross_scores.append(cross_scores)
print 'fusion scores ready'
max_score_s = [max(predict_cross_scores) for predict_cross_scores in persons_cross_scores]
for i, person_cross_scores in enumerate(persons_cross_scores):
for j, person_cross_score in enumerate(person_cross_scores):
if persons_cross_scores[i][j] >= 0:
# diff seq not sort, not rank for max, and not normalize
if max_score_s[i] == 0:
# there exist probe track with same seq, diff camera but value > 1000
print 'max_score_s %d is 0' % i
else:
persons_cross_scores[i][j] /= max_score_s[i]
else:
persons_cross_scores[i][j] *= -1.
print 'fusion scores normalized, diff seq use vision score to rank'
person_score_idx_s = list()
for i, person_cross_scores in enumerate(persons_cross_scores):
# 单个probe的预测结果中按score排序，得到index，用于对pid进行排序
sort_score_idx_s = sorted(range(len(person_cross_scores)), key=lambda k: -person_cross_scores[k])
person_score_idx_s.append(sort_score_idx_s)
sorted_persons_ap_pids = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
sorted_persons_ap_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
for i, person_ap_pids in enumerate(persons_ap_pids):
for j in range(len(person_ap_pids)):
sorted_persons_ap_pids[i][j] = persons_ap_pids[i][person_score_idx_s[i][j]]
sorted_persons_ap_scores[i][j] = persons_cross_scores[i][person_score_idx_s[i][j]]
print 'sorted scores ready'
safe_remove(log_path)
safe_remove(map_score_path)
np.savetxt(log_path, sorted_persons_ap_pids, fmt='%d')
np.savetxt(map_score_path, sorted_persons_ap_scores, fmt='%f')
print 'save sorted fusion scores'
return person_score_idx_s
def fusion_st_gallery_ranker(fusion_param):
ep = fusion_param['ep']
en = fusion_param['en']
log_path = fusion_param['eval_fusion_path']
map_score_path = fusion_param['fusion_normal_score_path'] # fusion_param = get_fusion_param()
# answer path is probe path
answer_path = fusion_param['answer_path']
answer_lines = read_lines(answer_path)
query_tracks = list()
for answer in answer_lines:
info = answer.split('_')
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
query_tracks.append([info[0], int(info[1][0]), int(info[2])])
elif 'f' in info[2]:
query_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
else:
query_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
gallery_path = fusion_param['gallery_path']
gallery_lines = read_lines(gallery_path)
gallery_tracks = list()
for gallery in gallery_lines:
info = gallery.split('_')
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
gallery_tracks.append([info[0], int(info[1][0]), int(info[2])])
elif 'f' in info[2]:
gallery_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
else:
gallery_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
print 'probe and gallery tracks ready'
persons_ap_scores = predict_img_scores(fusion_param)
persons_ap_pids = predict_pids(fusion_param)
print 'read vision scores and pids ready'
if 'market_market' in log_path:
scale = 10
else:
scale = 3 # 1.5 for direct fusion
if True:
# if 'market_market' in log_path:
for i, person_ap_scores in enumerate(persons_ap_scores):
cur_max_vision = max(person_ap_scores)
cur_min_vision = min(person_ap_scores)
persons_ap_scores[i] = (persons_ap_scores[i] - cur_min_vision) / (cur_max_vision - cur_min_vision)
persons_ap_scores[i] = np.exp(persons_ap_scores[i] * scale)
cur_max_vision = max(persons_ap_scores[i])
cur_min_vision = min(persons_ap_scores[i])
persons_ap_scores[i] = (persons_ap_scores[i] - cur_min_vision) / (cur_max_vision - cur_min_vision)
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
# camera_delta_s = pickle_load('true_market_probe.pck')
print 'load track deltas ready'
rand_delta_s = pickle_load(fusion_param['rand_distribution_pickle_path'])
print 'load rand deltas ready'
diff_delta_s = pickle_load(fusion_param['rand_distribution_pickle_path'].replace('rand', 'diff'))
print 'load diff deltas ready'
# todo tmp diff deltas
# diff_delta_s = rand_delta_s
rand_track_scores = gallery_track_scores(query_tracks, gallery_tracks, rand_delta_s, fusion_param, smooth=False)
print 'rand scores ready'
smooth = '_grid' in log_path
# smooth = True
persons_track_scores = gallery_track_scores(query_tracks, gallery_tracks, camera_delta_s, fusion_param, smooth=smooth)
print 'track scores ready'
# diff_track_scores = gallery_track_scores(query_tracks, gallery_tracks, diff_delta_s, fusion_param, smooth=smooth)
print 'diff track score ready'
# todo tmp diff scores
diff_track_scores = rand_track_scores
persons_cross_scores = list()
safe_remove(map_score_path)
safe_remove(log_path)
# fusion_track_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
# for i, person_ap_pids in enumerate(persons_ap_pids):
# for j, person_ap_pid in enumerate(person_ap_pids):
# cur_track_score = persons_track_scores[i][j]
# rand_track_score = rand_track_scores[i][j]
# if rand_track_score < 0.00002:
# rand_track_score = 0.00002
# fusion_track_scores[i][j] = (cur_track_score * (1 - ep) - en * diff_track_scores[i][j]) / rand_track_score
# for i, person_ap_pids in enumerate(persons_ap_pids):
# cur_max_predict = max(persons_track_scores[i])
# cur_max_rand = max(rand_track_scores[i])
# for j in range(len(fusion_track_scores[i])):
# if fusion_track_scores[i][j] >= 0:
# fusion_track_scores[i][j] /= cur_max_predict/cur_max_rand
# else:
# fusion_track_scores[i][j] = 1.
min_rand = 1e-3 # 0.00002
# min_rand = 2e-5 # 0.00002
if 'market_market' in log_path:
min_rand = 1e-2 # 0.00002
for i, person_ap_pids in enumerate(persons_ap_pids):
cross_scores = list()
for j, person_ap_pid in enumerate(person_ap_pids):
cur_track_score = persons_track_scores[i][j]
rand_track_score = rand_track_scores[i][j]
if rand_track_score < 0:
rand_track_score =min_rand
elif rand_track_score < min_rand:
rand_track_score = min_rand
if cur_track_score != 0:
cur_track_score = -1
cross_score = (cur_track_score * (1 - ep) - en * diff_track_scores[i][j]) * (
persons_ap_scores[i][j] + ep / (1 - ep - en)) / rand_track_score
if cur_track_score > 0 and cross_score < 0:
cross_score = 0
cross_scores.append(cross_score)
if max(cross_scores) == 0:
print 'max cross scores %d is 0' % i
persons_cross_scores.append(cross_scores)
print 'fusion scores ready'
# pickle_save(ctrl_msg['data_folder_path']+'viper_r-testpersons_cross_scores.pick', persons_cross_scores)
# pickle_save(ctrl_msg['data_folder_path']+'viper_r-testpersons_ap_pids.pick', persons_ap_pids)
max_score_s = [max(predict_cross_scores) for predict_cross_scores in persons_cross_scores]
for i, person_cross_scores in enumerate(persons_cross_scores):
for j, person_cross_score in enumerate(person_cross_scores):
if persons_cross_scores[i][j] >= 0:
# diff seq not sort, not rank for max, and not normalize
if max_score_s[i] == 0:
# there exist probe track with same seq, diff camera but value > 1000
print 'max_score_s %d is 0' % i
else:
persons_cross_scores[i][j] /= max_score_s[i]
# persons_cross_scores[i][j] /= max_score
# if persons_cross_scores[i][j] > 0.5:
# print 'same'
# print persons_cross_scores[i][j]
else:
# so diff seq is negative, normalize by minimum
# persons_cross_scores[i][j] /= min_score_s[i]
# persons_cross_scores[i][j] *= 1.0
persons_cross_scores[i][j] *= -1 * min_rand
if i == 0 and j % 100 == 0:
print 'track: %f vision: %f rand: %f final: %f' % (
persons_track_scores[i][j], persons_ap_scores[i][j], rand_track_scores[i][j], persons_cross_scores[i][j])
print 'fusion scores normalized, diff seq use vision score to rank'
person_score_idx_s = list()
for i, person_cross_scores in enumerate(persons_cross_scores):
# 单个probe的预测结果中按score排序，得到index，用于对pid进行排序
sort_score_idx_s = sorted(range(len(person_cross_scores)), key=lambda k: -person_cross_scores[k])
person_score_idx_s.append(sort_score_idx_s)
sorted_persons_ap_pids = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
sorted_persons_ap_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
for i, person_ap_pids in enumerate(persons_ap_pids):
for j in range(len(person_ap_pids)):
sorted_persons_ap_pids[i][j] = persons_ap_pids[i][person_score_idx_s[i][j]]
sorted_persons_ap_scores[i][j] = persons_cross_scores[i][person_score_idx_s[i][j]]
print 'sorted scores ready'
np.savetxt(log_path, sorted_persons_ap_pids, fmt='%d')
np.savetxt(map_score_path, sorted_persons_ap_scores, fmt='%f')
print 'save sorted fusion scores'
# for i, person_ap_pids in enumerate(persons_ap_pids):
# for j in range(len(person_ap_pids)):
# write(log_path, '%d ' % person_ap_pids[person_score_idx_s[i][j]])
# write(map_score_path, '%.3f ' % persons_cross_scores[i][person_score_idx_s[i][j]])
# write(log_path, '\n')
# write(map_score_path, '\n')
return person_score_idx_s
def simple_fusion_st_img_ranker(fusion_param):
ep = fusion_param['ep']
en = fusion_param['en']
# 从renew_pid和renew_ac获取预测的人物id和图像分数
persons_ap_scores = predict_img_scores(fusion_param)
persons_ap_pids = predict_pids(fusion_param)
# 从磁盘获取之前建立的时空模型，以及随机时空模型
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
real_tracks = train_tracks(fusion_param)
# 计算时空评分和随机时空评分
persons_track_scores = predict_track_scores(real_tracks, camera_delta_s, fusion_param)
persons_cross_scores = list()
log_path = fusion_param['eval_fusion_path']
map_score_path = fusion_param['fusion_normal_score_path']
safe_remove(map_score_path)
safe_remove(log_path)
line_log_cnt = 10
for i, person_ap_pids in enumerate(persons_ap_pids):
cross_scores = list()
for j, person_ap_pid in enumerate(person_ap_pids):
cross_score = persons_track_scores[i][j] * persons_ap_scores[i][j]
cross_scores.append(cross_score)
persons_cross_scores.append(cross_scores)
print 'img score ready'
max_score = max([max(predict_cross_scores) for predict_cross_scores in persons_cross_scores])
for i, person_cross_scores in enumerate(persons_cross_scores):
for j, person_cross_score in enumerate(person_cross_scores):
if person_cross_score > 0:
# diff seq not sort and not normalize
persons_cross_scores[i][j] /= max_score
else:
persons_cross_scores[i][j] *= -1.
# if real_tracks[i][1] == real_tracks[persons_ap_pids[i][j]][1]:
# # print '%d, %d' % (i, j)
# persons_cross_scores[i][j] = 0
person_score_idx_s = list()
top1_scores = list()
print 'above person score ready'
for i, person_cross_scores in enumerate(persons_cross_scores):
# 单个probe的预测结果中按score排序，得到index，用于对pid进行排序
sort_score_idx_s = sorted(range(len(person_cross_scores)), key=lambda k: -person_cross_scores[k])
person_score_idx_s.append(sort_score_idx_s)
# 统计top1分布，后面计算中位数用
top1_scores.append(person_cross_scores[sort_score_idx_s[0]])
# 降序排，取前60%处的分数
sorted_top1_scores = sorted(top1_scores, reverse=True)
mid_score = sorted_top1_scores[int(len(sorted_top1_scores) * 0.5)]
mid_score_path = fusion_param['mid_score_path']
safe_remove(mid_score_path)
write(mid_score_path, '%f\n' % mid_score)
print(str(mid_score))
sorted_persons_ap_pids = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
sorted_persons_ap_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
for i, person_ap_pids in enumerate(persons_ap_pids):
for j in range(len(person_ap_pids)):
sorted_persons_ap_pids[i][j] = persons_ap_pids[i][person_score_idx_s[i][j]]
sorted_persons_ap_scores[i][j] = persons_cross_scores[i][person_score_idx_s[i][j]]
np.savetxt(log_path, sorted_persons_ap_pids, fmt='%d')
np.savetxt(map_score_path, sorted_persons_ap_scores, fmt='%f')
def fusion_st_img_ranker(fusion_param):
ep = fusion_param['ep']
en = fusion_param['en']
# 从renew_pid和renew_ac获取预测的人物id和图像分数
persons_ap_scores = predict_img_scores(fusion_param)
persons_ap_pids = predict_pids(fusion_param)
# 从磁盘获取之前建立的时空模型，以及随机时空模型
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
rand_delta_s = pickle_load(fusion_param['rand_distribution_pickle_path'])
# diff_delta_s = pickle_load(fusion_param['rand_distribution_pickle_path'].replace('rand', 'diff'))
real_tracks = train_tracks(fusion_param)
# 计算时空评分和随机时空评分
persons_track_scores = predict_track_scores(real_tracks, camera_delta_s, fusion_param)
rand_track_scores = predict_track_scores(real_tracks, rand_delta_s, fusion_param)
diff_track_scores = rand_track_scores #predict_track_scores(real_tracks, diff_delta_s, fusion_param)
persons_cross_scores = list()
log_path = fusion_param['eval_fusion_path']
map_score_path = fusion_param['fusion_normal_score_path']
safe_remove(map_score_path)
safe_remove(log_path)
line_log_cnt = 10
for i, person_ap_scores in enumerate(persons_ap_scores):
cur_max_vision = max(person_ap_scores)
cur_min_vision = min(person_ap_scores)
persons_ap_scores[i] = (persons_ap_scores[i] - cur_min_vision) / (cur_max_vision - cur_min_vision)
persons_ap_scores[i] = np.exp(persons_ap_scores[i] * 3)
cur_max_vision = max(persons_ap_scores[i])
cur_min_vision = min(persons_ap_scores[i])
persons_ap_scores[i] = (persons_ap_scores[i] - cur_min_vision) / (cur_max_vision - cur_min_vision)
for i, person_ap_pids in enumerate(persons_ap_pids):
cross_scores = list()
for j, person_ap_pid in enumerate(person_ap_pids):
if rand_track_scores[i][j] < 0.00002:
cross_score = (persons_track_scores[i][j]*(1-ep) - en*diff_track_scores[i][j]) * (persons_ap_scores[i][j]+ep/(1-ep-en)) / 0.00002
else:
cross_score = (persons_track_scores[i][j] * (1 - ep) - en * diff_track_scores[i][j]) * (
persons_ap_scores[i][j] + ep / (1 - ep - en)) / rand_track_scores[i][j]
cross_scores.append(cross_score)
persons_cross_scores.append(cross_scores)
print 'img score ready'
max_score = max([max(predict_cross_scores) for predict_cross_scores in persons_cross_scores])
print 'max_cross_score %f' % max_score
for i, person_cross_scores in enumerate(persons_cross_scores):
for j, person_cross_score in enumerate(person_cross_scores):
if person_cross_score > 0: # diff camera
# diff seq not sort and not normalize
persons_cross_scores[i][j] /= max_score
else: # same camera and (diff camere && rand score == -1 )
persons_cross_scores[i][j] = persons_ap_scores[i][j]
# if real_tracks[i][1] == real_tracks[persons_ap_pids[i][j]][1]:
# # print '%d, %d' % (i, j)
# persons_cross_scores[i][j] = 0
if i == 0 and j % 100 == 0:
print 'st:%f st_diff%f vis:%f fus:%f' % (
persons_track_scores[i][j], diff_track_scores[i][j], persons_ap_scores[i][j], persons_cross_scores[i][j])
person_score_idx_s = list()
top1_scores = list()
print 'above person score ready'
for i, person_cross_scores in enumerate(persons_cross_scores):
# 单个probe的预测结果中按score排序，得到index，用于对pid进行排序
sort_score_idx_s = sorted(range(len(person_cross_scores)), key=lambda k: -person_cross_scores[k])
person_score_idx_s.append(sort_score_idx_s)
# 统计top1分布，后面计算中位数用
top1_scores.append(person_cross_scores[sort_score_idx_s[0]])
# 降序排，取前60%处的分数
sorted_top1_scores = sorted(top1_scores, reverse=True)
mid_score = sorted_top1_scores[int(len(sorted_top1_scores) * 0.5)]
mid_score_path = fusion_param['mid_score_path']
safe_remove(mid_score_path)
write(mid_score_path, '%f\n' % mid_score)
print(str(mid_score))
sorted_persons_ap_pids = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
sorted_persons_ap_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
for i, person_ap_pids in enumerate(persons_ap_pids):
for j in range(len(person_ap_pids)):
sorted_persons_ap_pids[i][j] = persons_ap_pids[i][person_score_idx_s[i][j]]
sorted_persons_ap_scores[i][j] = persons_cross_scores[i][person_score_idx_s[i][j]]
np.savetxt(log_path, sorted_persons_ap_pids, fmt='%d')
np.savetxt(map_score_path, sorted_persons_ap_scores, fmt='%f')
def fusion_st_gallery_ranker(fusion_param):
print 'st_filter_market.fusion'
ep = fusion_param['ep']
en = fusion_param['en']
log_path = fusion_param['eval_fusion_path']
map_score_path = fusion_param['fusion_normal_score_path'] # fusion_param = get_fusion_param()
# answer path is probe path
answer_path = fusion_param['answer_path']
answer_lines = read_lines(answer_path)
query_tracks = list()
for answer in answer_lines:
info = answer.split('_')
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
query_tracks.append([info[0], int(info[1][0]), int(info[2])])
else:
query_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
gallery_path = fusion_param['gallery_path']
gallery_lines = read_lines(gallery_path)
gallery_tracks = list()
for gallery in gallery_lines:
info = gallery.split('_')
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
gallery_tracks.append([info[0], int(info[1][0]), int(info[2])])
else:
gallery_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
print 'probe and gallery tracks ready'
persons_ap_scores = predict_img_scores(fusion_param)
persons_ap_pids = predict_pids(fusion_param)
print 'read vision scores and pids ready'
for i, person_ap_scores in enumerate(persons_ap_scores):
cur_max_vision = 0
for j, person_ap_score in enumerate(person_ap_scores):
if query_tracks[i][1] != gallery_tracks[persons_ap_pids[i][j]][1]:
# diff vision
cur_max_vision = person_ap_score
persons_ap_scores[i] /= cur_max_vision
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
# camera_delta_s = pickle_load('true_market_probe.pck')
print 'load track deltas ready'
rand_delta_s = pickle_load(fusion_param['rand_distribution_pickle_path'])
print 'load rand deltas ready'
# diff_delta_s = pickle_load(fusion_param['rand_distribution_pickle_path'].replace('rand', 'diff'))
# todo tmp diff deltas
diff_delta_s = rand_delta_s
rand_track_scores = gallery_track_scores(query_tracks, gallery_tracks, rand_delta_s, fusion_param)
print 'rand scores ready'
persons_track_scores = gallery_track_scores(query_tracks, gallery_tracks, camera_delta_s, fusion_param)
print 'track scores ready'
# diff_track_scores = gallery_track_scores(diff_delta_s, fusion_param)
# todo tmp diff scores
diff_track_scores = rand_track_scores
persons_cross_scores = list()
safe_remove(map_score_path)
safe_remove(log_path)
# fusion_track_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
# for i, person_ap_pids in enumerate(persons_ap_pids):
# for j, person_ap_pid in enumerate(person_ap_pids):
# cur_track_score = persons_track_scores[i][j]
# rand_track_score = rand_track_scores[i][j]
# if rand_track_score < 0.00002:
# rand_track_score = 0.00002
# fusion_track_scores[i][j] = (cur_track_score * (1 - ep) - en * diff_track_scores[i][j]) / rand_track_score
# for i, person_ap_pids in enumerate(persons_ap_pids):
# cur_max_predict = max(persons_track_scores[i])
# cur_max_rand = max(rand_track_scores[i])
# for j in range(len(fusion_track_scores[i])):
# if fusion_track_scores[i][j] >= 0:
# fusion_track_scores[i][j] /= cur_max_predict/cur_max_rand
# else:
# fusion_track_scores[i][j] = 1.
for i, person_ap_pids in enumerate(persons_ap_pids):
cross_scores = list()
for j, person_ap_pid in enumerate(person_ap_pids):
cur_track_score = persons_track_scores[i][j]
rand_track_score = rand_track_scores[i][j]
if rand_track_score < 0:
rand_track_score = 0.00002
elif rand_track_score < 0.00002:
rand_track_score = 0.00002
cur_track_score = -1
cross_score = (cur_track_score * (1 - ep) - en * diff_track_scores[i][j]) * (
persons_ap_scores[i][j] + ep / (1 - ep - en)) / rand_track_score
cross_scores.append(cross_score)
persons_cross_scores.append(cross_scores)
print 'fusion scores ready'
# pickle_save(ctrl_msg['data_folder_path']+'viper_r-testpersons_cross_scores.pick', persons_cross_scores)
# pickle_save(ctrl_msg['data_folder_path']+'viper_r-testpersons_ap_pids.pick', persons_ap_pids)
max_score_s = [max(predict_cross_scores) for predict_cross_scores in persons_cross_scores]
for i, person_cross_scores in enumerate(persons_cross_scores):
for j, person_cross_score in enumerate(person_cross_scores):
if persons_cross_scores[i][j] >= 0:
# diff seq not sort, not rank for max, and not normalize
if max_score_s[i] == 0:
# there exist probe track with same seq, diff camera but value > 1000
print i
else:
persons_cross_scores[i][j] /= max_score_s[i]
# persons_cross_scores[i][j] /= max_score
# if persons_cross_scores[i][j] > 0.5:
# print 'same'
# print persons_cross_scores[i][j]
else:
# so diff seq is negative, normalize by minimum
# persons_cross_scores[i][j] /= min_score_s[i]
# persons_cross_scores[i][j] *= 1.0
persons_cross_scores[i][j] *= -0.00002
# print persons_cross_scores[i][j]
print 'fusion scores normalized, diff seq use vision score to rank'
person_score_idx_s = list()
for i, person_cross_scores in enumerate(persons_cross_scores):
# 单个probe的预测结果中按score排序，得到index，用于对pid进行排序
sort_score_idx_s = sorted(range(len(person_cross_scores)), key=lambda k: -person_cross_scores[k])
person_score_idx_s.append(sort_score_idx_s)
sorted_persons_ap_pids = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
sorted_persons_ap_scores = np.zeros([len(persons_ap_pids), len(persons_ap_pids[0])])
for i, person_ap_pids in enumerate(persons_ap_pids):
for j in range(len(person_ap_pids)):
sorted_persons_ap_pids[i][j] = persons_ap_pids[i][person_score_idx_s[i][j]]
sorted_persons_ap_scores[i][j] = persons_cross_scores[i][person_score_idx_s[i][j]]
print 'sorted scores ready'
np.savetxt(log_path, sorted_persons_ap_pids, fmt='%d')
np.savetxt(map_score_path, sorted_persons_ap_scores, fmt='%f')
print 'save sorted fusion scores'
# for i, person_ap_pids in enumerate(persons_ap_pids):
# for j in range(len(person_ap_pids)):
# write(log_path, '%d ' % person_ap_pids[person_score_idx_s[i][j]])
# write(map_score_path, '%.3f ' % persons_cross_scores[i][person_score_idx_s[i][j]])
# write(log_path, '\n')
# write(map_score_path, '\n')
return person_score_idx_s
score = (right_index - left_index) / float(total_cnt)
# 训练集中同摄像头概率很高,但评估又不要同摄像头的,体现空间概率很不划算
# score = (right_index - left_index + 1) / float(len(camera_delta_s[camera1][camera2]))
if len(delta_distribution) == 0:
return 0.0
# score = (right_index - left_index + 1) / float(len(camera_delta_s[camera1][2]))
# if score > 0:
# print(len(delta_distribution))
# print('delta range %d ~ %d' % (delta_distribution[0], delta_distribution[-1]))
# print(left_index)
# print(right_index)
# print('probablity: %f%%' % (score * 100))
return score
def track_interval_score(interval_score_s, camera1, time1, camera2, time2):
delta = time2 - time1
for i, camera_pair_travel_prob in enumerate(
interval_score_s[camera1 - 1][camera2 - 1]):
if camera_pair_travel_prob['left'] < delta < camera_pair_travel_prob[
'right']:
print(
'camera1: %d, camera2: %d, delta: %d, interval: %d, prob: %f' %
(camera1, camera2, delta, i, camera_pair_travel_prob['prob']))
return camera_pair_travel_prob['prob']
return 0
if __name__ == '__main__':
camera_delta_s = pickle_load('data/top10/sorted_deltas.pickle')
track_score(camera_delta_s, 1, 25, 2, 250)
def fusion_curve(fusion_param):
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
rand_camera_deltas = pickle_load(
fusion_param['rand_distribution_pickle_path'])
diff_camera_deltas = pickle_load(
fusion_param['rand_distribution_pickle_path'].replace('rand', 'diff'))
# for actual calculate
delta_width = 2000.0
delta_cnt = int(delta_width / 100)
# for distribution viz
# delta_width = 3000.0
# delta_cnt = 10
interval_width = delta_width / delta_cnt
delta_stripe = delta_width / delta_cnt
delta_range = map(lambda x: x * delta_stripe - delta_width / 2,
range(delta_cnt))
# delta_range = map(lambda x: x*1.0 - 60.0, range(120))
over_probs = [[list() for j in range(6)] for i in range(6)]
probs = list()
for i in range(6):
for j in range(6):
if i == j:
continue
cur_prob = list()
for k in range(len(delta_range)):
match_track_score = track_score(camera_delta_s,
i + 1,
0,
j + 1,
delta_range[k],
interval=interval_width,
filter_interval=delta_width /
2)
rand_track_score = track_score(rand_camera_deltas,
i + 1,
0,
j + 1,
delta_range[k],
interval=interval_width,
filter_interval=delta_width / 2)
diff_track_score = track_score(diff_camera_deltas,
i + 1,
0,
j + 1,
delta_range[k],
interval=interval_width,
filter_interval=delta_width / 2)
if rand_track_score < 0.00002:
# print rand_track_score
rand_track_score = 0.00002
# if i == 3 and j == 4 and abs(delta_range[k]) <= 2000 :
# print i
# else:
# print match_track_score / rand_track_score
cur_prob.append(rand_track_score)
# raw_probs[i][j].append(match_track_score)
# rand_probs[i][j].append(rand_track_score)
# over_probs[i][j].append(rand_track_score)
# over_probs[i][j].append((match_track_score * (1 - 0.25) - 0.5 * diff_track_score) *
# (0.8 + 0.25 / 0.25) / rand_track_score)
over_probs[i][j].append(match_track_score)
probs.append(over_probs[i][j])
np_probs = np.array(probs)
np.savetxt('market-grid-cv0_scores.txt', np_probs, fmt='%.6f\t')
return delta_range, over_probs
def load_viz_deltas_distribution(delta_path):
cameras_delta_s = pickle_load(delta_path)
return cameras_delta_s
local_interval_length, left_local_index, right_local_index = local_frame_infos(frames, time1, filter_interval)
left_time_min = min(frames[left_local_index], left_time_min)
right_time_max = max(frames[right_local_index], right_time_max)
left_bound = cur_delta - interval
right_bound = cur_delta + interval
local_deltas = deltas[left_local_index: right_local_index]
target_interval_cnt = len(local_deltas[(local_deltas > left_bound) & (local_deltas < right_bound)])
# target_interval_cnt = c_bisect_lib.in_count(local_deltas, len(local_deltas), left_bound, right_bound)
all_frame_cnt_for_camera1 = local_interval_length
for i in range(len(cameras_delta_s)):
if i == camera1 or i == camera2:
continue
tmp_frames = cameras_frame_s[camera1][i]
tmp_local_interval_length = other_frames_length(tmp_frames, left_time_min, right_time_max)
all_frame_cnt_for_camera1 += tmp_local_interval_length
# if we use uniform Denominator, we means spatial & temporal probability
score = target_interval_cnt / float(all_frame_cnt_for_camera1)
return score
if __name__ == '__main__':
ctrl_msg['ep'] = 0
ctrl_msg['en'] = 0
ctrl_msg['data_folder_path'] = 'market_duke-test'
fusion_param = get_fusion_param()
camera_delta_s = pickle_load(fusion_param['distribution_pickle_path'])
track_score(camera_delta_s, 1, 25, 2, 5250, filter_interval=40000)
