def write_with_confidence(confidence_bound):
cross_score_path = 'data/top10-test/cross_filter_score.log'
cross_pid_path = 'data/top10-test/cross_filter_pid.log'
filter_pid_path = 'data/top10/conf_filter_pid.log'
filter_score_path = 'data/top10/conf_filter_score.log'
safe_remove(filter_pid_path)
safe_remove(filter_score_path)
score_lines = read_lines(cross_score_path)
persons_scores = [[float(score) for score in score_line.split()] for score_line in score_lines]
max_score = max([max(predict_scores) for predict_scores in persons_scores])
pid_lines = read_lines(cross_pid_path)
write_line_cnt = 0
for i in range(len(persons_scores)):
scores = persons_scores[i]
pids = pid_lines[i].split()
has_write = False
for j in range(len(persons_scores[0])):
confidence = max(scores[j]/max_score, 1 - scores[j]/max_score)
if confidence < confidence_bound:
# print(confidence)
if not has_write:
write_line_cnt += 1
has_write = True
write(filter_pid_path, pids[j] + ' ')
write(filter_score_path, '%f ' % scores[j])
write(filter_pid_path, '\n')
write(filter_score_path, '\n')
return write_line_cnt
def save_market_test_truth():
ctrl_msg['data_folder_path'] = 'market_market-test'
fusion_param = get_fusion_param()
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])])
gallery_tracks.extend(query_tracks)
print(len(gallery_tracks))
deltas = [[list() for j in range(6)] for i in range(6)]
for i, market_probe_track in enumerate(gallery_tracks):
if gallery_tracks[i][0] == 0 or gallery_tracks[i][0] == -1:
continue
for j in range(len(gallery_tracks)):
if gallery_tracks[i][0] == gallery_tracks[j][0] \
and i != j \
and gallery_tracks[i][3] == gallery_tracks[j][3] \
and gallery_tracks[i][1] != gallery_tracks[j][1]:
if gallery_tracks[i][1] == 4 and gallery_tracks[j][1] - 1 == 5:
if j >= 19732:
print gallery_tracks[i][2] - gallery_tracks[j][2]
deltas[gallery_tracks[i][1] -
1][gallery_tracks[j][1] -
1].append(gallery_tracks[i][2] -
gallery_tracks[j][2])
for camera_delta in deltas:
for delta_s in camera_delta:
delta_s.sort()
pickle_save('true_market_pg.pck', deltas)
def parse_tracks(track_path):
answer_lines = read_lines(track_path)
real_tracks = list()
cameras = set()
seqs = set()
for i, answer in enumerate(answer_lines):
info = answer.split('_')
if len(info) < 1:
continue
if 'bmp' in info[2]:
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
real_tracks.append([int(info[0]), int(info[1][0]), int(info[2])])
elif 'f' in info[2]:
real_tracks.append(
[int(info[0]),
int(info[1][1]),
int(info[2][1:-5]), 1])
else:
real_tracks.append(
[int(info[0]),
int(info[1][1]),
int(info[2]),
int(info[1][3])])
cameras.add(real_tracks[i][1])
seqs.add(real_tracks[i][3])
return real_tracks, cameras, seqs
def st_hp_sensitivity_eval(sense_file_path):
lines = read_lines(sense_file_path)
grid_avg_accs = list()
for i, line in enumerate(lines):
if i % 2 == 0:
continue
grid_avg_accs.append(float(line.split()[0]))
viz_gray_map(duke_sensity_data(grid_avg_accs))
def write_unequal_rand_st_model(fusion_param):
# fusion_param = get_fusion_param()
rand_answer_path = fusion_param['answer_path'].replace(ctrl_msg['data_folder_path'],
ctrl_msg['data_folder_path'] + '_uerand')
rand_folder_path = folder(rand_answer_path)
safe_mkdir(rand_folder_path)
# although copy all info including pid info, but not use in later training
shutil.copy(fusion_param['answer_path'], rand_answer_path)
rand_path = rand_folder_path + '/renew_pid.log'
safe_remove(rand_path)
origin_tracks = get_tracks(fusion_param)
pid_cnt = len(origin_tracks)
origin_pids = map(lambda x: x + 1, range(pid_cnt))
persons_rand_predict_idx_s = [random.sample(origin_pids, pid_cnt) for _ in range(pid_cnt)]
viz_pid_path = fusion_param['renew_pid_path']
viz_score_path = fusion_param['renew_ac_path']
viz_pids = read_lines(viz_pid_path)
viz_pids = [per_viz_pids.split() for per_viz_pids in viz_pids]
viz_scores = read_lines(viz_score_path)
viz_scores = [per_viz_scores.split() for per_viz_scores in viz_scores]
viz_same_pids = [
[
int(viz_pid) for viz_pid, viz_score in zip(per_viz_pids, per_viz_scores) if float(viz_score) > 0.7
] for per_viz_scores, per_viz_pids in zip(viz_scores, viz_pids)
]
persons_unequal_rand_predict_idx_s = list()
for i in range(pid_cnt):
diff_persons = list(set(persons_rand_predict_idx_s[i]) ^ set(viz_same_pids[i]))
diff_cnt = len(diff_persons)
persons_unequal_rand_predict_idx_s.append(
random.sample(diff_persons, diff_cnt)
)
write_content = ''
for rand_predict_idx_s in persons_unequal_rand_predict_idx_s:
for rand_predict_idx in rand_predict_idx_s:
write_content += str(rand_predict_idx) + ' '
write_content += '\n'
write(rand_path, write_content)
def save_market_img_list(img_list_path, dest_path):
answer_lines = read_lines(img_list_path)
query_tracks = list()
for i, answer in enumerate(answer_lines):
info = answer.split('_')
query_tracks.append(
[i, info[0],
int(info[1][1]),
int(info[2]),
int(info[1][3])])
query_tracks = np.array(query_tracks).astype(int)
np.savetxt(dest_path, query_tracks, fmt='%d', delimiter='\t')
def sensitivity_eval(sense_file_path):
lines = read_lines(sense_file_path)
rank1_accs = list()
cur_cv = -1
for i, line in enumerate(lines):
if i % 20 == 0:
rank1_accs.append(list())
cur_cv += 1
if i % 2 == 0:
continue
rank1_accs[cur_cv].append(float(line.split()[0]))
grid_avg_accs = np.array(rank1_accs).mean(axis=0)
viz_gray_map(gray_data(grid_avg_accs))
def train_tracks(fusion_param):
answer_path = fusion_param['answer_path']
answer_lines = read_lines(answer_path)
# 左图
real_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]:
real_tracks.append([info[0], int(info[1][0]), int(info[2])])
elif 'f' in info[2]:
real_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
else:
real_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
return real_tracks
def iter_vision_acc_data(data_path):
lines = read_lines(data_path)
cv_accs = list()
acc_cnt = 0
cv_cnt = -1
for i, line in enumerate(lines):
if i % 2 == 0:
continue
if (i - 1) % 22 == 0:
cv_cnt += 1
cv_accs.append(list())
cv_accs[cv_cnt].append(float(line.split()[0]))
acc_cnt += 1
avg_accs = np.array([np.array(cv_accs[i]) for i in range(cv_cnt + 1)])
avg_accs = avg_accs.mean(axis=0)
return avg_accs
def sensitivity_eval():
grid_sensity_values = list()
lines = read_lines('../post_process/market_sense.txt')
rank1_accs = list()
cur_cv = -1
for i, line in enumerate(lines):
if i % 20 == 0:
rank1_accs.append(list())
cur_cv += 1
if i % 2 == 0:
continue
rank1_accs[cur_cv].append(float(line.split()[0]))
grid_avg_accs = np.array(rank1_accs).mean(axis=0)
market_values = [
0.740202, 0.746437, 0.746140, 0.745843, 0.739311, 0.745843, 0.746140,
0.739905, 0.746734, 0.739311
]
viz_gray_map(gray_data(grid_avg_accs))
def iter_acc_data(data_path):
lines = read_lines(data_path)
cv_accs = list()
acc_cnt = 0
cv_cnt = -1
for i, line in enumerate(lines):
if i % 2 == 0:
continue
if (i - 1) % 44 == 0:
cv_cnt += 1
cv_accs.append([list(), list()])
if acc_cnt % 2 == 0:
cv_accs[cv_cnt][0].append(float(line.split()[0]))
else:
cv_accs[cv_cnt][1].append(float(line.split()[0]))
acc_cnt += 1
avg_accs = np.array(cv_accs).mean(axis=0)
return avg_accs
def avg_acc2(grid_eval_path):
grid_infos = read_lines(grid_eval_path)
before_vision_accs = [0.0, 0.0, 0.0, 0.0]
before_fusion_accs = [0.0, 0.0, 0.0]
after_vision_accs = [0.0, 0.0, 0.0]
after_fusion_accs = [0.0, 0.0, 0.0]
i_cv_cnt = 0
for i, grid_info in enumerate(grid_infos):
if i % 2 != 0:
accs = grid_info.split()
for j in range(4):
before_vision_accs[j] += float(accs[j])
i_cv_cnt += 1
write('grid_eval.log', '\n' + grid_eval_path + '\n')
write(
'grid_eval.log', '& %.2f & %.2f & %.2f & %.2f\n' %
(before_vision_accs[0] * 10, before_vision_accs[1] * 10,
before_vision_accs[2] * 10, before_vision_accs[3] * 10))
def load_train_img_infos(train_imgs_path):
train_imgs_lines = read_lines(train_imgs_path)
real_tracks = list()
max_camera_cnt = 0
for answer in train_imgs_lines:
info = answer.split('_')
if 'bmp' in info[2]:
# viper
info[2] = info[2].split('.')[0]
if len(info) > 4 and 'jpe' in info[6]:
# grid
real_tracks.append([info[0], int(info[1][0]), int(info[2]), 1])
elif 'f' in info[2]:
# duke
real_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
else:
# market
real_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
# real track: person_id, camera_num, time, sequence num
max_camera_cnt = max(real_tracks[-1][1], max_camera_cnt)
return real_tracks, max_camera_cnt
def avg_acc(grid_eval_path):
grid_infos = read_lines(grid_eval_path)
before_vision_accs = [0.0, 0.0, 0.0]
before_fusion_accs = [0.0, 0.0, 0.0]
after_vision_accs = [0.0, 0.0, 0.0]
after_fusion_accs = [0.0, 0.0, 0.0]
i_cv_cnt = 0
for i, grid_info in enumerate(grid_infos):
if i % 2 != 0:
accs = grid_info.split()
if i_cv_cnt % 4 == 0:
for j in range(3):
before_vision_accs[j] += float(accs[j])
if i_cv_cnt % 4 == 1:
for j in range(3):
before_fusion_accs[j] += float(accs[j])
if i_cv_cnt % 4 == 2:
for j in range(3):
after_vision_accs[j] += float(accs[j])
if i_cv_cnt % 4 == 3:
for j in range(3):
after_fusion_accs[j] += float(accs[j])
i_cv_cnt += 1
write('grid_eval.log', '\n' + grid_eval_path + '\n')
write(
'grid_eval.log', 'before_retrain_vision\n%f %f %f\n' %
(before_vision_accs[0] / 10, before_vision_accs[1] / 10,
before_vision_accs[2] / 10))
write(
'grid_eval.log', 'before_retrain_fusion\n%f %f %f\n' %
(before_fusion_accs[0] / 10, before_fusion_accs[1] / 10,
before_fusion_accs[2] / 10))
write(
'grid_eval.log', 'after_retrain_vision\n%f %f %f\n' %
(after_vision_accs[0] / 10, after_vision_accs[1] / 10,
after_vision_accs[2] / 10))
write(
'grid_eval.log', 'after_retrain_fusion\n%f %f %f\n' %
(after_fusion_accs[0] / 10, after_fusion_accs[1] / 10,
after_fusion_accs[2] / 10))
def get_predict_delta_tracks(fusion_param, useful_predict_limit=10, random=False, diff_person=False, use_real_st=False):
# 获取左图列表
answer_path = fusion_param['answer_path']
answer_lines = read_lines(answer_path)
camera_cnt = 6
real_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]:
# grid
real_tracks.append([info[0], int(info[1][0]), int(info[2]), 1])
elif 'f' in info[2]:
real_tracks.append([info[0], int(info[1][1]), int(info[2][1:-5]), 1])
camera_cnt = 8
else:
# market
real_tracks.append([info[0], int(info[1][1]), int(info[2]), int(info[1][3])])
print 'left image ready'
# 获取右图列表
renew_pid_path = fusion_param['renew_pid_path']
predict_lines = read_lines(renew_pid_path)
print 'predict images ready'
# 左图中的人在右图可能出现在6个摄像头中
camera_delta_s = [[list() for j in range(camera_cnt)] for i in range(camera_cnt)]
person_cnt = len(answer_lines)
# market1501数据集有六个序列，只有同一个序列才能计算delta
if random:
useful_predict_limit = max(len(predict_lines)/100, 10)
for i, line in enumerate(predict_lines):
predict_pids = line.split(' ')
useful_cnt = 0
for j, predict_pid in enumerate(predict_pids):
if useful_cnt > useful_predict_limit:
break
if random:
predict_pid = randint(0, person_cnt - 1)
elif diff_person:
predict_pid = randint(10, person_cnt - 1)
else:
# todo transfer: if predict by python, start from 0, needn't minus 1
predict_pid = int(predict_pid)
predict_pid = int(predict_pid)
# same seq
# todo ignore same camera track
if real_tracks[i][3] == real_tracks[predict_pid][3] and real_tracks[i][1] != real_tracks[predict_pid][1]:
# and pid equal: real st
# if use_real_st and random or real_tracks[i][0] == real_tracks[predict_pid][0]:
if True:
useful_cnt += 1
delta = real_tracks[i][2] - real_tracks[predict_pid][2]
if abs(delta) < 1000000:
camera_delta_s[real_tracks[i][1] - 1][real_tracks[predict_pid][1] - 1].append(delta)
print 'deltas collected'
for camera_delta in camera_delta_s:
for delta_s in camera_delta:
delta_s.sort()
print 'deltas sorted'
# for python
safe_remove(fusion_param['distribution_pickle_path'])
pickle_save(fusion_param['distribution_pickle_path'], camera_delta_s)
print 'deltas saved'
return camera_delta_s
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
def percent_shot_eval(target_path, top_cnt, test_mode=False):
global gallery_cnt
gallery_cnt = 0
answer_path = folder(target_path) + '/test_tracks.txt'
predict_path = target_path
answer_lines = read_lines(answer_path)
real_pids = [int(answer.split('_')[0]) for answer in answer_lines]
def is_shot(line):
global line_idx
global shot_line_cnt
global shot_cnt
global predict_cnt
global predict_line_cnt
global gallery_cnt
predict_idx_es = line.split()
has_shot = False
if len(predict_idx_es) > top_cnt:
predict_cnt += top_cnt
else:
predict_cnt += len(predict_idx_es)
if len(predict_idx_es) > 0:
predict_line_cnt += 1
# line_idx > 774 means label img,
# gallery_idxs[(line_idx - 775)/2] means iseven in gallery,
# if iseven is equal, means gallery img
if test_mode and line_idx > 774 and (line_idx - 774) % 2 == 1:
gallery_cnt += 1
line_idx += 1
return
for i, predict_idx in enumerate(predict_idx_es):
if i >= top_cnt:
break
# print(line_idx)
if real_pids[int(predict_idx) - 1] == real_pids[line_idx]:
if not has_shot:
shot_line_cnt += 1
has_shot = True
shot_cnt += 1
line_idx += 1
read_lines_and(predict_path, is_shot)
global line_idx
global shot_line_cnt
global shot_cnt
global predict_cnt
global predict_line_cnt
# print('all predict shot(ac1): %f' % (float(shot_cnt) / predict_cnt))
if test_mode:
valid_line_cnt = 125
else:
valid_line_cnt = 250
shot_rate = shot_line_cnt / float(valid_line_cnt)
print('top%d shot: %f' % (top_cnt, shot_rate))
print('gallery cnt: %d' % gallery_cnt)
line_idx = 0
shot_cnt = 0
shot_line_cnt = 0
predict_cnt = 0
predict_line_cnt = 0
return shot_rate
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_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 read_caltech():
train_features = list()
train_labels = list()
test_features = list()
test_labels = list()
i = 0
max_read = 15000
for files in os.listdir(caltech_train_pos_path):
if i > max_read:
break
i += 1
path = os.path.join(caltech_train_pos_path, files)
features = read_lines(path)
# print(path)
train_features.append(features)
train_features.append(features)
train_features.append(features)
train_labels.append([1, 0])
train_labels.append([1, 0])
train_labels.append([1, 0])
pos_train_cnt = len(train_labels) / 3
print(pos_train_cnt)
i = 0
for files in os.listdir(caltech_train_neg_path):
if i > max_read:
break
i += 1
path = os.path.join(caltech_train_neg_path, files)
# print(path)
features = read_lines(path)
train_features.append(features)
train_labels.append([0, 1])
print(len(train_labels) - pos_train_cnt * 3)
i = 0
for files in os.listdir(caltech_test_pos_path):
if i > max_read:
break
i += 1
path = os.path.join(caltech_test_pos_path, files)
# print(path)
features = read_lines(path)
test_features.append(features)
test_labels.append([1, 0])
pos_test_cnt = len(test_labels) / 3
print(pos_test_cnt)
i = 0
for files in os.listdir(caltech_test_neg_path):
if i > max_read:
break
i += 1
path = os.path.join(caltech_test_neg_path, files)
# print(path)
features = read_lines(path)
test_features.append(features)
test_labels.append([0, 1])
print(len(test_labels) - pos_test_cnt)
train_tuples = zip(train_features, train_labels)
random.shuffle(train_tuples)
train_features = [train_tuple[0] for train_tuple in train_tuples]
train_labels = [train_tuple[1] for train_tuple in train_tuples]
test_tuples = zip(test_features, test_labels)
random.shuffle(test_tuples)
test_features = [test_tuple[0] for test_tuple in test_tuples]
test_labels = [test_tuple[1] for test_tuple in test_tuples]
return train_features, train_labels, test_features, test_labels
def get_shot_rate():
shot_rate_s = read_lines('data/ep_en.txt')
final_shot_rate = shot_rate_s[-1].split()
return float(final_shot_rate[0]), float(final_shot_rate[1])
from util.file_helper import read_lines, write
import seaborn as sns
import numpy as np
if __name__ == '__main__':
# for i in range(10):
for i in range(1):
person_lines = read_lines('data/top-m2g-std%d-train/cross_filter_pid.log' % i)
predict_persons = [predict_line.split() for predict_line in person_lines]
score_lines = read_lines('data/top-m2g-std%d-train/cross_filter_score.log' % i)
predict_scores = [score_line.split() for score_line in score_lines]
write('data/top1.txt', 'std %d top1\n' % i)
scores = list()
pos_cnt = 0
in_cnt = 0
up_b = 1.
down_b = 0.16
for k in range(10):
for j in range(len(predict_persons)):
score = float(predict_scores[j][0])
r = int(predict_persons[j][0]) - j - 1
if abs(r) == 1:
write('data/top1.txt', 'left %d, right %d, score %f\n' % (j + 1, int(predict_persons[j][0]), score))
scores.append(score)
if down_b < score < up_b:
in_cnt += 1
if abs(r) == 1:
pos_cnt += 1
if in_cnt == 0:
in_cnt = 1
