def my_main(tracktor, _config):
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
print("[*] Beginning process...")
for seq in Datasets(tracktor['dataset']):
print(f"[*] Processing sequence {seq}")
img_output_dir = osp.join(output_dir, tracktor['dataset'], str(seq))
if tracktor['write_images'] and not osp.exists(img_output_dir):
os.makedirs(img_output_dir)
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
flows = []
for i, frame in enumerate(tqdm(data_loader)):
current_img = np.transpose(frame['img'][0].cpu().numpy(),
(1, 2, 0))
if i == 0:
prev_img = current_img
current_gray = cv2.cvtColor(current_img, cv2.COLOR_RGB2GRAY)
prev_gray = cv2.cvtColor(prev_img, cv2.COLOR_RGB2GRAY)
flow = cv2.calcOpticalFlowFarneback(prev_gray, current_gray, None,
0.5, 3, 15, 3, 5, 1.2,
cv2.OPTFLOW_FARNEBACK_GAUSSIAN)
flows.append(flow)
if tracktor['write_images']:
mask = np.zeros_like(current_img)
mask[..., 1] = 255
magnitude, angle = cv2.cartToPolar(flow[..., 0], flow[..., 1])
mask[..., 0] = angle * 180 / np.pi / 2
mask[..., 2] = cv2.normalize(magnitude, None, 0, 255,
cv2.NORM_MINMAX)
rgb = cv2.cvtColor(mask, cv2.COLOR_HSV2RGB)
save_path = osp.join(img_output_dir,
osp.basename(frame['img_path'][0]))
Image.fromarray(rgb.astype('uint8')).save(save_path)
prev_img = current_img
#write_optical_flow(results, warps, sequence, osp.join(output_dir, tracktor['dataset'], str(sequence)))
print("[*] Evaluation for all sets (without image generation): {:.3f} s".
format(time_total))
def validate_tracktor(motion_network, epoch):
# inject current network into tracker
tracker.motion_network = motion_network
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(train['tracktor_val_dataset'])
for seq in dataset:
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(
seq) * tracktor['frame_split'][1]:
tracker.step(frame)
num_frames += 1
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if tracktor['write_images']:
plot_sequence(
results, seq,
osp.join(output_dir, tracktor['dataset'], str(epoch),
str(seq)))
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
metrics = {}
if mot_accums:
summary = evaluate_mot_accums(
mot_accums, [str(s) for s in dataset if not s.no_gt],
generate_overall=True,
return_summary=True,
metrics=train['tracktor_val_metrics'])
metrics = {
m: summary.loc['OVERALL', m]
for m in train['tracktor_val_metrics']
}
return metrics
def my_main(_config, reid):
# set all seeds
torch.manual_seed(reid['seed'])
torch.cuda.manual_seed(reid['seed'])
np.random.seed(reid['seed'])
torch.backends.cudnn.deterministic = True
print(_config)
output_dir = 'D:/emartins/reiddd'
tb_dir = 'D:/emartins/reiddd'
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
#########################
# Initialize dataloader #
#########################
print("[*] Initializing Dataloader")
db_train = Datasets(reid['db_train'], reid['dataloader'])
db_train = DataLoader(db_train, batch_size=1, shuffle=True)
if reid['db_val']:
db_val = None
#db_val = DataLoader(db_val, batch_size=1, shuffle=True)
else:
db_val = None
##########################
# Initialize the modules #
##########################
print("[*] Building CNN")
network = resnet50(pretrained=False, **reid['cnn'])
network.train()
network.cuda()
##################
# Begin training #
##################
print("[*] Solving ...")
# build scheduling like in "In Defense of the Triplet Loss for Person Re-Identification"
# from Hermans et al.
lr = reid['solver']['optim_args']['lr']
iters_per_epoch = len(db_train)
# we want to keep lr until iter 15000 and from there to iter 25000 a exponential decay
l = eval("lambda epoch: 1 if epoch*{} < 15000 else 0.001**((epoch*{} - 15000)/(25000-15000))".format(
iters_per_epoch, iters_per_epoch))
#else:
# l = None
max_epochs = 25000 // len(db_train.dataset) + 1 if 25000 % len(db_train.dataset) else 25000 // len(db_train.dataset)
solver = Solver(output_dir, tb_dir, lr_scheduler_lambda=l)
solver.train(network, db_train, db_val, max_epochs, 100, model_args=reid['model_args'])
def my_main(plotter, _config):
output_dir = Path(get_output_dir(plotter['module_name'])) / plotter['name']
for sequence in Datasets(plotter['dataset']):
for file in Path(plotter['boxes_dir']).glob('*.pkl'):
with file.open('rb') as fh:
data = pickle.load(fh)[sequence._seq_name + '-FRCNN']
plot_sequence(
data, sequence, output_dir / plotter['dataset'] /
str(sequence) / str(file.stem))
def main(fg_detector, _config, _log, _run):
torch.manual_seed(fg_detector['seed'])
torch.cuda.manual_seed(fg_detector['seed'])
np.random.seed(fg_detector['seed'])
sacred.commands.print_config(_run)
output_dir = os.path.join(get_output_dir(fg_detector['module_name']),
fg_detector['name'])
sacred_config = os.path.join(output_dir, 'sacred_config.yaml')
if not os.path.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
# object detection
_log.info("Initializing foreground detector.")
dataset = Datasets(fg_detector['dataset'])
fg_det = FGDetector(fg_detector, dataset[3])
fg_det.calc_average_image()
grid_points = fg_det.calc_grid_points()
fg_det.calc_positions(grid_points)
def main(tracktor, reid, _config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'], tracktor['output_subdir'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector.")
obj_detect = FRCNN_FPN(num_classes=2).to(device)
obj_detect.load_state_dict(
torch.load(_config['tracktor']['obj_detect_model'],
map_location=lambda storage, loc: storage))
obj_detect.eval()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn']).to(device)
reid_network.load_state_dict(
torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(obj_detect, reid_network, tracktor['tracker'],
tracktor['oracle'])
else:
tracker = Tracker(obj_detect, reid_network, tracktor['tracker'])
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'])
for seq in dataset:
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(
seq) * tracktor['frame_split'][1]:
tracker.step(frame, i)
num_frames += 1
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
if tracktor['interpolate']:
results = interpolate(results)
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if tracktor['write_images']:
plot_sequence(results, seq,
osp.join(output_dir, tracktor['dataset'], str(seq)))
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
if mot_accums:
summary = evaluate_mot_accums(mot_accums,
[str(s) for s in dataset if not s.no_gt],
generate_overall=True)
summary.to_pickle(
"output/finetuning_results/results_{}_{}_{}_{}_{}.pkl".format(
tracktor['output_subdir'],
tracktor['tracker']['finetuning']['max_displacement'],
tracktor['tracker']['finetuning']['batch_size'],
tracktor['tracker']['finetuning']['learning_rate'],
tracktor['tracker']['finetuning']['iterations']))
def my_main(tracktor, siamese, _config):
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
print("[*] Building object detector")
if tracktor['network'].startswith('frcnn'):
# FRCNN
from tracktor.frcnn import FRCNN
from frcnn.model import config
if _config['frcnn']['cfg_file']:
config.cfg_from_file(_config['frcnn']['cfg_file'])
if _config['frcnn']['set_cfgs']:
config.cfg_from_list(_config['frcnn']['set_cfgs'])
obj_detect = FRCNN(num_layers=101)
obj_detect.create_architecture(2,
tag='default',
anchor_scales=config.cfg.ANCHOR_SCALES,
anchor_ratios=config.cfg.ANCHOR_RATIOS)
obj_detect.load_state_dict(torch.load(tracktor['obj_detect_weights']))
elif tracktor['network'].startswith('fpn'):
# FPN
from tracktor.fpn import FPN
from fpn.model.utils import config
config.cfg.TRAIN.USE_FLIPPED = False
config.cfg.CUDA = True
config.cfg.TRAIN.USE_FLIPPED = False
checkpoint = torch.load(tracktor['obj_detect_weights'])
if 'pooling_mode' in checkpoint.keys():
config.cfg.POOLING_MODE = checkpoint['pooling_mode']
set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'
]
config.cfg_from_file(_config['tracktor']['obj_detect_config'])
config.cfg_from_list(set_cfgs)
obj_detect = FPN(('__background__', 'pedestrian'),
101,
pretrained=False)
obj_detect.create_architecture()
obj_detect.load_state_dict(checkpoint['model'])
else:
raise NotImplementedError(
f"Object detector type not known: {tracktor['network']}")
pprint.pprint(config.cfg)
obj_detect.eval()
obj_detect.cuda()
# reid
reid_network = resnet50(pretrained=False, **siamese['cnn'])
reid_network.load_state_dict(torch.load(tracktor['reid_network_weights']))
reid_network.eval()
reid_network.cuda()
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(obj_detect, reid_network, tracktor['tracker'],
tracktor['oracle'])
else:
tracker = Tracker(obj_detect, reid_network, tracktor['tracker'])
print("[*] Beginning evaluation...")
time_total = 0
for sequence in Datasets(tracktor['dataset']):
tracker.reset()
now = time.time()
print("[*] Evaluating: {}".format(sequence))
data_loader = DataLoader(sequence, batch_size=1, shuffle=False)
for i, frame in enumerate(data_loader):
# frame_split = [0.0, 1.0]
if i >= len(sequence) * tracktor['frame_split'][0] and i <= len(
sequence) * tracktor['frame_split'][1]:
tracker.step(frame)
results = tracker.get_results()
time_total += time.time() - now
print("[*] Tracks found: {}".format(len(results)))
print("[*] Time needed for {} evaluation: {:.3f} s".format(
sequence,
time.time() - now))
if tracktor['interpolate']:
results = interpolate(results)
sequence.write_results(results, osp.join(output_dir))
if tracktor['write_images']:
plot_sequence(
results, sequence,
osp.join(output_dir, tracktor['dataset'], str(sequence)))
print("[*] Evaluation for all sets (without image generation): {:.3f} s".
format(time_total))
def main(module_name, name, seed, obj_detect_models, reid_models, tracker,
oracle, dataset, load_results, frame_range, interpolate, write_images,
_config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
np.random.seed(seed)
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(module_name), name)
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(copy.deepcopy(_config), outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector(s).")
obj_detects = []
for obj_detect_model in obj_detect_models:
obj_detect = FRCNN_FPN(num_classes=2)
obj_detect.load_state_dict(
torch.load(obj_detect_model,
map_location=lambda storage, loc: storage))
obj_detects.append(obj_detect)
obj_detect.eval()
if torch.cuda.is_available():
obj_detect.cuda()
# reid
_log.info("Initializing reID network(s).")
reid_networks = []
for reid_model in reid_models:
reid_cfg = os.path.join(os.path.dirname(reid_model),
'sacred_config.yaml')
reid_cfg = yaml.safe_load(open(reid_cfg))
reid_network = ReIDNetwork_resnet50(pretrained=False,
**reid_cfg['model_args'])
reid_network.load_state_dict(
torch.load(reid_model, map_location=lambda storage, loc: storage))
reid_network.eval()
if torch.cuda.is_available():
reid_network.cuda()
reid_networks.append(reid_network)
# tracktor
if oracle is not None:
tracker = OracleTracker(obj_detect, reid_network, tracker, oracle)
else:
tracker = Tracker(obj_detect, reid_network, tracker)
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(dataset)
for seq, obj_detect, reid_network in zip(dataset, obj_detects,
reid_networks):
tracker.obj_detect = obj_detect
tracker.reid_network = reid_network
tracker.reset()
_log.info(f"Tracking: {seq}")
start_frame = int(frame_range['start'] * len(seq))
end_frame = int(frame_range['end'] * len(seq))
seq_loader = DataLoader(
torch.utils.data.Subset(seq, range(start_frame, end_frame)))
num_frames += len(seq_loader)
results = {}
if load_results:
results = seq.load_results(output_dir)
if not results:
start = time.time()
for frame_data in tqdm(seq_loader):
with torch.no_grad():
tracker.step(frame_data)
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.2f} s.")
if interpolate:
results = interpolate_tracks(results)
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if seq.no_gt:
_log.info("No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq_loader))
if write_images:
plot_sequence(results, seq,
osp.join(output_dir, str(dataset), str(seq)),
write_images)
if time_total:
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.2f} s for {num_frames} frames ({num_frames / time_total:.2f} Hz)"
)
if mot_accums:
_log.info("Evaluation:")
evaluate_mot_accums(mot_accums,
[str(s) for s in dataset if not s.no_gt],
generate_overall=True)
def main(tracktor, reid, _config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector.")
obj_detect = FRCNN_FPN(num_classes=2)
obj_detect.load_state_dict(
torch.load(_config['tracktor']['obj_detect_model'],
map_location=lambda storage, loc: storage))
obj_detect.eval()
obj_detect.cuda()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn'])
reid_network.load_state_dict(
torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
reid_network.cuda()
# motion network
motion_network = None
if tracktor['tracker']['motion_model_enabled'] and not tracktor['motion'][
'use_cva_model']:
motion_network = eval(
tracktor['motion']['model'])(**tracktor['motion']['model_args'])
motion_network.load_state_dict(
torch.load(tracktor['motion']['network_weights'])['model'])
motion_network.eval().cuda()
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(obj_detect, reid_network, tracktor['tracker'],
tracktor['oracle'])
else:
tracker = Tracker(obj_detect, reid_network, motion_network,
tracktor['tracker'], tracktor['motion'], 2)
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'])
for seq in dataset:
tracker.reset()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
start = time.time()
all_mm_times = []
all_warp_times = []
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(
seq) * tracktor['frame_split'][1]:
with torch.no_grad():
mm_time, warp_time = tracker.step(frame)
if mm_time is not None:
all_mm_times.append(mm_time)
if warp_time is not None:
all_warp_times.append(warp_time)
num_frames += 1
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
_log.info(
f"Average FPS for {seq}: {len(data_loader) / (time.time() - start) :.3f}"
)
_log.info(
f"Average MM time for {seq}: {float(np.array(all_mm_times).mean()) :.3f} s"
)
if all_warp_times:
_log.info(
f"Average warp time for {seq}: {float(np.array(all_warp_times).mean()) :.3f} s"
)
if tracktor['interpolate']:
results = interpolate(results)
if 'semi_online' in tracktor and tracktor['semi_online']:
for i, track in results.items():
for frame in sorted(track, reverse=True):
if track[frame][5] == 0:
break
del track[frame]
if tracktor['write_images']:
plot_sequence(results, seq,
osp.join(output_dir, tracktor['dataset'], str(seq)),
tracktor['tracker']['plot_mm'])
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.2f} s for {num_frames} frames ({num_frames / time_total:.2f} Hz)"
)
if mot_accums:
evaluate_mot_accums(mot_accums,
[str(s) for s in dataset if not s.no_gt],
generate_overall=True)
def main(tracktor, reid, _config, _log, _run):
target = Target()
targetpath = target.Folder()
targetname = target.TargetName()
vottpath = target.GetVottPath()
vottfile = target.GetVottContent()
dictid, timelist = target.GetTagTime(vottfile)
print(f"{len(timelist)} frames were tagged")
timedict = target.ExtractByTimeList(timelist)
bbdict = target.GetbbWithTime(vottfile)
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector.")
obj_detect = FRCNN_FPN(num_classes=2)
obj_detect.load_state_dict(
torch.load(_config['tracktor']['obj_detect_model'],
map_location=lambda storage, loc: storage))
obj_detect.eval()
obj_detect.cuda()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn'])
reid_network.load_state_dict(
torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
reid_network.cuda()
# tracktor
print("Tracktor初始化完成")
tracker = Tracker(obj_detect, reid_network, tracktor['tracker'])
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'])
for seq in dataset:
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
print(f"{seq}加載完成, tracking開始")
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(
seq) * tracktor['frame_split'][1]:
id = tracker.step(frame, bbdict[timedict["%06d" % num_frames]])
target.WriteID2asset(id, dictid[timedict["%06d" % num_frames]])
num_frames += 1
results = tracker.get_results()
ids = list(results.keys())
target.WriteID2vott(ids, vottfile=vottfile)
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
target.CleanImg()
if tracktor['interpolate']:
results = interpolate(results)
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if tracktor['write_images']:
plot_sequence(results, seq,
osp.join(output_dir, tracktor['dataset'], str(seq)))
if tracktor['write_videos']:
plot_sequence_video(
results, seq,
osp.join(output_dir, tracktor['dataset'], str(seq)))
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
if mot_accums:
evaluate_mot_accums(mot_accums,
[str(s) for s in dataset if not s.no_gt],
generate_overall=True)
def my_main(tracktor, siamese, _config):
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
print("[*] Building object detector")
if tracktor['network'].startswith('frcnn'):
# FRCNN
from tracktor.frcnn import FRCNN
from frcnn.model import config
if _config['frcnn']['cfg_file']:
config.cfg_from_file(_config['frcnn']['cfg_file'])
if _config['frcnn']['set_cfgs']:
config.cfg_from_list(_config['frcnn']['set_cfgs'])
obj_detect = FRCNN(num_layers=101)
obj_detect.create_architecture(2,
tag='default',
anchor_scales=config.cfg.ANCHOR_SCALES,
anchor_ratios=config.cfg.ANCHOR_RATIOS)
obj_detect.load_state_dict(torch.load(tracktor['obj_detect_weights']))
elif tracktor['network'].startswith('fpn'):
# FPN
from tracktor.fpn import FPN
from fpn.model.utils import config
config.cfg.TRAIN.USE_FLIPPED = False
config.cfg.CUDA = True
config.cfg.TRAIN.USE_FLIPPED = False
checkpoint = torch.load(tracktor['obj_detect_weights'])
if 'pooling_mode' in checkpoint.keys():
config.cfg.POOLING_MODE = checkpoint['pooling_mode']
set_cfgs = [
'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'
]
config.cfg_from_file(_config['tracktor']['obj_detect_config'])
config.cfg_from_list(set_cfgs)
obj_detect = FPN(('__background__', 'pedestrian'),
101,
pretrained=False)
obj_detect.create_architecture()
obj_detect.load_state_dict(checkpoint['model'])
else:
raise NotImplementedError(
f"Object detector type not known: {tracktor['network']}")
obj_detect.eval()
obj_detect.cuda()
print("[*] Beginning operation...")
layers = ['p2', 'p3', 'p4', 'p5']
f_hdf5 = h5py.File(
'/usr/stud/beckera/tracking_wo_bnw/data/motion/im_features.hdf5', 'w')
i_hdf5 = h5py.File(
'/usr/stud/beckera/tracking_wo_bnw/data/motion/images.hdf5', 'w')
for sequence in Datasets(tracktor['dataset']):
print("[*] Storing sequence: {}".format(sequence))
f_group = f_hdf5.create_group(sequence._seq_name)
i_group = i_hdf5.create_group(sequence._seq_name)
data_loader = DataLoader(sequence, batch_size=1, shuffle=False)
for i, frame in enumerate(data_loader):
if i == 0:
i_group.create_dataset('data',
shape=(len(data_loader),
*frame['data'][0].shape[1:]),
dtype='float16')
i_group.create_dataset('app_data',
shape=(len(data_loader),
*frame['app_data'][0].shape[1:]),
dtype='float16')
i_group.create_dataset('im_info',
shape=(len(data_loader), 3),
dtype='float16')
i_group['data'][i] = frame['data'][0].cpu().numpy()
i_group['app_data'][i] = frame['app_data'][0].cpu().numpy()
i_group['im_info'][i] = frame['im_info'].cpu().numpy()
image = Variable(frame['data'][0].permute(0, 3, 1, 2).cuda(),
volatile=True)
features = obj_detect.get_features(image)
for j, layer in enumerate(layers):
if i == 0:
f_group.create_dataset(layer,
shape=(len(data_loader),
*features[j].shape[1:]),
dtype='float16')
f_group[layer][i] = features[j].data.cpu().numpy().astype(
'float16')
f_hdf5.close()
i_hdf5.close()
def main(seed, module_name, name, db_train, db_val, solver_cfg, model_args,
dataset_kwargs, _run, _config, _log):
# set all seeds
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
sacred.commands.print_config(_run)
output_dir = osp.join(get_output_dir(module_name), name)
tb_dir = osp.join(get_tb_dir(module_name), name)
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(copy.deepcopy(_config), outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
_log.info("[*] Building CNN")
model = ReIDNetwork_resnet50(pretrained=True, **model_args)
model.train()
model.cuda()
#########################
# Initialize dataloader #
#########################
_log.info("[*] Initializing Datasets")
_log.info("[*] Train:")
dataset_kwargs = copy.deepcopy(dataset_kwargs)
dataset_kwargs['logger'] = _log.info
dataset_kwargs['mot_dir'] = db_train['mot_dir']
dataset_kwargs['transform'] = db_train['transform']
dataset_kwargs['random_triplets'] = db_train['random_triplets']
db_train = Datasets(db_train['split'], dataset_kwargs)
db_train = DataLoader(db_train, batch_size=1, shuffle=True)
if db_val is not None:
_log.info("[*] Val:")
dataset_kwargs['mot_dir'] = db_val['mot_dir']
dataset_kwargs['transform'] = db_val['transform']
dataset_kwargs['random_triplets'] = db_val['random_triplets']
db_val = Datasets(db_val['split'], dataset_kwargs)
db_val = DataLoader(db_val, batch_size=1, shuffle=False)
##################
# Begin training #
##################
_log.info("[*] Solving ...")
# build scheduling like in "In Defense of the Triplet Loss
# for Person Re-Identification" from Hermans et al.
def lr_scheduler(epoch):
if epoch < 1 / 2 * solver_cfg['num_epochs']:
return 1
return 0.001**(2 * epoch / solver_cfg['num_epochs'] - 1)
# return 0.1 ** (epoch // 30)
# return 0.9 ** epoch
solver = Solver(output_dir,
tb_dir,
lr_scheduler_lambda=lr_scheduler,
logger=_log.info,
optim=solver_cfg['optim'],
optim_args=solver_cfg['optim_args'])
solver.train(model, db_train, db_val, solver_cfg['num_epochs'],
solver_cfg['log_nth'])
def my_main(_config):
print(_config)
dataset = "mot_train_"
detections = "FRCNN"
##########################
# Initialize the modules #
##########################
print("[*] Beginning evaluation...")
module_dir = get_output_dir('MOT17')
results_dir = module_dir
module_dir = osp.join(module_dir, 'eval/video_fp')
#output_dir = osp.join(results_dir, 'plots')
#if not osp.exists(output_dir):
# os.makedirs(output_dir)
#sequences_raw = ["MOT17-13", "MOT17-11", "MOT17-10", "MOT17-09", "MOT17-05", "MOT17-04", "MOT17-02", ]
#sequences = ["{}-{}".format(s, detections) for s in sequences_raw]
#sequences = sequences[:1]
# tracker = ["FRCNN_Base", "HAM_SADF17", "MOTDT17", "EDMT17", "IOU17", "MHT_bLSTM", "FWT_17", "jCC", "MHT_DAM_17"]
# tracker = ["Baseline", "BnW", "FWT_17", "jCC", "MOTDT17", "MHT_DAM_17"]
tracker = ["Tracktor", "FWT", "jCC", "MOTDT17"]
#tracker = ["Baseline"]
for t in tracker:
print("[*] Evaluating {}".format(t))
if True:
#for db in Datasets(dataset):
################################
# Make videos for each tracker #
################################
db = Datasets(dataset)[2]
s = "{}-{}".format(db, detections)
gt_file = osp.join(cfg.DATA_DIR, "MOT17Labels", "train", s, "gt",
"gt.txt")
res_file = osp.join(results_dir, t, s + ".txt")
stDB = read_txt_to_struct(res_file)
gtDB = read_txt_to_struct(gt_file)
gtDB, distractor_ids = extract_valid_gt_data(gtDB)
_, M, gtDB, stDB = evaluate_new(stDB, gtDB, distractor_ids)
#gt_ids_res = np.unique(gtDB[:, 1])
#gtDB = read_txt_to_struct(gt_file)
# filter out so that confidence and id = 1
#gtDB = gtDB[gtDB[:,7] == 1]
#gtDB = gtDB[gtDB[:,6] == 1]
st_ids = np.unique(stDB[:, 1])
#gt_ids = np.unique(gtDB[:, 1])
gt_frames = np.unique(gtDB[:, 0])
f_gt = len(gt_frames)
#gt_inds = [{} for i in range(f_gt)]
st_inds = [{} for i in range(f_gt)]
# hash the indices to speed up indexing
#for i in range(gtDB.shape[0]):
# frame = np.where(gt_frames == gtDB[i, 0])[0][0]
#gid = np.where(gt_ids == gtDB[i, 1])[0][0]
# gt_id = int(gtDB[i,1])
# gt_inds[frame][gt_id] = i
gt_frames_list = list(gt_frames)
for i in range(stDB.shape[0]):
# sometimes detection missed in certain frames, thus should be assigned to groundtruth frame id for alignment
frame = gt_frames_list.index(stDB[i, 0])
sid = np.where(st_ids == stDB[i, 1])[0][0]
st_inds[frame][sid] = i
#stDB = read_txt_to_struct(res_file)
results = []
for frame in range(f_gt):
# get gt_ids in res
m = M[frame]
matched_sids = list(m.values())
#frame_sids = list(st_inds[frame].keys())
f = gt_frames_list[frame]
st_frame = stDB[stDB[:, 0] == f]
st_uniq_ids = np.unique(st_frame[:, 1])
for st_id in st_uniq_ids:
sid = -1
si = np.where(st_ids == st_id)[0]
if len(si) > 0:
sid = si[0]
if sid not in matched_sids:
res = np.zeros(6)
res[0] = frame + 1
st_track = st_frame[st_frame[:, 1] == st_id]
res[2:6] = st_track[0, 2:6]
results.append(res)
else:
matched_sids.remove(sid)
results = np.array(results)
print(results.shape[0])
output_dir = osp.join(module_dir, t, s)
if not osp.exists(output_dir):
os.makedirs(output_dir)
print("[*] Plotting whole sequence to {}".format(output_dir))
# infinte color loop
cyl = cy('ec', colors)
loop_cy_iter = cyl()
styles = defaultdict(lambda: next(loop_cy_iter))
for frame, v in enumerate(db, 1):
im_path = v['im_path']
im_name = osp.basename(im_path)
im_output = osp.join(output_dir, im_name)
im = cv2.imread(im_path)
im = im[:, :, (2, 1, 0)]
sizes = np.shape(im)
height = float(sizes[0])
width = float(sizes[1])
fig = plt.figure()
#fig.set_size_inches(w,h)
#fig.set_size_inches(width/height, 1, forward=False)
#fig.set_size_inches(width/100, height/100)
scale = width / 640
#fig.set_size_inches(640/100, height*scale/100)
fig.set_size_inches(width / 100, height / 100)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(im)
res_frame = results[results[:, 0] == frame]
for j in range(res_frame.shape[0]):
box = res_frame[j, 2:6]
gt_id = int(res_frame[j, 1])
ax.add_patch(
plt.Rectangle((box[0], box[1]),
box[2] - box[0],
box[3] - box[1],
fill=False,
linewidth=1.3 * scale,
color='blue'))
ax.annotate(t, (width - 250, height - 100),
color='white',
weight='bold',
fontsize=72,
ha='center',
va='center')
plt.axis('off')
plt.draw()
plt.savefig(im_output, dpi=100)
plt.close()
def main(dataset_names, prepr_w_tracktor, frcnn_prepr_params, tracktor_params,
frcnn_weights, _config, _log, _run):
sacred.commands.print_config(_run)
if prepr_w_tracktor:
prepr_params = tracktor_params
else:
prepr_params = frcnn_prepr_params
make_deterministic(prepr_params['seed'])
MOV_CAMERA_DICT = {**MOT15_MOV_CAMERA_DICT, **MOT17_MOV_CAMERA_DICT}
# object detection
_log.info("Initializing object detector.")
obj_detect = FRCNN_FPN(num_classes=2)
obj_detect.load_state_dict(
torch.load(osp.join(OUTPUT_PATH, frcnn_weights),
map_location=lambda storage, loc: storage))
obj_detect.eval()
obj_detect.cuda()
if prepr_w_tracktor:
preprocessor = Tracker(obj_detect, None, prepr_params['tracker'])
else:
preprocessor = FRCNNPreprocessor(obj_detect, prepr_params)
_log.info(
f"Starting preprocessing of datasets {dataset_names} with {'Tracktor' if prepr_w_tracktor else 'FRCNN'} \n"
)
for dataset_name in dataset_names:
dataset = Datasets(dataset_name)
_log.info(
f"Preprocessing {len(dataset)} sequences from dataset {dataset_name} \n"
)
time_total = 0
num_frames = 0
for seq in dataset:
preprocessor.reset()
start = time.time()
_log.info(f"Preprocessing : {seq}")
if prepr_w_tracktor:
preprocessor.do_align = tracktor_params['tracker'][
'do_align'] and (MOV_CAMERA_DICT[str(seq)])
data_loader = DataLoader(seq,
batch_size=1,
shuffle=False,
num_workers=8,
pin_memory=True)
for i, frame in enumerate(tqdm(data_loader)):
with torch.no_grad():
preprocessor.step(frame)
num_frames += 1
time_total += time.time() - start
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
output_file_path = osp.join(seq.seq_path, 'det',
prepr_params['det_file_name'])
if prepr_w_tracktor:
results = preprocessor.get_results()
seq.write_results(results, output_file_path)
else:
_log.info(f"Writing predictions in: {output_file_path}")
preprocessor.save_results(output_file_path)
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
def main(tracktor, reid, _config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
_log.info("Initializing object detector.")
# object detection
obj_detect = FRCNN_FPN(num_classes=2, correlation_head=CorrelationHead())
obj_detect_model = torch.load(_config['tracktor']['obj_detect_model'],
map_location=lambda storage, loc: storage)
correlation_weights = torch.load(
_config['tracktor']['correlation_weights'],
map_location=lambda storage, loc: storage)
for k in correlation_weights:
obj_detect_model.update(
{"correlation_head." + k: correlation_weights[k]})
obj_detect.load_state_dict(obj_detect_model)
obj_detect.eval()
obj_detect.cuda()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn'])
reid_network.load_state_dict(
torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
reid_network.cuda()
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(obj_detect, reid_network, tracktor['tracker'],
tracktor['oracle'])
else:
tracker = Tracker(obj_detect, reid_network, tracktor['tracker'])
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'])
for seq in dataset:
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(
seq) * tracktor['frame_split'][1]:
with torch.no_grad():
tracker.step(frame)
num_frames += 1
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.2f} s.")
if tracktor['interpolate']:
results = interpolate(results)
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if tracktor['write_images']:
plot_sequence(results, seq,
osp.join(output_dir, tracktor['dataset'], str(seq)))
score_killed_tracks = tracker.get_score_killed_tracks()
_log.info(f"Score Killed Tracks: ({len(score_killed_tracks)})")
for kill in score_killed_tracks:
_log.info(
f"Track [ {kill['id']:3d} ] killed in frame [ {kill['frame']:3d} ]"
)
nms_killed_tracks = tracker.get_nms_killed_tracks()
_log.info(f"NMS Killed Tracks ({len(nms_killed_tracks)}):")
for kill in nms_killed_tracks:
_log.info(
f"Track [ {kill['id']:3d} ] killed in frame [ {kill['frame']:3d} ]"
)
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.2f} s for {num_frames} frames ({num_frames / time_total:.2f} Hz)"
)
if mot_accums:
evaluate_mot_accums(mot_accums,
[str(s) for s in dataset if not s.no_gt],
generate_overall=True)
def main(tracktor, reid, _config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']),
tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector.")
obj_detect = FRCNN_FPN(num_classes=2)
obj_detect.load_state_dict(
torch.load(_config['tracktor']['obj_detect_model'],
map_location=lambda storage, loc: storage))
obj_detect.eval()
obj_detect.cuda()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn'])
reid_network.load_state_dict(
torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
reid_network.cuda()
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(obj_detect, reid_network, tracktor['tracker'],
tracktor['oracle'])
else:
tracker = Tracker(obj_detect, reid_network, tracktor['tracker'])
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'])
for seq in dataset:
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(
seq) * tracktor['frame_split'][1]:
tracker.step(frame)
num_frames += 1
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
if tracktor['interpolate']:
results = interpolate(results)
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if tracktor['write_images']:
plot_sequence(results, seq,
osp.join(output_dir, tracktor['dataset'], str(seq)))
img_array = []
dir = osp.join(output_dir, tracktor['dataset'], str(seq), "*.jpg")
files = glob.glob(dir)
sorted_files = natsorted(files)
for filename in sorted_files:
img = cv2.imread(filename)
height, width, layers = img.shape
size = (width, height)
img_array.append(img)
out = cv2.VideoWriter(
osp.join(output_dir, tracktor['dataset'],
str(seq), "result_video.avi"),
cv2.VideoWriter_fourcc(*'DIVX'), 10, size)
for i in range(len(img_array)):
out.write(img_array[i])
out.release()
_log.info(
f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
if mot_accums:
evaluate_mot_accums(mot_accums,
[str(s) for s in dataset if not s.no_gt],
generate_overall=True)
from PIL import Image
from tracktor.config import get_output_dir
from tracktor.datasets.factory import Datasets
dataset = "mot_train_"
detections = "FRCNN"
module_dir = get_output_dir('MOT17')
results_dir = module_dir
module_dir = osp.join(module_dir, 'eval/video_fp')
tracker = ["Tracktor", "FWT", "jCC", "MOTDT17"]
for db in Datasets(dataset):
seq_path = osp.join(module_dir, f"{tracker[0]}/{db}-{detections}")
if not osp.exists(seq_path):
continue
for frame, v in enumerate(db, 1):
file_name = osp.basename(v['im_path'])
output_dir = osp.join(module_dir, 'combined', f"{db}-{detections}")
if not osp.exists(output_dir):
os.makedirs(output_dir)
im_output = osp.join(output_dir, file_name)
tracker_frames = []
for t in tracker:
im_path = osp.join(module_dir,
f"{t}/{db}-{detections}/{file_name}")
tracker_frames.append(Image.open(im_path))
def my_main(_config):
print(_config)
dataset = "mot_train_"
detections = "FRCNN"
##########################
# Initialize the modules #
##########################
print("[*] Beginning evaluation...")
module_dir = get_output_dir('MOT17')
results_dir = module_dir
module_dir = osp.join(module_dir, 'eval/video_red_green')
#output_dir = osp.join(results_dir, 'plots')
#if not osp.exists(output_dir):
# os.makedirs(output_dir)
#sequences_raw = ["MOT17-13", "MOT17-11", "MOT17-10", "MOT17-09", "MOT17-05", "MOT17-04", "MOT17-02", ]
#sequences = ["{}-{}".format(s, detections) for s in sequences_raw]
#sequences = sequences[:1]
# tracker = ["FRCNN_Base", "HAM_SADF17", "MOTDT17", "EDMT17", "IOU17", "MHT_bLSTM", "FWT_17", "jCC", "MHT_DAM_17"]
# tracker = ["Baseline", "BnW", "FWT_17", "jCC", "MOTDT17", "MHT_DAM_17"]
tracker = ["FWT", "jCC", "MOTDT17"]#, "Tracktor++"]
baseline = "Tracktor"
for t in tracker:
print("[*] Evaluating {}".format(t))
for db in Datasets(dataset):
################################
# Make videos for each tracker #
################################
s = "{}-{}".format(db, detections)
gt_file = osp.join(cfg.DATA_DIR, "MOT17Labels", "train", s, "gt", "gt.txt")
res_file = osp.join(results_dir, t, s+".txt")
base_file = osp.join(results_dir, baseline, s+".txt")
stDB = read_txt_to_struct(res_file)
gtDB = read_txt_to_struct(gt_file)
gtDB, distractor_ids = extract_valid_gt_data(gtDB)
_, M_res, gtDB, stDB = evaluate_new(stDB, gtDB, distractor_ids)
gt_ids_res = np.unique(gtDB[:, 1])
bsDB = read_txt_to_struct(base_file)
gtDB = read_txt_to_struct(gt_file)
gtDB, distractor_ids = extract_valid_gt_data(gtDB)
_, M_bs, gtDB, stDB = evaluate_new(bsDB, gtDB, distractor_ids)
gt_ids_base = np.unique(gtDB[:, 1])
gtDB = read_txt_to_struct(gt_file)
# filter out so that confidence and id = 1
gtDB = gtDB[gtDB[:,7] == 1]
gtDB = gtDB[gtDB[:,6] == 1]
#st_ids = np.unique(stDB[:, 1])
#gt_ids = np.unique(gtDB[:, 1])
gt_frames = np.unique(gtDB[:, 0])
f_gt = len(gt_frames)
gt_inds = [{} for i in range(f_gt)]
#st_inds = [{} for i in range(f_gt)]
# hash the indices to speed up indexing
for i in range(gtDB.shape[0]):
frame = np.where(gt_frames == gtDB[i, 0])[0][0]
#gid = np.where(gt_ids == gtDB[i, 1])[0][0]
gt_id = int(gtDB[i,1])
gt_inds[frame][gt_id] = i
#gt_frames_list = list(gt_frames)
#for i in range(stDB.shape[0]):
# sometimes detection missed in certain frames, thus should be assigned to groundtruth frame id for alignment
# frame = gt_frames_list.index(stDB[i, 0])
# sid = np.where(st_ids == stDB[i, 1])[0][0]
# st_inds[frame][sid] = i
results = []
for frame in range(f_gt):
# get gt_ids in res
m_res = M_res[frame]
gids = list(m_res.keys())
res_gt = []
for gid in gids:
res_gt.append(gt_ids_res[gid])
# get gt_ids in base
m_bs = M_bs[frame]
gids = list(m_bs.keys())
base_gt = []
for gid in gids:
base_gt.append(gt_ids_base[gid])
# get unique gt ids
unique_gt = np.unique(res_gt + base_gt)
#print("res gt: {}".format(res_gt))
#print("base gt: {}".format(base_gt))
for gt in unique_gt:
gt = int(gt)
#print(gt)
res = np.zeros(6)
res[0] = frame+1
res[2:6] = gtDB[gt_inds[frame][gt], 2:6]
if gt in res_gt and gt in base_gt:
res[1] = 1
elif gt in base_gt:
res[1] = 2
elif gt in res_gt:
res[1] = 3
results.append(res)
results = np.array(results)
output_dir = osp.join(module_dir, t, s)
if not osp.exists(output_dir):
os.makedirs(output_dir)
print("[*] Plotting whole sequence to {}".format(output_dir))
# infinte color loop
cyl = cy('ec', colors)
loop_cy_iter = cyl()
styles = defaultdict(lambda : next(loop_cy_iter))
for frame,v in enumerate(db,1):
im_path = v['im_path']
im_name = osp.basename(im_path)
im_output = osp.join(output_dir, im_name)
im = cv2.imread(im_path)
im = im[:, :, (2, 1, 0)]
sizes = np.shape(im)
height = float(sizes[0])
width = float(sizes[1])
fig = plt.figure()
#fig.set_size_inches(w,h)
#fig.set_size_inches(width/height, 1, forward=False)
#fig.set_size_inches(width/100, height/100)
scale = width/640
#fig.set_size_inches(640/100, height*scale/100)
fig.set_size_inches(width/100, height/100)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(im)
res_frame = results[results[:,0]==frame]
for j in range(res_frame.shape[0]):
box = res_frame[j,2:6]
gt_id = int(res_frame[j,1])
ax.add_patch(
plt.Rectangle((box[0], box[1]),
box[2] - box[0],
box[3] - box[1], fill=False,
linewidth=1.3*scale, color=colors[gt_id])
#**styles[gt_id])
)
plt.axis('off')
#plt.tight_layout()
plt.draw()
plt.savefig(im_output, dpi=100)
plt.close()
def main(tracktor, reid, _config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']), tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector.")
obj_detect = FRCNN_FPN(num_classes=2)
obj_detect.load_state_dict(torch.load(_config['tracktor']['obj_detect_model'],
map_location=lambda storage, loc: storage))
obj_detect.eval()
obj_detect.cuda()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn'])
reid_network.load_state_dict(torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
reid_network.cuda()
# neural motion model
vis_model = VisSimpleReID()
motion_model = MotionModelV3(vis_model)
motion_model.load_state_dict(torch.load('output/motion/finetune_motion_model_v3.pth'))
motion_model.eval()
motion_model.cuda()
save_vis_results = False
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(obj_detect, reid_network, tracktor['tracker'], tracktor['oracle'])
else:
# tracker = Tracker(obj_detect, reid_network, tracktor['tracker'])
tracker = TrackerNeuralMM(obj_detect, reid_network, motion_model, tracktor['tracker'], save_vis_results=save_vis_results, vis_model=None)
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'], {'use_val_split':True})
for seq in dataset:
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(seq) * tracktor['frame_split'][1]:
with torch.no_grad():
tracker.step(frame)
num_frames += 1
results = tracker.get_results()
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
if tracktor['interpolate']:
results = interpolate(results)
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
if save_vis_results:
vis_results = tracker.get_vis_results()
seq.write_vis_results(vis_results, output_dir)
if tracktor['write_images']:
plot_sequence(results, seq, osp.join(output_dir, tracktor['dataset'], str(seq)))
_log.info(f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
if mot_accums:
evaluate_mot_accums(mot_accums, [str(s) for s in dataset if not s.no_gt], generate_overall=True)
def main(tracktor, reid, _config, _log, _run):
sacred.commands.print_config(_run)
# set all seeds
torch.manual_seed(tracktor['seed'])
torch.cuda.manual_seed(tracktor['seed'])
np.random.seed(tracktor['seed'])
torch.backends.cudnn.deterministic = True
output_dir = osp.join(get_output_dir(tracktor['module_name']), tracktor['name'])
sacred_config = osp.join(output_dir, 'sacred_config.yaml')
if not osp.exists(output_dir):
os.makedirs(output_dir)
with open(sacred_config, 'w') as outfile:
yaml.dump(_config, outfile, default_flow_style=False)
##########################
# Initialize the modules #
##########################
# object detection
_log.info("Initializing object detector.")
use_masks = _config['tracktor']['tracker']['use_masks']
mask_model = Mask_RCNN(num_classes=2)
fast_model = FRCNN_FPN(num_classes=2)
fast_model.load_state_dict(torch.load(_config['tracktor']['fast_rcnn_model'],
map_location=lambda storage, loc: storage))
if(use_masks):
mask_model.load_state_dict(torch.load(_config['tracktor']['mask_rcnn_model'],
map_location=lambda storage, loc: storage)['model_state_dict'])
mask_model.eval()
mask_model.cuda()
fast_model.eval()
fast_model.cuda()
# reid
reid_network = resnet50(pretrained=False, **reid['cnn'])
reid_network.load_state_dict(torch.load(tracktor['reid_weights'],
map_location=lambda storage, loc: storage))
reid_network.eval()
reid_network.cuda()
# tracktor
if 'oracle' in tracktor:
tracker = OracleTracker(fast_model, reid_network, tracktor['tracker'], tracktor['oracle'])
else:
tracker = Tracker(fast_model, reid_network, tracktor['tracker'], mask_model)
time_total = 0
num_frames = 0
mot_accums = []
dataset = Datasets(tracktor['dataset'])
for seq in dataset:
num_frames = 0
tracker.reset()
start = time.time()
_log.info(f"Tracking: {seq}")
data_loader = DataLoader(seq, batch_size=1, shuffle=False)
if tracktor['write_images'] and use_masks:
print("[*] Plotting image to {}".format(osp.join(output_dir, tracktor['dataset'])))
for i, frame in enumerate(tqdm(data_loader)):
if len(seq) * tracktor['frame_split'][0] <= i <= len(seq) * tracktor['frame_split'][1]:
tracker.step(frame)
if tracktor['write_images'] and use_masks:
result = tracker.get_results()
masks = tracker.get_masks()
plot_sequence(result, masks, seq, num_frames, osp.join(output_dir, tracktor['dataset'], str(seq)), plot_masks = True)
num_frames += 1
results = tracker.get_results()
import matplotlib.pyplot as plt
time_total += time.time() - start
_log.info(f"Tracks found: {len(results)}")
_log.info(f"Runtime for {seq}: {time.time() - start :.1f} s.")
if tracktor['interpolate']:
results = interpolate(results)
if seq.no_gt:
_log.info(f"No GT data for evaluation available.")
else:
mot_accums.append(get_mot_accum(results, seq))
_log.info(f"Writing predictions to: {output_dir}")
seq.write_results(results, output_dir)
_log.info(f"Tracking runtime for all sequences (without evaluation or image writing): "
f"{time_total:.1f} s ({num_frames / time_total:.1f} Hz)")
if mot_accums:
evaluate_mot_accums(mot_accums, [str(s) for s in dataset if not s.no_gt], generate_overall=True)