def __init__(self, res_path, info):
net = net_1024.net_1024()
net_path = "SaveModel/net_1024_beta2.pth"
print("-------> loading net_1024")
self.net = LoadModel(net, net_path)
self.sequence = []
print("-------> initializing MOT17-{}-{} ...".format(
info[0], info[1]))
self.sequence.append(VideoData(info, res_path))
print("-------> initialize MOT17-{}-{} done".format(
info[0], info[1]))
self.vis_save_path = "test/visualize"
def __init__(self, res_path, info):
net = net_1024.net_1024()
# net_path = "SaveModel/net_1024_beta2.pth"
# net_path = "/hdd/yongxinw/MOT17/experiments/debug11/net_1024.pth"
# net_path = "/hdd/yongxinw/MOT17/experiments/train_mot15/net_1024.pth"
net_path = "/hdd/yongxinw/MOT15/new_experiments/train_mot15_train/checkpoints/net_39500.pth"
print("-------> loading net_1024")
print("-----------------> resuming from {}".format(net_path))
self.net = LoadModel(net, net_path)
self.sequence = []
# # MOT17
print("-------> initializing MOT17-{}-{} ...".format(
info[0], info[1]))
self.sequence.append(VideoData(info, res_path))
print("-------> initialize MOT17-{}-{} done".format(
info[0], info[1]))
def val(parser, generator, log, log_path):
print("validation \n")
model = net_1024.net_1024()
# "----------------- pretrained model loading -----------------"
# print("loading pretrained model")
# checkpoint = torch.load("/home/lallazhao/MOT/result/Oct-25-at-02-17-net_1024/net_1024_88.4.pth")
checkpoint = torch.load(
"/hdd/yongxinw/Det/experiments/train_mot15_w_detect_3anchors/net_1024.pth"
)
model.load_state_dict(checkpoint["state_dict"])
# "------------------------------------------------------------"
image_dir = osp.join(log_path, "images")
os.makedirs(image_dir, exist_ok=True)
model = model.cuda()
model.eval()
for it in range(1):
frame = 6
cur_crop, pre_crop, cur_motion, pre_motion, gt_matrix, pos_mask, neg_mask, anchor_class, offsets, curr_image, \
curr_data, prev_image, prev_data, anchors = generator(frame=frame)
with torch.no_grad():
s0, s1, s2, s3, adj1, adj, box_pred, cls_pred = model(
pre_crop, cur_crop, pre_motion, cur_motion)
# predicted matching score
adj_sig = F.sigmoid(adj)
if parser.use_gt_match:
adj_sig = torch.from_numpy(gt_matrix).cuda()
# use top k adj scores for match
scores, match_idx = torch.topk(adj_sig.t(), 1, dim=1)
# print(scores)
# print(match_idx)
# mask the indices that are below the threshold
match_idx[scores < parser.threshold] = -1
# x_inds = torch.arange(match_idx.shape[0]).view(-1, 1).repeat(1, match_idx.shape[1]).view(-1)
prev_boxes = prev_data[:, 2:6]
gt_ids = prev_data[:, 1]
max_color = 10
colors = random_colors(max_color, bright=True)
# Visualize gt boxes
curr_image_copy = prev_image.copy()
for i, gt_box in enumerate(prev_boxes):
id = gt_ids[i]
color_tmp = tuple(
[int(tmp * 255) for tmp in colors[int(id % max_color)]])
curr_image_copy = visualize_boxes(curr_image_copy, [gt_box],
width=5,
outline=color_tmp)
curr_image_copy.save(
osp.join(image_dir, "prev_{:03d}.jpg".format(frame + 1)))
# Visualize anchor matching
# curr_image_copy = curr_image.copy()
# for j, anchor_box in enumerate(anchors):
# matches = match_idx[j]
# for k in range(len(matches)):
# if matches[k] != -1:
# match_gt_id = gt_ids[matches[k]]
# width = 3
# outline = tuple([int(tmp * 255) for tmp in colors[int(match_gt_id % max_color)]])
# else:
# width = 1
# outline = "white"
#
# curr_image_copy = visualize_boxes(curr_image_copy, [anchor_box], width=width, outline=outline)
# curr_image_copy.save(osp.join(image_dir, "curr_match_{:03d}.jpg".format(frame)))
# Visualize anchor detection+classification
print(cls_pred)
print(anchor_class)
print(pos_mask)
# Visualize detections
curr_boxes = curr_data[:, 2:6]
curr_image_copy = curr_image.copy()
colors = random_colors(max_color, bright=False)
# Draw negative anchors
for j, anchor_box in enumerate(anchors):
# predicted class
cls_j = np.argmax(cls_pred.detach().cpu().numpy()[j])
# if we are in debug mode and want to use some gt information, specify in config
if parser.use_gt_anchor_class:
cls_j = anchor_class[j]
if cls_j == 0:
curr_image_copy = visualize_boxes(curr_image_copy,
[anchor_box],
width=1,
outline='white')
# Draw positive anchors
for j, anchor_box in enumerate(anchors):
# predicted class
cls_j = np.argmax(cls_pred.detach().cpu().numpy()[j])
# predicted offset
offset_j = box_pred.detach().cpu().numpy()[j]
# if we are in debug mode and want to use some gt information, specify in config
if parser.use_gt_anchor_class:
cls_j = anchor_class[j]
if parser.use_gt_offsets:
offset_j = offsets[j]
if cls_j == 1:
match = match_idx[j]
match_gt_id = gt_ids[match]
outline = tuple([
int(tmp * 255)
for tmp in colors[int(match_gt_id % max_color)]
])
if parser.show_aligned_anchors:
gw, gh = np.exp(offset_j[2:]) * anchor_box[2:]
gleft, gtop = offset_j[:2] * anchor_box[2:] + anchor_box[:2]
anchor_box_aligned = [gleft, gtop, gw, gh]
curr_image_copy = visualize_boxes(curr_image_copy,
[anchor_box_aligned],
width=3,
outline=outline)
else:
curr_image_copy = visualize_boxes(curr_image_copy,
[anchor_box],
width=3,
outline=outline)
# visualize the GT
for i, gt_box in enumerate(curr_boxes):
id = gt_ids[i]
color_tmp = tuple(
[int(tmp * 255) for tmp in colors[int(id % max_color)]])
curr_image_copy = visualize_boxes(curr_image_copy, [gt_box],
width=5,
outline=color_tmp)
curr_image_copy.save(
osp.join(image_dir, "curr_det_{:03d}.jpg".format(frame + 1)))
def train(parser, generator, log, log_path):
# print("training net_1024\n")
# model = net_1024.net_1024()
print("training final\n")
model = net_1024.net_1024()
# "----------------- pretrained model loading -----------------"
# print("loading pretrained model")
# checkpoint = torch.load("/home/lallazhao/MOT/result/Oct-25-at-02-17-net_1024/net_1024_88.4.pth")
# checkpoint = torch.load("/hdd/yongxinw/MOT17/experiments/debug1/net_1024.pth")
# model.load_state_dict(checkpoint["state_dict"])
# "------------------------------------------------------------"
model = model.cuda()
net_param_dict = model.parameters()
weight = torch.Tensor([10])
criterion_BCE = torch.nn.BCEWithLogitsLoss(pos_weight=weight).cuda()
criterion_CE = torch.nn.CrossEntropyLoss().cuda()
criterion_MSE = torch.nn.MSELoss().cuda()
criterion_SMOOTHL1 = torch.nn.SmoothL1Loss().cuda()
if parser.optimizer == "SGD":
optimizer = torch.optim.SGD(net_param_dict,
lr=parser.learning_rate,
momentum=parser.momentum,
weight_decay=parser.decay,
nesterov=True)
elif parser.optimizer == "Adam":
optimizer = torch.optim.Adam(net_param_dict,
lr=parser.learning_rate,
weight_decay=parser.decay)
elif parser.optimizer == "RMSprop":
optimizer = torch.optim.RMSprop(net_param_dict,
lr=parser.learning_rate,
weight_decay=parser.decay,
momentum=parser.momentum)
else:
raise NotImplementedError
# Main Training and Evaluation Loop
start_time, epoch_time = time.time(), AverageMeter()
Batch_time = AverageMeter()
Loss = AverageMeter()
CLoss = AverageMeter()
RLoss = AverageMeter()
Acc = AverageMeter()
Acc_pos = AverageMeter()
# Initialize visual validation
val_parser, val_generator, val_log_path = init_visual_validation()
for epoch in range(parser.start_epoch, parser.epochs):
all_lrs = adjust_learning_rate(optimizer, epoch, parser.gammas,
parser.schedule)
need_hour, need_mins, need_secs = convert_secs2time(
epoch_time.avg * (parser.epochs - epoch))
# ----------------------------------- train for one epoch -----------------------------------
batch_time, loss, classification_loss, regression_loss, acc, acc_pos = \
train_net_1024(model, generator, optimizer, criterion_BCE, criterion_CE, criterion_MSE, criterion_SMOOTHL1)
Batch_time.update(batch_time)
Loss.update(loss.item())
CLoss.update(classification_loss.item())
RLoss.update(regression_loss.item())
Acc.update(acc)
Acc_pos.update(acc_pos)
if epoch % parser.print_freq == 0 or epoch == parser.epochs - 1:
print_log(
'Epoch: [{:03d}/{:03d}]\t'
'Time {batch_time.val:5.2f} ({batch_time.avg:5.2f})\t'
'Match Loss {loss.val:6.3f} ({loss.avg:6.3f})\t'
'Cls Loss {closs.val:6.3f} ({closs.avg:6.3f})\t'
'Reg Loss {rloss.val:6.3f} ({rloss.avg:6.3f})\t'
"Acc {acc.val:6.3f} ({acc.avg:6.3f})\t"
"Acc_pos {acc_pos.val:6.3f} ({acc_pos.avg:6.3f})\t".format(
epoch,
parser.epochs,
batch_time=Batch_time,
loss=Loss,
closs=CLoss,
rloss=RLoss,
acc=Acc,
acc_pos=Acc_pos), log)
visual_log(model, epoch, val_parser, val_generator, val_log_path)
Batch_time.reset()
Loss.reset()
CLoss.reset()
RLoss.reset()
if (epoch in parser.schedule):
print_log(
"------------------- adjust learning rate -------------------",
log)
# -------------------------------------------------------------------------------------------
# measure elapsed time
epoch_time.update(time.time() - start_time)
start_time = time.time()
if epoch % 100 == 0:
save_file_path = osp.join(log_path, "net_1024.pth")
states = {
"state_dict": model.state_dict(),
}
torch.save(states, save_file_path)