def predict_track_scores(real_tracks, camera_delta_s, fusion_param, smooth=False):
# fusion_param = get_fusion_param()
# persons_deltas_score = pickle_load(fusion_param['persons_deltas_path'])
# if pickle_load(fusion_param['persons_deltas_path']) is not None:
# return persons_deltas_score
predict_path = fusion_param['renew_pid_path']
# test_tracks.txt
top_cnt = 10
persons_deltas_score = list()
# todo 不用读第二遍
pids4probes = np.genfromtxt(predict_path, delimiter=' ')
for probe_i, pids4probe in enumerate(pids4probes):
person_deltas_score = list()
if probe_i % 100 == 0:
print '%d of %d' % (probe_i, len(pids4probes))
for pid4probe in pids4probe:
# todo transfer: if predict by python, start from 0, needn't minus 1
pid4probe = int(pid4probe)
# predict_idx = predict_idx - 1
if len(real_tracks[pid4probe]) > 3:
s1 = real_tracks[pid4probe][3]
s2 = real_tracks[probe_i][3]
if s1 != s2:
person_deltas_score.append(-1.0)
continue
time1 = real_tracks[pid4probe][2]
# if track_score_idx == 3914:
# print 'test'
time2 = real_tracks[probe_i][2]
c1 = real_tracks[pid4probe][1]
c2 = real_tracks[probe_i][1]
if smooth:
if '_dukequerytail' in predict_path:
score = track_score(camera_delta_s, c1, time1, c2, time2, interval=500, moving_st=True, filter_interval=50000)
else:
score = smooth_score(c1, c2, time1, time2, camera_delta_s)
else:
# 给定摄像头，时间，获取时空评分，这里camera_deltas如果是随机算出来的，则是随机评分
# todo grid 需要 改区间大小
if '_dukequerytail' in predict_path:
score = track_score(camera_delta_s, c1, time1, c2, time2,
interval=fusion_param['window_interval'], moving_st=True,
filter_interval=fusion_param['filter_interval'])
else:
score = track_score(camera_delta_s, c1, time1, c2, time2, interval=700, filter_interval=40000)
person_deltas_score.append(score)
probe_i += 1
persons_deltas_score.append(person_deltas_score)
return persons_deltas_score
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 gallery_track_scores(query_tracks, gallery_tracks, camera_delta_s, fusion_param, smooth=False):
predict_path = fusion_param['renew_pid_path']
persons_deltas_score = list()
pids4probes = np.genfromtxt(predict_path, delimiter=' ')
for probe_i, pids4probe in enumerate(pids4probes):
person_deltas_score = list()
for i, pid4probe in enumerate(pids4probe):
# if i >= top_cnt:
# break
pid4probe = int(pid4probe)
if len(query_tracks[0]) > 3:
# market index minus 1
probe_i_tmp = probe_i # (probe_i + 1) % len(pids4probes)
else:
probe_i_tmp = probe_i
# todo transfer: if predict by python, start from 0, needn't minus 1
# predict_idx = predict_idx - 1
if len(query_tracks[probe_i_tmp]) > 3:
s1 = query_tracks[probe_i_tmp][3]
# print predict_idx
s2 = gallery_tracks[pid4probe][3]
if s1 != s2:
person_deltas_score.append(-1.0)
continue
time1 = query_tracks[probe_i_tmp][2]
# if track_score_idx == 3914:
# print 'test'
time2 = gallery_tracks[pid4probe][2]
c1 = query_tracks[probe_i_tmp][1]
c2 = gallery_tracks[pid4probe][1]
if smooth:
score = smooth_score(c1, c2, time1, time2, camera_delta_s)
else:
# 给定摄像头，时间，获取时空评分，这里camera_deltas如果是随机算出来的，则是随机评分
if 'market_market' in predict_path:
score = track_score(camera_delta_s, c1, time1, c2, time2, interval=100, filter_interval=500)
elif '_market' in predict_path:
score = track_score(camera_delta_s, c1, time1, c2, time2, interval=700, filter_interval=40000)
elif '_duke' in predict_path:
score = track_score(camera_delta_s, c1, time1, c2, time2, interval=700, filter_interval=50000)
else:
score = track_score(camera_delta_s, c1, time1, c2, time2)
person_deltas_score.append(score)
probe_i += 1
persons_deltas_score.append(person_deltas_score)
return persons_deltas_score
def smooth_score(c1, c2, time1, time2, camera_delta_s, track_interval=20, filter_interval=1000):
smooth_window_size = 10
smooth_scores = [
track_score(camera_delta_s, c1,
time1 - (smooth_window_size / 2 - 1) * track_interval + j * track_interval, c2, time2,
interval=track_interval, filter_interval=filter_interval)
for j in range(smooth_window_size)]
# filter
for j in range(smooth_window_size):
if smooth_scores[j] < 0.01:
smooth_scores[j] = 0
# smooth
score = sum(smooth_scores) / len(smooth_scores)
return score
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
