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 test_fusion(fusion_param, ep=0.5, en=0.01): # copy sort pickle safe_remove(fusion_param['distribution_pickle_path']) try: # 直接使用训练集的时空模型 shutil.copy(fusion_param['src_distribution_pickle_path'], fusion_param['distribution_pickle_path']) print 'copy train track distribute pickle done' except shutil.Error: print 'pickle ready' # merge visual probability and track distribution probability fusion_st_gallery_ranker(fusion_param)
def store_sorted_deltas(fusion_param): # 时空模型构建核心函数, # 存储每对摄像头的时间差分布, # 共6×6个数组,每个数组长度为该对摄像头统计到的时间差数目 # 这个函数运行前会删除distribution_pickle_path: sorted_deltas.pickle,因此也不会有缓存问题 camera_delta_s = viz_data_for_market(fusion_param) # 对时间差做排序,在预测的时候能快速定位时间差位置,得到时间差的概率 for camera_delta in camera_delta_s: for delta_s in camera_delta: delta_s.sort() # for python safe_remove(fusion_param['distribution_pickle_path']) pickle_save(fusion_param['distribution_pickle_path'], camera_delta_s)
def duke_tracks_realloc(tracks, track_name, data_type): target_list_path = '../data/%s/%s.list' % (track_name, data_type) target_track_info_dir_path = '/home/cwh/coding/TrackViz/data/%s' % track_name safe_mkdir(target_track_info_dir_path) target_track_dir_path = '/home/cwh/coding/%s' % track_name safe_mkdir(target_track_dir_path) target_track_type_dir_path = '/home/cwh/coding/%s/%s' % (track_name, data_type) safe_mkdir(target_track_type_dir_path) for track in tracks: source_img_name = '%04d_c%d_f%07d.jpg' % (int( track[0]), track[1], track[2]) target_img_name = '%05d%07d%03d.jpg' % (int( track[0]), track[2], track[1]) shutil.copyfile( '/home/cwh/coding/DukeMTMC-reID/%s/%s' % (data_type, source_img_name), '%s/%s' % (target_track_type_dir_path, target_img_name)) safe_remove(target_list_path)
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 duke_tracks_realloc(tracks, track_name, data_type): target_list_path = '../data/%s/%s.list' % (track_name, data_type) target_track_info_dir_path = '/home/cwh/coding/TrackViz/data/%s' % track_name safe_mkdir(target_track_info_dir_path) target_track_dir_path = '/home/cwh/coding/%s' % track_name safe_mkdir(target_track_dir_path) target_track_type_dir_path = '/home/cwh/coding/%s/%s' % (track_name, data_type) safe_mkdir(target_track_type_dir_path) names = list() for track in tracks: img_name = '%04d_c%d_f%07d.jpg' % (int(track[0]), track[1], track[2]) shutil.copyfile( '/home/cwh/coding/DukeMTMC-reID/%s/%s' % (data_type, img_name), '%s/%s' % (target_track_type_dir_path, img_name)) names.append(img_name) names.append('\n') list_stmt = ''.join(names) safe_remove(target_list_path) write(target_list_path, list_stmt)
def write_rand_pid(fusion_param): # 对每张左图, 随机生成250个右图的pid,相当于一个随机的renew_pid.log,rand_path也会每次都删除,所以不存在缓存 # todo 不一定需要生成250个右图 # fusion_param = get_fusion_param() rand_answer_path = fusion_param['answer_path'].replace(ctrl_msg['data_folder_path'], ctrl_msg['data_folder_path'] + '_rand') 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)] write_content = '' for rand_predict_idx_s in persons_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 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 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 get_predict_tracks(fusion_param, useful_predict_cnt=10): # 这个函数根据预测的pid,生成更多的图片名,从而构造时空模型, # 例如,左图1_c1_t2的匹配图片id是2_c2_t3,3_c3_t3,6_c4_t1, # 则生成1_c2_t3, 1_c3_t3, 1_c4_t1,用于构造时空概率模型 # useful_predcit_cnt为10,实际上会对每张左图的名字产生10个右图的名字,加上原图就是11个新的名字 # 为了加快后续检索速度,将生成的图片名中,摄像头相同的,写到同一个文件里,即predict_camera_path: predict_c%d.txt # 每次运行这个函数都会删除predict_c%d.txt和predict_tracks.txt,所以不会有缓存旧结果的情况 # todo: 实际上可以在这一步直接生成cameras_deltas,之前是出于重用可视化代码考虑才使用了delta_track.py中的代码 # renew_pid_path: data/top-m2g-std0-train/renew_pid.log',包含左图预测的图片id, 250*249 renew_pid_path = fusion_param['renew_pid_path'] # predict_track_path:data/top-m2g-std0-train/predict_tracks.txt,存储get predict tracks结果 predict_track_path = fusion_param['predict_track_path'] # 获取左图列表 origin_tracks = get_tracks(fusion_param) # safe_remove(predict_track_path) camera_cnt = 8 global predict_line_idx predict_line_idx = 0 for i in range(camera_cnt): safe_remove(fusion_param['predict_camera_path'] + str(i) + '.txt') def add_predict_track(line): global predict_line_idx # print predict_line_idx if line == '\n': predict_line_idx += 1 return if predict_line_idx >= 248: print(predict_line_idx) if origin_tracks[predict_line_idx].startswith('-1'): tail = origin_tracks[predict_line_idx][2:-1] else: tail = origin_tracks[predict_line_idx][4:-1] if 's' in tail: s_num = int(tail[4]) else: s_num = 1 if predict_line_idx == 499: print(predict_line_idx) if 'jpe' in tail: camera = tail[1] else: camera = tail[2] track_time = tail.split('_')[2] mids = line.split() # 这里写入的是predict_line_idx,而非原来的person id,保证了无监督无标签 write_line( predict_track_path, ('%04d_c%ds%d_%d_n.jpg' % (int(predict_line_idx) + 1, int(camera), s_num, int(track_time)))) write_line( fusion_param['predict_camera_path'] + str(camera) + '.txt', ('%04d_c%ds%d_%d_n.jpg' % (int(predict_line_idx) + 1, int(camera), s_num, int(track_time)))) for i, mid in enumerate(mids): if i >= useful_predict_cnt: break write_line(predict_track_path, ('%04d_c%ds%d_%d_n.jpg' % (int(mid), int(camera), s_num, int(track_time)))) write_line( fusion_param['predict_camera_path'] + str(camera) + '.txt', ('%04d_c%ds%d_%d_n.jpg' % (int(mid), int(camera), s_num, int(track_time)))) predict_line_idx += 1 # print('done') read_lines_and(renew_pid_path, add_predict_track)