def main():
args.means = (104, 117, 123) # only support voc now
exp_name = '{}-SSD-{}-{}-bs-{}-{}-lr-{:05d}'.format(
args.net_type, args.dataset, args.input_type, args.batch_size,
args.cfg['base'], int(args.lr * 100000))
args.save_root += args.dataset + '/'
args.data_root += args.dataset + '/'
args.listid = '01' ## would be usefull in JHMDB-21
print('Exp name', exp_name, args.listid)
#
for iteration in [
int(itr) for itr in args.eval_iter.split(',') if len(itr) > 0
]:
log_file = open(
args.save_root + 'cache/' + exp_name +
"/testing-{:d}-{:0.2f}.log".format(iteration, args.iou_thresh),
"w", 1)
log_file.write(exp_name + '\n')
trained_model_path = args.save_root + 'cache/' + exp_name + '/ssd300_ucf24_' + repr(
iteration) + '.pth'
log_file.write(trained_model_path + '\n')
num_classes = len(CLASSES) + 1 #7 +1 background
if args.cfg['base'] == 'fpn':
net = FPNSSD512(num_classes, args.cfg)
else:
if args.cfg['min_dim'][0] == 512:
net = SSD512(num_classes, args.cfg)
else:
net = build_vgg_ssd(num_classes, args.cfg)
net.load_state_dict(torch.load(trained_model_path))
net.eval()
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
print('Finished loading model %d !' % iteration)
# Load dataset
if args.dataset == 'ucf24':
dataset = OmniUCF24(args.data_root,
'test',
BaseTransform(300, args.means),
AnnotationTransform(),
input_type=args.input_type,
outshape=args.outshape,
full_test=True)
else:
dataset = OmniJHMDB(args.data_root,
'test',
BaseTransform(300, None),
AnnotationTransform(),
outshape=args.outshape)
# evaluation
torch.cuda.synchronize()
tt0 = time.perf_counter()
log_file.write('Testing net \n')
test_net(net, args.save_root, exp_name, args.input_type, dataset,
iteration, num_classes, log_file)
log_file.close()
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
evaluate_detections(all_boxes, output_dir, dataset)
def evaluate_detections(box_list, output_dir, dataset):
write_voc_results_file(box_list, dataset)
do_python_eval(output_dir)
if __name__ == '__main__':
# load net
num_classes = len(labelmap) + 1 # +1 for background
net = build_ssd('test', 300, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# load data
dataset = VOCDetection(args.voc_root, [('2007', set_type)],
BaseTransform(300, dataset_mean),
VOCAnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder, net, args.cuda, dataset,
BaseTransform(net.size, dataset_mean), args.top_k, 300,
thresh=args.confidence_threshold)
head = k[:7]
if head == 'module.':
name = k[7:] # remove `module.`
else:
name = k
new_state_dict[name] = v
net.load_state_dict(new_state_dict)
net.eval()
print('Finished loading model!')
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
else:
net = net.cpu()
detector = Detect(num_classes, 0, cfg)
transform = BaseTransform(img_dim, rgb_means, (2, 0, 1))
cap = cv2.VideoCapture('11.mp4')
#cap1 = cv2.VideoCapture('rtsp://*****:*****@101.205.119.109:554/Streaming/Channels/301')
ret, image = cap.read()
x = transform(image).unsqueeze(0)
x = x.cuda()
model_trt = torch2trt(net, [x])
object_detector = ObjectDetector(model_trt, detector, transform)
img_list = os.listdir(args.img_dir)
frame_no = 0
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
output = cv2.VideoWriter("demo1.avi", fourcc, 20, (1280, 720))
while True:
start = time.time()
frame_no += 1
#print(frame_no)
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
# with open(det_file, 'rb') as f:
# all_boxes = pickle.load(f)
# print('LOADED')
dataset.evaluate_detections(all_boxes, save_folder)
if __name__ == '__main__':
# load net
num_classes = len(labelmap) + 1 # +1 for background
net = build_ssd('test', cfg, args.use_pred_module) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
print(net)
# load data
dataset = COCODetection(args.dataset_root,
image_set='minival2014',
transform=BaseTransform(cfg['min_dim'], MEANS),
target_transform=COCOAnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder, net, args.cuda, dataset,
BaseTransform(net.size, MEANS), args.top_k, 512,
thresh=args.confidence_threshold)
def main():
global args
args = arg_parse()
cfg_from_file(args.cfg_file)
save_folder = args.save_folder
batch_size = cfg.TRAIN.BATCH_SIZE
bgr_means = cfg.TRAIN.BGR_MEAN
p = 0.6
gamma = cfg.SOLVER.GAMMA
momentum = cfg.SOLVER.MOMENTUM
weight_decay = cfg.SOLVER.WEIGHT_DECAY
size = cfg.MODEL.SIZE
thresh = cfg.TEST.CONFIDENCE_THRESH
if cfg.DATASETS.DATA_TYPE == 'VOC':
trainvalDataset = VOCDetection
top_k = 200
else:
trainvalDataset = COCODetection
top_k = 300
dataset_name = cfg.DATASETS.DATA_TYPE
dataroot = cfg.DATASETS.DATAROOT
trainSet = cfg.DATASETS.TRAIN_TYPE
valSet = cfg.DATASETS.VAL_TYPE
num_classes = cfg.MODEL.NUM_CLASSES
start_epoch = args.resume_epoch
epoch_step = cfg.SOLVER.EPOCH_STEPS
end_epoch = cfg.SOLVER.END_EPOCH
if not os.path.exists(save_folder):
os.mkdir(save_folder)
torch.set_default_tensor_type('torch.cuda.FloatTensor')
net = SSD(cfg)
print(net)
if cfg.MODEL.SIZE == '300':
size_cfg = cfg.SMALL
else:
size_cfg = cfg.BIG
optimizer = optim.SGD(net.parameters(),
lr=cfg.SOLVER.BASE_LR,
momentum=momentum,
weight_decay=weight_decay)
net.apply(weights_init)
mydic = net.state_dict()
if args.resume_net != None:
checkpoint = torch.load(args.resume_net)
state_dict = checkpoint['model']
from collections import OrderedDict
new_state_dict = OrderedDict()
state_dict = {k: v for k, v in state_dict.items() if k in mydic}
for k, v in state_dict.items():
head = k[:7]
if head == 'module.':
name = k[7:] # remove `module.`
else:
name = k
new_state_dict[name] = v
mydic.update(new_state_dict)
# net.load_state_dict(new_state_dict)
net.load_state_dict(mydic)
optimizer.load_state_dict(checkpoint['optimizer'])
print('Loading resume network...')
if args.ngpu > 1:
net = torch.nn.DataParallel(net)
net.cuda()
cudnn.benchmark = True
criterion = list()
if cfg.MODEL.REFINE:
detector = Detect(cfg)
arm_criterion = RefineMultiBoxLoss(cfg, 2)
odm_criterion = RefineMultiBoxLoss(cfg, cfg.MODEL.NUM_CLASSES)
criterion.append(arm_criterion)
criterion.append(odm_criterion)
else:
detector = Detect(cfg)
ssd_criterion = MultiBoxLoss(cfg)
criterion.append(ssd_criterion)
TrainTransform = preproc(size_cfg.IMG_WH, bgr_means, p)
ValTransform = BaseTransform(size_cfg.IMG_WH, bgr_means, (2, 0, 1))
val_dataset = trainvalDataset(dataroot, valSet, ValTransform, dataset_name)
val_loader = data.DataLoader(val_dataset,
batch_size,
shuffle=False,
num_workers=args.num_workers,
collate_fn=detection_collate)
for epoch in range(start_epoch + 1, end_epoch + 1):
train_dataset = trainvalDataset(dataroot, trainSet, TrainTransform,
dataset_name)
epoch_size = len(train_dataset)
train_loader = data.DataLoader(train_dataset,
batch_size,
shuffle=True,
num_workers=args.num_workers,
collate_fn=detection_collate)
train(train_loader, net, criterion, optimizer, epoch, epoch_step,
gamma, end_epoch, cfg)
if (epoch % 30 == 0) or (epoch % 10 == 0 and epoch >= 400):
time.sleep(10)
save_checkpoint(net, epoch, size, optimizer)
if (epoch >= 200 and epoch % 50 == 0):
eval_net(val_dataset,
val_loader,
net,
detector,
cfg,
ValTransform,
top_k,
thresh=thresh,
batch_size=batch_size)
time.sleep(10)
save_checkpoint(net, end_epoch, size, optimizer)
def main():
global my_dict, keys, k_len, arr, xxx, args, log_file, best_prec1
relative_path = '/data4/lilin/my_code'
parser = argparse.ArgumentParser(description='Single Shot MultiBox Detector Training')
parser.add_argument('--version', default='v2', help='conv11_2(v2) or pool6(v1) as last layer')
parser.add_argument('--basenet', default='vgg16_reducedfc.pth', help='pretrained base model')
parser.add_argument('--dataset', default='ucf24', help='pretrained base model')
parser.add_argument('--ssd_dim', default=300, type=int, help='Input Size for SSD') # only support 300 now
parser.add_argument('--modality', default='rgb', type=str,
help='INput tyep default rgb options are [rgb,brox,fastOF]')
parser.add_argument('--jaccard_threshold', default=0.5, type=float, help='Min Jaccard index for matching')
parser.add_argument('--batch_size', default=32, type=int, help='Batch size for training')
parser.add_argument('--num_workers', default=0, type=int, help='Number of workers used in dataloading')
parser.add_argument('--max_iter', default=120000, type=int, help='Number of training iterations')
parser.add_argument('--man_seed', default=123, type=int, help='manualseed for reproduction')
parser.add_argument('--cuda', default=True, type=str2bool, help='Use cuda to train model')
parser.add_argument('--ngpu', default=1, type=str2bool, help='Use cuda to train model')
parser.add_argument('--base_lr', default=0.0005, type=float, help='initial learning rate')
parser.add_argument('--lr', default=0.0005, type=float, help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, help='momentum')
parser.add_argument('--weight_decay', default=5e-4, type=float, help='Weight decay for SGD')
parser.add_argument('--gamma', default=0.2, type=float, help='Gamma update for SGD')
parser.add_argument('--log_iters', default=True, type=bool, help='Print the loss at each iteration')
parser.add_argument('--visdom', default=False, type=str2bool, help='Use visdom to for loss visualization')
parser.add_argument('--data_root', default= relative_path + '/realtime/', help='Location of VOC root directory')
parser.add_argument('--save_root', default= relative_path + '/realtime/saveucf24/',
help='Location to save checkpoint models')
parser.add_argument('--iou_thresh', default=0.5, type=float, help='Evaluation threshold')
parser.add_argument('--conf_thresh', default=0.01, type=float, help='Confidence threshold for evaluation')
parser.add_argument('--nms_thresh', default=0.45, type=float, help='NMS threshold')
parser.add_argument('--topk', default=50, type=int, help='topk for evaluation')
parser.add_argument('--clip_gradient', default=40, type=float, help='gradients clip')
parser.add_argument('--resume', default=None,type=str, help='Resume from checkpoint')
parser.add_argument('--start_epoch', default=0, type=int, help='start epoch')
parser.add_argument('--epochs', default=35, type=int, metavar='N',
help='number of total epochs to run')
parser.add_argument('--eval_freq', default=2, type=int, metavar='N', help='evaluation frequency (default: 5)')
parser.add_argument('--snapshot_pref', type=str, default="ucf101_vgg16_ssd300_end2end")
parser.add_argument('--lr_milestones', default=[-2, -5], type=float, help='initial learning rate')
parser.add_argument('--arch', type=str, default="VGG16")
parser.add_argument('--Finetune_SSD', default=False, type=str)
parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
help='evaluate model on validation set')
parser.add_argument(
'--step',
type=int,
default=[18, 27],
nargs='+',
help='the epoch where optimizer reduce the learning rate')
parser.add_argument('--log_lr', default=False, type=str2bool, help='Use cuda to train model')
parser.add_argument(
'--print-log',
type=str2bool,
default=True,
help='print logging or not')
parser.add_argument(
'--end2end',
type=str2bool,
default=False,
help='print logging or not')
## Parse arguments
args = parser.parse_args()
print(__file__)
file_name = (__file__).split('/')[-1]
file_name = file_name.split('.')[0]
print_log(args, file_name)
## set random seeds
np.random.seed(args.man_seed)
torch.manual_seed(args.man_seed)
if args.cuda:
torch.cuda.manual_seed_all(args.man_seed)
if args.cuda and torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
else:
torch.set_default_tensor_type('torch.FloatTensor')
args.cfg = v2
args.train_sets = 'train'
args.means = (104, 117, 123)
num_classes = len(CLASSES) + 1
args.num_classes = num_classes
# args.step = [int(val) for val in args.step.split(',')]
args.loss_reset_step = 30
args.eval_step = 10000
args.print_step = 10
args.data_root += args.dataset + '/'
## Define the experiment Name will used to same directory
args.snapshot_pref = ('ucf101_CONV-SSD-{}-{}-bs-{}-{}-lr-{:05d}').format(args.dataset,
args.modality, args.batch_size, args.basenet[:-14], int(args.lr*100000)) # + '_' + file_name + '_' + day
print_log(args, args.snapshot_pref)
if not os.path.isdir(args.save_root):
os.makedirs(args.save_root)
net = build_ssd(300, args.num_classes)
if args.Finetune_SSD is True:
print_log(args, "load snapshot")
pretrained_weights = "/home2/lin_li/zjg_code/realtime/ucf24/rgb-ssd300_ucf24_120000.pth"
pretrained_dict = torch.load(pretrained_weights)
model_dict = net.state_dict() # 1. filter out unnecessary keys
pretrained_dict_2 = {k: v for k, v in pretrained_dict.items() if k in model_dict } # 2. overwrite entries in the existing state dict
# pretrained_dict_2['vgg.25.bias'] = pretrained_dict['vgg.24.bias']
# pretrained_dict_2['vgg.25.weight'] = pretrained_dict['vgg.24.weight']
# pretrained_dict_2['vgg.27.bias'] = pretrained_dict['vgg.26.bias']
# pretrained_dict_2['vgg.27.weight'] = pretrained_dict['vgg.26.weight']
# pretrained_dict_2['vgg.29.bias'] = pretrained_dict['vgg.28.bias']
# pretrained_dict_2['vgg.29.weight'] = pretrained_dict['vgg.28.weight']
# pretrained_dict_2['vgg.32.bias'] = pretrained_dict['vgg.31.bias']
# pretrained_dict_2['vgg.32.weight'] = pretrained_dict['vgg.31.weight']
# pretrained_dict_2['vgg.34.bias'] = pretrained_dict['vgg.33.bias']
# pretrained_dict_2['vgg.34.weight'] = pretrained_dict['vgg.33.weight']
model_dict.update(pretrained_dict_2) # 3. load the new state dict
elif args.resume is not None:
if os.path.isfile(args.resume):
print_log(args, ("=> loading checkpoint '{}'".format(args.resume)))
checkpoint = torch.load(args.resume)
if args.end2end is False:
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
net.load_state_dict(checkpoint['state_dict'])
print_log(args, ("=> loaded checkpoint '{}' (epoch {})"
.format(args.evaluate, checkpoint['epoch'])))
else:
print_log(args, ("=> no checkpoint found at '{}'".format(args.resume)))
elif args.modality == 'fastOF':
print_log(args, 'Download pretrained brox flow trained model weights and place them at:::=> ' + args.data_root + 'ucf24/train_data/brox_wieghts.pth')
pretrained_weights = args.data_root + 'train_data/brox_wieghts.pth'
print_log(args, 'Loading base network...')
net.load_state_dict(torch.load(pretrained_weights))
else:
vgg_weights = torch.load(args.data_root +'train_data/' + args.basenet)
print_log(args, 'Loading base network...')
net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
def xavier(param):
init.xavier_uniform(param)
def weights_init(m):
if isinstance(m, nn.Conv2d):
xavier(m.weight.data)
m.bias.data.zero_()
print_log(args, 'Initializing weights for extra layers and HEADs...')
# initialize newly added layers' weights with xavier method
if args.Finetune_SSD is False and args.resume is None:
print_log(args, "init layers")
net.extras.apply(weights_init)
net.loc.apply(weights_init)
net.conf.apply(weights_init)
parameter_dict = dict(net.named_parameters()) # Get parmeter of network in dictionary format wtih name being key
params = []
#Set different learning rate to bias layers and set their weight_decay to 0
for name, param in parameter_dict.items():
if args.end2end is False and name.find('vgg') > -1 and int(name.split('.')[1]) < 23:# :and name.find('cell') <= -1
param.requires_grad = False
print_log(args, name + 'layer parameters will be fixed')
else:
if name.find('bias') > -1:
print_log(args, name + 'layer parameters will be trained @ {}'.format(args.lr*2))
params += [{'params': [param], 'lr': args.lr*2, 'weight_decay': 0}]
else:
print_log(args, name + 'layer parameters will be trained @ {}'.format(args.lr))
params += [{'params':[param], 'lr': args.lr, 'weight_decay':args.weight_decay}]
optimizer = optim.SGD(params, lr=args.base_lr, momentum=args.momentum, weight_decay=args.weight_decay)
criterion = MultiBoxLoss(args.num_classes, 0.5, True, 0, True, 3, 0.5, False, args.cuda)
scheduler = None
# scheduler = MultiStepLR(optimizer, milestones=args.step, gamma=args.gamma)
print_log(args, 'Loading Dataset...')
train_dataset = UCF24Detection(args.data_root, args.train_sets, SSDAugmentation(args.ssd_dim, args.means),
AnnotationTransform(), input_type=args.modality)
val_dataset = UCF24Detection(args.data_root, 'test', BaseTransform(args.ssd_dim, args.means),
AnnotationTransform(), input_type=args.modality,
full_test=False)
train_data_loader = data.DataLoader(train_dataset, args.batch_size, num_workers=args.num_workers,
shuffle=False, collate_fn=detection_collate, pin_memory=True)
val_data_loader = data.DataLoader(val_dataset, args.batch_size, num_workers=args.num_workers,
shuffle=False, collate_fn=detection_collate, pin_memory=True)
print_log(args, "train epoch_size: " + str(len(train_data_loader)))
print_log(args, 'Training SSD on' + train_dataset.name)
my_dict = copy.deepcopy(train_data_loader.dataset.train_vid_frame)
keys = list(my_dict.keys())
k_len = len(keys)
arr = np.arange(k_len)
xxx = copy.deepcopy(train_data_loader.dataset.ids)
# log_file = open(args.save_root + args.snapshot_pref + "_training_" + day + ".log", "w", 1)
# log_file.write()
print_log(args, args.snapshot_pref)
for arg in vars(args):
print(arg, getattr(args, arg))
print_log(args, str(arg)+': '+str(getattr(args, arg)))
print_log(args, str(net))
torch.cuda.synchronize()
for epoch in range(args.start_epoch, args.epochs):
train(train_data_loader, net, criterion, optimizer, epoch, scheduler)
print_log(args, 'Saving state, epoch:' + str(epoch))
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': net.state_dict(),
'best_prec1': best_prec1,
}, epoch = epoch)
# evaluate on validation set
if (epoch + 1) % args.eval_freq == 0 or epoch == args.epochs - 1:
torch.cuda.synchronize()
tvs = time.perf_counter()
mAP, ap_all, ap_strs = validate(args, net, val_data_loader, val_dataset, epoch, iou_thresh=args.iou_thresh)
# remember best prec@1 and save checkpoint
is_best = mAP > best_prec1
best_prec1 = max(mAP, best_prec1)
print_log(args, 'Saving state, epoch:' +str(epoch))
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': net.state_dict(),
'best_prec1': best_prec1,
}, is_best,epoch)
for ap_str in ap_strs:
# print(ap_str)
print_log(args, ap_str)
ptr_str = '\nMEANAP:::=>'+str(mAP)
# print(ptr_str)
# log_file.write()
print_log(args, ptr_str)
torch.cuda.synchronize()
t0 = time.perf_counter()
prt_str = '\nValidation TIME::: {:0.3f}\n\n'.format(t0-tvs)
# print(prt_str)
# log_file.write(ptr_str)
print_log(args, ptr_str)
def train(args, net, optimizer, criterion, scheduler):
log_file = open(args.save_root + "training.log", "w", 1)
log_file.write(args.exp_name + '\n')
for arg in vars(args):
print(arg, getattr(args, arg))
log_file.write(str(arg) + ': ' + str(getattr(args, arg)) + '\n')
log_file.write(str(net))
net.train()
# loss counters
batch_time = AverageMeter()
losses = AverageMeter()
loc_losses = AverageMeter()
cls_losses = AverageMeter()
print('Loading Dataset...')
train_dataset = UCF24Detection(args.data_root,
args.train_sets,
SSDAugmentation(args.ssd_dim, args.means),
AnnotationTransform(),
input_type=args.input_type)
val_dataset = UCF24Detection(args.data_root,
'test',
BaseTransform(args.ssd_dim, args.means),
AnnotationTransform(),
input_type=args.input_type,
full_test=False)
epoch_size = len(train_dataset) // args.batch_size
print('len(train_dataset) : ', len(train_dataset))
print('epoch_size : ', epoch_size)
exit()
print('Training SSD on', train_dataset.name)
if args.visdom:
import visdom
viz = visdom.Visdom()
viz.port = args.vis_port
viz.env = args.exp_name
# initialize visdom loss plot
lot = viz.line(X=torch.zeros((1, )).cpu(),
Y=torch.zeros((1, 6)).cpu(),
opts=dict(xlabel='Iteration',
ylabel='Loss',
title='Current SSD Training Loss',
legend=[
'REG', 'CLS', 'AVG', 'S-REG', ' S-CLS',
' S-AVG'
]))
# initialize visdom meanAP and class APs plot
legends = ['meanAP']
for cls in CLASSES:
legends.append(cls)
val_lot = viz.line(X=torch.zeros((1, )).cpu(),
Y=torch.zeros((1, args.num_classes)).cpu(),
opts=dict(xlabel='Iteration',
ylabel='Mean AP',
title='Current SSD Validation mean AP',
legend=legends))
batch_iterator = None
train_data_loader = data.DataLoader(train_dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
val_data_loader = data.DataLoader(val_dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=False,
collate_fn=detection_collate,
pin_memory=True)
itr_count = 0
torch.cuda.synchronize()
t0 = time.perf_counter()
iteration = 0
while iteration <= args.max_iter:
for i, (images, targets, img_indexs) in enumerate(train_data_loader):
if iteration > args.max_iter:
break
iteration += 1
if args.cuda:
images = Variable(images.cuda())
targets = [
Variable(anno.cuda(), volatile=True) for anno in targets
]
else:
images = Variable(images)
targets = [Variable(anno, volatile=True) for anno in targets]
# forward
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
scheduler.step()
loc_loss = loss_l.data[0]
conf_loss = loss_c.data[0]
# print('Loss data type ',type(loc_loss))
loc_losses.update(loc_loss)
cls_losses.update(conf_loss)
losses.update((loc_loss + conf_loss) / 2.0)
if iteration % args.print_step == 0 and iteration > 0:
if args.visdom:
losses_list = [
loc_losses.val, cls_losses.val, losses.val,
loc_losses.avg, cls_losses.avg, losses.avg
]
viz.line(X=torch.ones((1, 6)).cpu() * iteration,
Y=torch.from_numpy(
np.asarray(losses_list)).unsqueeze(0).cpu(),
win=lot,
update='append')
torch.cuda.synchronize()
t1 = time.perf_counter()
batch_time.update(t1 - t0)
print_line = 'Itration {:06d}/{:06d} loc-loss {:.3f}({:.3f}) cls-loss {:.3f}({:.3f}) ' \
'average-loss {:.3f}({:.3f}) Timer {:0.3f}({:0.3f})'.format(
iteration, args.max_iter, loc_losses.val, loc_losses.avg, cls_losses.val,
cls_losses.avg, losses.val, losses.avg, batch_time.val, batch_time.avg)
torch.cuda.synchronize()
t0 = time.perf_counter()
log_file.write(print_line + '\n')
print(print_line)
# if args.visdom and args.send_images_to_visdom:
# random_batch_index = np.random.randint(images.size(0))
# viz.image(images.data[random_batch_index].cpu().numpy())
itr_count += 1
if itr_count % args.loss_reset_step == 0 and itr_count > 0:
loc_losses.reset()
cls_losses.reset()
losses.reset()
batch_time.reset()
print('Reset accumulators of ', args.exp_name, ' at',
itr_count * args.print_step)
itr_count = 0
if (iteration % args.eval_step == 0
or iteration == 5000) and iteration > 0:
torch.cuda.synchronize()
tvs = time.perf_counter()
print('Saving state, iter:', iteration)
torch.save(
net.state_dict(), args.save_root + 'ssd300_ucf24_' +
repr(iteration) + '.pth')
net.eval() # switch net to evaluation mode
mAP, ap_all, ap_strs = validate(args,
net,
val_data_loader,
val_dataset,
iteration,
iou_thresh=args.iou_thresh)
for ap_str in ap_strs:
print(ap_str)
log_file.write(ap_str + '\n')
ptr_str = '\nMEANAP:::=>' + str(mAP) + '\n'
print(ptr_str)
log_file.write(ptr_str)
if args.visdom:
aps = [mAP]
for ap in ap_all:
aps.append(ap)
viz.line(
X=torch.ones((1, args.num_classes)).cpu() * iteration,
Y=torch.from_numpy(np.asarray(aps)).unsqueeze(0).cpu(),
win=val_lot,
update='append')
net.train() # Switch net back to training mode
torch.cuda.synchronize()
t0 = time.perf_counter()
prt_str = '\nValidation TIME::: {:0.3f}\n\n'.format(t0 - tvs)
print(prt_str)
log_file.write(ptr_str)
log_file.close()
def main():
args.step_values = [int(val) for val in args.step_values.split(',')]
# args.loss_reset_step = 10
args.log_step = 10
args.dataset = args.dataset.lower()
args.basenet = args.basenet.lower()
args.bn = abs(args.bn) # 0 freeze or else use bn
if args.bn > 0:
args.bn = 1 # update bn layer set the flag to 1
args.shared_heads = abs(
args.shared_heads) # 0 no sharing of feature else yes
if args.shared_heads > 0:
args.shared_heads = 1
args.exp_name = 'FPN{:d}-{:s}sh{:02d}-{:s}-bs{:02d}-{:s}-{:s}-lr{:05d}-bn{:d}'.format(
args.input_dim, args.anchor_type, args.shared_heads,
args.dataset, args.batch_size, args.basenet, args.loss_type,
int(args.lr * 100000), args.bn)
args.save_root += args.dataset + '/'
args.save_root = args.save_root + 'cache/' + args.exp_name + '/'
if not os.path.isdir(
args.save_root): # if save directory doesn't exist create it
os.makedirs(args.save_root)
source_dir = args.save_root + '/source/' # where to save the source
utils.copy_source(source_dir)
anchors = 'None'
with torch.no_grad():
if args.anchor_type == 'kmeans':
anchorbox = kanchorBoxes(input_dim=args.input_dim,
dataset=args.dataset)
else:
anchorbox = anchorBox(args.anchor_type,
input_dim=args.input_dim,
dataset=args.dataset)
anchors = anchorbox.forward()
args.ar = anchorbox.ar
args.num_anchors = anchors.size(0)
if args.dataset == 'coco':
args.train_sets = ['train2017']
args.val_sets = ['val2017']
else:
args.train_sets = ['train2007', 'val2007', 'train2012', 'val2012']
args.val_sets = ['test2007']
args.means = [0.485, 0.456, 0.406]
args.stds = [0.229, 0.224, 0.225]
print('\nLoading Datasets')
train_dataset = Detection(args,
train=True,
image_sets=args.train_sets,
transform=Augmentation(args.input_dim,
args.means, args.stds))
print('Done Loading Dataset Train Dataset :::>>>\n',
train_dataset.print_str)
val_dataset = Detection(args,
train=False,
image_sets=args.val_sets,
transform=BaseTransform(args.input_dim, args.means,
args.stds),
full_test=False)
print('Done Loading Dataset Validation Dataset :::>>>\n',
val_dataset.print_str)
args.num_classes = len(train_dataset.classes) + 1
args.classes = train_dataset.classes
args.bias_heads = args.bias_heads > 0
args.head_size = 256
if args.shared_heads > 0:
net = build_fpn_shared_heads(args.basenet,
args.model_dir,
ar=args.ar,
head_size=args.head_size,
num_classes=args.num_classes,
bias_heads=args.bias_heads)
else:
net = build_fpn_unshared(args.basenet,
args.model_dir,
ar=args.ar,
head_size=args.head_size,
num_classes=args.num_classes,
bias_heads=args.bias_heads)
net = net.cuda()
if args.ngpu > 1:
print('\nLets do dataparallel\n')
net = torch.nn.DataParallel(net)
if args.loss_type == 'mbox':
criterion = MultiBoxLoss()
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
elif args.loss_type == 'yolo':
criterion = YOLOLoss()
optimizer = optim.Adam(net.parameters())
elif args.loss_type == 'yolo':
criterion = FocalLoss()
optimizer = optim.Adam(net.parameters())
else:
error('Define correct loss type')
scheduler = MultiStepLR(optimizer,
milestones=args.step_values,
gamma=args.gamma)
train(args, net, anchors, optimizer, criterion, scheduler, train_dataset,
val_dataset)
# cfg = VOC_300
cfg = COCO_512
priorbox = PriorBox(cfg)
with torch.no_grad():
priors = priorbox.forward()
if args.cuda:
priors = priors.cuda()
# numclass = 21
numclass = 81
start_load = time.time()
img = cv2.imread(args.img)
scale = torch.Tensor([img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
net = build_net('test', args.size, numclass) # initialize detector
transform = BaseTransform(net.size, (123, 117, 104), (2, 0, 1))
with torch.no_grad():
x = transform(img).unsqueeze(0)
if args.cuda:
x = x.cuda()
scale = scale.cuda()
state_dict = torch.load(args.trained_model, map_location='cpu')
# create new OrderedDict that does not contain `module.`
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
head = k[:7]
if head == 'module.':
name = k[7:] # remove `module.`
else:
f.write(
str(pred_num) + ' label: ' + label_name +
' score: ' + str(score) + ' ' +
' || '.join(str(c) for c in coords) + '\n')
j += 1
except:
continue
if __name__ == '__main__':
# load net
#num_classes = len(VOC_CLASSES) + 1 # +1 background
num_classes = len(SVG_CLASSES) + 1
net = build_ssd('test', 300, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# load data
#testset = VOCDetection(args.voc_root, [('2007', 'test')], None, AnnotationTransform())
testset = SVGDetection(args.svg_root, image_set, None, LabelTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
testset,
BaseTransform(net.size, (102, 102, 102)),
thresh=args.visual_threshold)
def evaluate_detections(box_list, output_dir, dataset):
write_voc_results_file(box_list, dataset)
do_python_eval(output_dir)
if __name__ == '__main__':
# load net
num_classes = len(VOC_CLASSES) + 1 # +1 background
net = build_ssd('test', 512, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
log.l.info('Finished loading model!')
# load data
dataset = VOCDetection(args.voc_root, [('2007', set_type)],
BaseTransform(512, dataset_mean),
AnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
dataset,
BaseTransform(net.size, dataset_mean),
args.top_k,
512,
thresh=args.confidence_threshold)
Map_loc = lambda storage, loc: storage
else:
Map_loc = 'cpu'
state_dict = torch.load(configs.eval.model_name, map_location=Map_loc)
if 'net_state' in state_dict.keys():
state_dict = state_dict['net_state']
net.load_state_dict(state_dict)
net.eval()
if configs.eval.cuda:
net = net.cuda()
cudnn.benchmark = True
# Load dataset.
dataset = TreeDataset(configs.dataset,
transform=BaseTransform(configs.model.input_size,
configs.model.pixel_means))
# Detect objects.
if not os.path.isfile(ALL_DETECTIONS_FILEPATH):
detect_objects(configs, net, dataset)
elif configs.eval.overwrite_all_detections:
print('Overwriting detections in:')
countdown(5)
detect_objects(configs, net, dataset)
else:
print("{} has been detected. Skipping object detections.".format(
ALL_DETECTIONS_FILEPATH))
# Evaluate detections
evaluate_detections(dataset, configs)
def __init__(self):
self.cfg = cfg
# Load data
print('===> Loading data')
self.train_loader = load_data(
cfg.dataset, 'train') if 'train' in cfg.phase else None
self.eval_loader = load_data(cfg.dataset,
'eval') if 'eval' in cfg.phase else None
self.test_loader = load_data(cfg.dataset,
'test') if 'test' in cfg.phase else None
# self.visualize_loader = load_data(cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
# Build model
print('===> Building model')
self.base_trans = BaseTransform(cfg.image_size[0],
cfg.network.rgb_means,
cfg.network.rgb_std, (2, 0, 1))
self.priors = PriorBox(cfg.anchor)
self.model = eval(cfg.model + '.build_net')(cfg.image_size[0],
cfg.dataset.num_classes)
with torch.no_grad():
self.priors = self.priors.forward()
self.detector = Detect2(cfg.post_process)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
if cfg.train.train_scope == '':
trainable_param = self.model.parameters()
else:
trainable_param = self.trainable_param(cfg.train.train_scope)
self.output_dir = os.path.join(cfg.output_dir, cfg.name, cfg.date)
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
self.log_dir = os.path.join(self.output_dir, 'logs')
if not os.path.exists(self.log_dir):
os.makedirs(self.log_dir)
self.checkpoint = cfg.train.checkpoint
previous = self.find_previous()
previous = False
if previous:
self.start_epoch = previous[0][-1]
self.resume_checkpoint(previous[1][-1])
else:
self.start_epoch = self.initialize()
if self.use_gpu:
print('Utilize GPUs for computation')
print('Number of GPU available', torch.cuda.device_count())
self.model.cuda()
self.priors.cuda()
cudnn.benchmark = True
if cfg.ngpu > 1:
self.model = torch.nn.DataParallel(self.model,
device_ids=list(
range(cfg.ngpu)))
# Print the model architecture and parameters
#print('Model architectures:\n{}\n'.format(self.model))
#print('Parameters and size:')
#for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
print('Trainable scope: {}'.format(cfg.train.train_scope))
self.optimizer = self.configure_optimizer(trainable_param,
cfg.train.optimizer)
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.train.lr_scheduler)
self.max_epochs = cfg.train.lr_scheduler.max_epochs
# metric
if cfg.network.multi_box_loss_type == 'origin':
self.criterion = MultiBoxLoss2(cfg.matcher, self.priors,
self.use_gpu)
else:
print('ERROR: ' + cfg.multi_box_loss_type + ' is not supported')
sys.exit()
# Set the logger
self.writer = SummaryWriter(log_dir=self.log_dir)
self.checkpoint_prefix = cfg.name + '_' + cfg.dataset.dataset
def main():
val_step = 25000
val_steps = [
5000,
]
train_step = 500
args = parser.parse_args()
hostname = socket.gethostname()
args.stepvalues = [int(val) for val in args.stepvalues.split(',')]
exp_name = '{}-{}-{}-sl{:02d}-g{:d}-fs{:d}-{}-{:06d}'.format(
args.dataset, args.arch, args.input, args.seq_len, args.gap,
args.frame_step, args.batch_size, int(args.lr * 1000000))
args.exp_name = exp_name
args.root += args.dataset + '/'
model_save_dir = args.root + 'cache/' + exp_name
if not os.path.isdir(model_save_dir):
os.system('mkdir -p ' + model_save_dir)
args.model_save_dir = model_save_dir
args.global_models_dir = os.path.expanduser(args.global_models_dir)
if args.visdom:
import visdom
viz = visdom.Visdom()
ports = {'mars': 8097, 'sun': 8096}
viz.port = ports[hostname]
viz.env = exp_name
# initialize visdom loss plot
loss_plot = viz.line(X=torch.zeros((1, )).cpu(),
Y=torch.zeros((1, 2)).cpu(),
opts=dict(xlabel='Iteration',
ylabel='Losses',
title='Train & Val Losses',
legend=['Train-Loss', 'Val-Loss']))
eval_plot = viz.line(
X=torch.zeros((1, )).cpu(),
Y=torch.zeros((1, 4)).cpu(),
opts=dict(xlabel='Iteration',
ylabel='Accuracy',
title='Train & Val Accuracies',
legend=['trainTop3', 'valTop3', 'trainTop1', 'valTop1']))
## load dataloading configs
input_size, means, stds = get_mean_size(args.arch)
normalize = transforms.Normalize(mean=means, std=stds)
# Data loading transform based on model type
transform = transforms.Compose([transforms.ToTensor(), normalize])
val_transform = transforms.Compose([
transforms.Scale(int(input_size * 1.1)),
transforms.CenterCrop(int(input_size)),
transforms.ToTensor(),
normalize,
])
if args.arch.find('vgg') > -1:
transform = BaseTransform(size=input_size, mean=means)
val_transform = transform
print('\n\ntransforms are going to be VGG type\n\n')
train_dataset = KINETICS(args.root,
args.input,
transform,
netname=args.arch,
subsets=['train'],
scale_size=int(input_size * 1.1),
input_size=int(input_size),
exp_name=exp_name,
frame_step=args.frame_step,
seq_len=args.seq_len,
gap=args.gap)
args.num_classes = train_dataset.num_classes
print('Models will be cached in ', args.model_save_dir)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_dataset = KINETICS(args.root,
args.input,
val_transform,
netname=args.arch,
subsets=['val'],
exp_name=exp_name,
scale_size=int(input_size * 1.1),
input_size=int(input_size),
frame_step=args.frame_step * 6,
seq_len=args.seq_len,
gap=args.gap)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
model, criterion = initialise_model(args)
parameter_dict = dict(model.named_parameters())
params = []
for name, param in parameter_dict.items():
if name.find('bias') > -1:
params += [{
'params': [param],
'lr': args.lr * 2,
'weight_decay': 0
}]
else:
params += [{
'params': [param],
'lr': args.lr,
'weight_decay': args.weight_decay
}]
optimizer = torch.optim.SGD(params, args.lr, momentum=args.momentum)
if args.resume:
latest_file_name = '{:s}/latest.pth'.format(args.model_save_dir)
latest_dict = torch.load(latest_file_name)
args.start_iteration = latest_dict['iteration'] + 1
model.load_state_dict(torch.load(latest_dict['model_file_name']))
optimizer.load_state_dict(
torch.load(latest_dict['optimizer_file_name']))
log_fid = open(args.model_save_dir + '/training.log', 'a')
else:
log_fid = open(args.model_save_dir + '/training.log', 'w')
log_fid.write(args.exp_name + '\n')
for arg in vars(args):
print(arg, getattr(args, arg))
log_fid.write(str(arg) + ': ' + str(getattr(args, arg)) + '\n')
log_fid.write(str(model))
best_top1 = 0.0
val_loss = 0.0
val_top1 = 0.0
val_top3 = 0.0
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top3 = AverageMeter()
iteration = args.start_iteration
approx_epochs = np.ceil(
float(args.max_iterations - iteration) / len(train_loader))
print(
'Approx Epochs to RUN: {}, Start Ietration {} Max iterations {} # of samples in dataset {}'
.format(approx_epochs, iteration, args.max_iterations,
len(train_loader)))
epoch = -1
scheduler = MultiStepLR(optimizer,
milestones=args.stepvalues,
gamma=args.gamma)
model.train()
torch.cuda.synchronize()
start = time.perf_counter()
while iteration < args.max_iterations:
epoch += 1
for i, (batch, targets, __, __) in enumerate(train_loader):
if i < len(train_loader) - 2:
if iteration > args.max_iterations:
break
iteration += 1
#pdb.set_trace()
#print('input size ',batch.size())
targets = targets.cuda(async=True)
input_var = torch.autograd.Variable(batch.cuda(async=True))
target_var = torch.autograd.Variable(targets)
torch.cuda.synchronize()
data_time.update(time.perf_counter() - start)
# compute output
output = model(input_var)
loss = criterion(output, target_var)
#pdb.set_trace()
# measure accuracy and record loss
prec1, prec3 = accuracy(output.data, targets, topk=(1, 3))
losses.update(loss.data[0], batch.size(0))
top1.update(prec1[0], batch.size(0))
top3.update(prec3[0], batch.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
# measure elapsed time
torch.cuda.synchronize()
batch_time.update(time.perf_counter() - start)
start = time.perf_counter()
if iteration % args.print_freq == 0:
line = 'Epoch: [{0}][{1}/{2}] Time {batch_time.val:.3f} ({batch_time.avg:.3f}) Data {data_time.val:.3f} ({data_time.avg:.3f})'.format(
epoch,
iteration,
len(train_loader),
batch_time=batch_time,
data_time=data_time)
line += 'Loss {loss.val:.4f} ({loss.avg:.4f}) Prec@1 {top1.val:.3f} ({top1.avg:.3f}) Prec@3 {top3.val:.3f} ({top3.avg:.3f})'.format(
loss=losses, top1=top1, top3=top3)
print(line)
log_fid.write(line + '\n')
avgtop1 = top1.avg
avgtop3 = top3.avg
avgloss = losses.avg
if (iteration % val_step == 0
or iteration in val_steps) and iteration > 0:
# evaluate on validation set
val_top1, val_top3, val_loss = validate(
args, val_loader, model, criterion)
line = '\n\nValidation @ {:d}: Top1 {:.2f} Top3 {:.2f} Loss {:.3f}\n\n'.format(
iteration, val_top1, val_top3, val_loss)
print(line)
log_fid.write(line)
# remember best prec@1 and save checkpoint
is_best = val_top1 > best_top1
best_top1 = max(val_top1, best_top1)
torch.cuda.synchronize()
line = '\nBest Top1 sofar {:.3f} current top1 {:.3f} Time taken for Validation {:0.3f}\n\n'.format(
best_top1, val_top1,
time.perf_counter() - start)
log_fid.write(line + '\n')
print(line)
save_checkpoint(
{
'epoch': epoch,
'iteration': iteration,
'arch': args.arch,
'val_top1': val_top1,
'val_top3': val_top3,
'val_loss': val_loss,
'train_top1': avgtop1,
'train_top3': avgtop3,
'train_loss': avgloss,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}, is_best, args.model_save_dir)
if args.visdom:
viz.line(X=torch.ones((1, 2)).cpu() * iteration,
Y=torch.Tensor([avgloss,
val_loss]).unsqueeze(0).cpu(),
win=loss_plot,
update='append')
viz.line(X=torch.ones((1, 4)).cpu() * iteration,
Y=torch.Tensor(
[avgtop3, val_top3, avgtop1,
val_top1]).unsqueeze(0).cpu(),
win=eval_plot,
update='append')
model.train()
if iteration % train_step == 0 and iteration > 0:
if args.visdom:
viz.line(X=torch.ones((1, 2)).cpu() * iteration,
Y=torch.Tensor([avgloss,
val_loss]).unsqueeze(0).cpu(),
win=loss_plot,
update='append')
viz.line(X=torch.ones((1, 4)).cpu() * iteration,
Y=torch.Tensor(
[avgtop3, val_top3, avgtop1,
val_top1]).unsqueeze(0).cpu(),
win=eval_plot,
update='append')
top1.reset()
top3.reset()
losses.reset()
print('RESET::=> ', args.exp_name)
def train():
net.train()
# loss counters
epoch = 0
if args.resume_net:
epoch = 0 + args.resume_epoch
epoch_size = len(train_dataset) // args.batch_size # How many batch size is needed.
max_iter = args.max_epoch * epoch_size
print('max_iter : ', max_iter)
stepvalues_VOC = (150 * epoch_size, 200 * epoch_size, 250 * epoch_size)
stepvalues_COCO = (90 * epoch_size, 120 * epoch_size, 140 * epoch_size)
stepvalues = (stepvalues_VOC, stepvalues_COCO)[args.dataset == 'COCO']
print('Training', args.version, 'on', train_dataset.name)
step_index = 0
## To visualize
if args.visdom:
# initialize visdom loss plot
lot = viz.line(
X=torch.zeros((1,)).cpu(),
Y=torch.zeros((1, 3)).cpu(),
opts=dict(
xlabel='Iteration',
ylabel='Loss',
title='Current SSD Training Loss',
legend=['Loc Loss', 'Conf Loss', 'Loss']
)
)
epoch_lot = viz.line(
X=torch.zeros((1,)).cpu(),
Y=torch.zeros((1, 3)).cpu(),
opts=dict(
xlabel='Epoch',
ylabel='Loss',
title='Epoch SSD Training Loss',
legend=['Loc Loss', 'Conf Loss', 'Loss']
)
)
if args.resume_epoch > 0:
start_iter = args.resume_epoch * epoch_size
else:
start_iter = 0
log_file = open(log_file_path, 'w')
batch_iterator = None
mean_loss_c = 0
mean_loss_l = 0
for iteration in range(start_iter, max_iter + 10):
# -------------------------------------------------------------------------------------------------------------------- #
if iteration % epoch_size == 0:
# create batch iterator
batch_iterator = iter(data.DataLoader(train_dataset, batch_size, shuffle=True, num_workers=args.num_workers, collate_fn=detection_collate))
# loc_loss = 0
# conf_loss = 0
if epoch % args.save_frequency == 0 and epoch > 0:
torch.save(net.state_dict(), os.path.join(save_folder, args.version + '_' + args.dataset + '_epoches_' + repr(epoch) + '.pth'))
## Evaluation
if epoch % args.test_frequency == 0 and epoch > 0:
net.eval()
top_k = (300, 200)[args.dataset == 'COCO']
if args.dataset == 'VOC':
# net.module.size -> net.size.
APs, mAP = test_net(test_save_dir, net, detector, args.cuda, testset, BaseTransform(net.module.size, rgb_means, rgb_std, (2, 0, 1)), top_k, thresh=0.01)
APs = [str(num) for num in APs]
mAP = str(mAP)
log_file.write(str(iteration) + ' APs:\n' + '\n'.join(APs))
log_file.write('\n mAP:\n' + mAP + '\n')
# -------------------------------------------------------------------------------------------------------------------- #
# 1. Log scalar values (scalar summary)
# info = {'accuracy': mAP}
#
# for tag, value in info.items():
# logger.scalar_summary(tag, value, iteration + 1)
# -------------------------------------------------------------------------------------------------------------------- #
else:
test_net(test_save_dir, net, detector, args.cuda, testset, BaseTransform(net.module.size, rgb_means, rgb_std, (2, 0, 1)), top_k, thresh=0.01)
net.train()
epoch += 1
# -------------------------------------------------------------------------------------------------------------------- #
load_t0 = time.time()
if iteration in stepvalues:
step_index = stepvalues.index(iteration) + 1
if args.visdom:
viz.line(
X=torch.ones((1, 3)).cpu() * epoch,
Y=torch.Tensor([mean_loss_l, mean_loss_c, mean_loss_l + mean_loss_c]).unsqueeze(0).cpu() / epoch_size,
win=epoch_lot,
update='append'
)
lr = adjust_learning_rate(optimizer, args.gamma, epoch, step_index, iteration, epoch_size)
# load train data
images, targets = next(batch_iterator)
if args.cuda:
images = images.cuda()
targets = [ann.cuda() for ann in targets]
else:
images = images
targets = [ann for ann in targets]
# forward
out = net(images)
# backprop
optimizer.zero_grad()
# arm branch loss
loss_l, loss_c = criterion(out, priors, targets)
# odm branch loss
mean_loss_c += loss_c.item()
mean_loss_l += loss_l.item()
loss = loss_l + loss_c
loss.backward()
optimizer.step()
load_t1 = time.time()
# -------------------------------------------------------------------------------------------------------------------- #
if iteration % epoch_size == 0:
# 1. Log scalar values (scalar summary)
info = {'loss': loss.item(), 'loc_loss': loss_l.item(), 'conf_loss': loss_c.item()}
for tag, value in info.items():
logger.scalar_summary(tag, value, iteration + 1)
# -------------------------------------------------------------------------------------------------------------------- #
# -------------------------------------------------------------------------------------------------------------------- #
if iteration % 10 == 0:
print('Epoch:' + repr(epoch) + ' || epochiter: ' + repr(iteration % epoch_size) + '/' + repr(epoch_size)
+ '|| Totel iter ' + repr(iteration) + ' || L: %.4f C: %.4f||' % (mean_loss_l / 10, mean_loss_c / 10) +
'Batch time: %.4f sec. ||' % (load_t1 - load_t0) + 'LR: %.8f' % (lr))
log_file.write('Epoch:' + repr(epoch) + ' || epochiter: ' + repr(iteration % epoch_size) + '/' + repr(epoch_size)
+ '|| Totel iter ' +repr(iteration) + ' || L: %.4f C: %.4f||' % (
mean_loss_l / 10, mean_loss_c / 10) +'Batch time: %.4f sec. ||' % (load_t1 - load_t0) + 'LR: %.8f' % (lr) + '\n')
mean_loss_c = 0
mean_loss_l = 0
if args.visdom and args.send_images_to_visdom:
random_batch_index = np.random.randint(images.size(0))
viz.image(images.data[random_batch_index].cpu().numpy())
# -------------------------------------------------------------------------------------------------------------------- #
log_file.close()
torch.save(net.state_dict(), os.path.join(save_folder,'Final_' + args.version + '_' + args.dataset + '.pth'))
self.ptr = 0
self.size = size
self.ids = [i for i in range(lst.size(0))]
if shuffle:
random.shuffle(self.ids)
if drop_last:
self.ids = self.ids[:int(lst.size(0) / size) * size]
def __next__(self):
self.ptr += self.size
if self.ptr > len(self.lst):
raise StopIteration()
return self.lst[self.ids[self.ptr -
self.size:self.ptr]].clone().detach()
def __iter__(self):
return self.IterInstance(self.bb_data, self.b_size, self.shuffle,
self.drop_last)
if __name__ == '__main__':
rt = COCO_ROOT
data_set = COCODetection(
root=rt,
image_sets=(('2017', 'train'), ),
transform=BaseTransform(300, (104, 117, 123)),
target_transform=COCOAnnotationTransform(keep_difficult=False))
loader = BoundingBoxesLoader(data_set,
[i for i in range(len(COCO_CLASSES))],
cache_pth='../truths/gts_coco_17train.pth')
for k, v in state_dict.items():
name = k[7:]
new_state_dict[name] = v
net.load_state_dict(new_state_dict)
# eval mode
net.eval()
print('Finished loading model!')
# load data
#testset = VOCDetection(args.voc_root, [('2007', 'test')], None, AnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
# cv_idx_for_test must be equal to the checkpoint idx of the trained model (otherwise cheat)
means = (34, 34, 34)
trainset = FISHdetection(ct_train[cv_idx_for_test],
coord_ssd_train[cv_idx_for_test], None,
'lesion_train')
validset = FISHdetection(ct_valid[cv_idx_for_test],
coord_ssd_valid[cv_idx_for_test], None,
'lesion_valid')
# allset = FISHdetection(np.vstack(ct), np.vstack(coord).astype(np.float64), None, 'lesion_all')
test_net(args.save_folder,
net,
args.cuda,
validset,
BaseTransform(size, means),
thresh=args.visual_threshold)
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
head = k[:7]
if head == 'module.':
name = k[7:] # remove `module.`
else:
name = k
new_state_dict[name] = v
net.load_state_dict(new_state_dict)
net.eval()
print('Finished loading model!')
# load data
print(args.picture_path)
testset = VOCDetection(
args.picture_path, [('2007', 'test')], None, AnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
else:
net = net.cpu()
# evaluation
#top_k = (300, 200)[args.dataset == 'COCO']
top_k = 200
detector = Detect(num_classes,0,cfg)
save_folder = os.path.join(args.save_folder,args.dataset)
rgb_means = (103.94,116.78,123.68)
test_net(save_folder, net, detector, args.cuda, testset, args.device_ip, args.start_time, args.num_th, args.bbox_params, args.save_path,
BaseTransform(net.size, rgb_means, (2, 0, 1)),
top_k, thresh=0.01)
def train():
net.train()
# loss counters
loc_loss = 0 # epoch
conf_loss = 0
epoch = 0
if args.resume_net:
epoch = 0 + args.resume_epoch
epoch_size = len(train_dataset) // args.batch_size
max_iter = args.max_epoch * epoch_size
stepvalues_VOC = (150 * epoch_size, 200 * epoch_size, 250 * epoch_size)
stepvalues_COCO = (90 * epoch_size, 120 * epoch_size, 140 * epoch_size)
stepvalues = (stepvalues_VOC, stepvalues_COCO)[args.dataset == 'COCO']
print('Training', args.version, 'on', train_dataset.name)
step_index = 0
if args.visdom:
# initialize visdom loss plot
lot = viz.line(X=torch.zeros((1, )).cpu(),
Y=torch.zeros((1, 3)).cpu(),
opts=dict(xlabel='Iteration',
ylabel='Loss',
title='Current SSD Training Loss',
legend=['Loc Loss', 'Conf Loss', 'Loss']))
epoch_lot = viz.line(X=torch.zeros((1, )).cpu(),
Y=torch.zeros((1, 3)).cpu(),
opts=dict(
xlabel='Epoch',
ylabel='Loss',
title='Epoch SSD Training Loss',
legend=['Loc Loss', 'Conf Loss', 'Loss']))
if args.resume_epoch > 0:
start_iter = args.resume_epoch * epoch_size
else:
start_iter = 0
#log_file = open(log_file_path,'w')
batch_iterator = None
mean_odm_loss_c = 0
mean_odm_loss_l = 0
mean_arm_loss_c = 0
mean_arm_loss_l = 0
for iteration in range(start_iter, max_iter + 10):
if (iteration % epoch_size == 0):
# create batch iterator
batch_iterator = iter(
data.DataLoader(train_dataset,
batch_size,
shuffle=True,
num_workers=args.num_workers,
collate_fn=detection_collate))
loc_loss = 0
conf_loss = 0
if epoch % args.save_frequency == 0 and epoch > 0:
torch.save(
net.state_dict(),
os.path.join(
save_folder, args.version + '_' + args.dataset +
'_epoches_' + repr(epoch) + '.pth'))
if epoch % args.test_frequency == 0 and epoch > 0:
net.eval()
top_k = (300, 200)[args.dataset == 'COCO']
if args.dataset == 'VOC':
APs, mAP = test_net(test_save_dir,
net,
detector,
args.cuda,
testset,
BaseTransform(net.module.size,
rgb_means, rgb_std,
(2, 0, 1)),
top_k,
thresh=0.01)
APs = [str(num) for num in APs]
mAP = str(mAP)
with open(log_file_path, 'w+') as log_file:
log_file.write(
str(iteration) + ' APs:\n' + '\n'.join(APs))
log_file.write('\nmAP:\n' + mAP + '\n')
else:
test_net(test_save_dir,
net,
detector,
args.cuda,
testset,
BaseTransform(net.module.size, rgb_means, rgb_std,
(2, 0, 1)),
top_k,
thresh=0.01)
net.train()
epoch += 1
load_t0 = time.time()
if iteration in stepvalues:
step_index = stepvalues.index(iteration) + 1
if args.visdom:
viz.line(
X=torch.ones((1, 3)).cpu() * epoch,
Y=torch.Tensor([loc_loss, conf_loss, loc_loss + conf_loss
]).unsqueeze(0).cpu() / epoch_size,
win=epoch_lot,
update='append')
lr = adjust_learning_rate(optimizer, args.gamma, epoch, step_index,
iteration, epoch_size)
# load train data
images, targets = next(batch_iterator)
#print(np.sum([torch.sum(anno[:,-1] == 2) for anno in targets]))
if args.cuda:
images = Variable(images.cuda())
targets = [
Variable(anno.cuda(), volatile=True) for anno in targets
]
else:
images = Variable(images)
targets = [Variable(anno, volatile=True) for anno in targets]
# forward
out = net(images)
arm_loc, arm_conf, odm_loc, odm_conf = out
# backprop
optimizer.zero_grad()
#arm branch loss
arm_loss_l, arm_loss_c = arm_criterion((arm_loc, arm_conf), priors,
targets)
#odm branch loss
odm_loss_l, odm_loss_c = odm_criterion(
(odm_loc, odm_conf), priors, targets, (arm_loc, arm_conf), False)
mean_arm_loss_c += arm_loss_c.data[0]
mean_arm_loss_l += arm_loss_l.data[0]
mean_odm_loss_c += odm_loss_c.data[0]
mean_odm_loss_l += odm_loss_l.data[0]
loss = arm_loss_l + arm_loss_c + odm_loss_l + odm_loss_c
loss.backward()
optimizer.step()
load_t1 = time.time()
if iteration % 10 == 0:
print('Epoch:' + repr(epoch) + ' || epochiter: ' +
repr(iteration % epoch_size) + '/' + repr(epoch_size) +
'|| Total iter ' + repr(iteration) +
' || AL: %.4f AC: %.4f OL: %.4f OC: %.4f||' %
(mean_arm_loss_l / 10, mean_arm_loss_c / 10,
mean_odm_loss_l / 10, mean_odm_loss_c / 10) +
'Batch time: %.4f sec. ||' % (load_t1 - load_t0) +
'LR: %.8f' % (lr))
# log_file.write('Epoch:' + repr(epoch) + ' || epochiter: ' + repr(iteration % epoch_size) + '/' + repr(epoch_size)
# + '|| Total iter ' +
# repr(iteration) + ' || AL: %.4f AC: %.4f OL: %.4f OC: %.4f||' % (
# mean_arm_loss_l / 10,mean_arm_loss_c / 10,mean_odm_loss_l / 10, mean_odm_loss_c / 10) +
# 'Batch time: %.4f sec. ||' % (load_t1 - load_t0) + 'LR: %.8f' % (lr)+'\n')
mean_odm_loss_c = 0
mean_odm_loss_l = 0
mean_arm_loss_c = 0
mean_arm_loss_l = 0
if args.visdom and args.send_images_to_visdom:
random_batch_index = np.random.randint(images.size(0))
viz.image(images.data[random_batch_index].cpu().numpy())
log_file.close()
torch.save(
net.state_dict(),
os.path.join(save_folder,
'Final_' + args.version + '_' + args.dataset + '.pth'))
# 'weights/ssd300_0712_150000.pth', 'weights/ssd300_0712_160000.pth'
# 'weights/ssd512_tme_255000_cut_90.4.pth'
'weights/ssd512_tme_255000.pth'
]
for model_name in check_point_list:
# load net
num_classes = len(TME_CLASSES) + 1 # +1 background
net = build_ssd('test', args.dim, num_classes) # initialize SSD
# net.load_state_dict(torch.load(args.trained_model))
net.load_state_dict(torch.load(model_name))
net.eval()
log.l.info(model_name)
log.l.info('Finished loading model!')
# load data
dataset = TMEDetection(DataRoot, [(set_type)],
BaseTransform(args.dim, dataset_mean),
AnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
dataset,
BaseTransform(net.size, dataset_mean),
args.top_k,
args.dim,
thresh=args.confidence_threshold)
imgs_path_dict = {'VOC': 'imgs/VOC', 'COCO': 'imgs/COCO'}
im_path = imgs_path_dict[args.dataset]
imgs_result_path = os.path.join(im_path, 'im_res')
if not os.path.exists(imgs_result_path):
os.makedirs(imgs_result_path)
with torch.no_grad():
priors = priorbox.forward()
if cfg.test_cfg.cuda:
net = net.cuda()
priors = priors.cuda()
cudnn.benchmark = True
else:
net = net.cpu()
_preprocess = BaseTransform(cfg.model.input_size, cfg.model.rgb_means,
(2, 0, 1))
detector = Detect(num_classes, cfg.loss.bkg_label, anchor_config)
def _to_color(indx, base):
""" return (b, r, g) tuple"""
base2 = base * base
b = 2 - indx / base2
r = 2 - (indx % base2) / base
g = 2 - (indx % base2) % base
return b * 127, r * 127, g * 127
base = int(np.ceil(pow(num_classes, 1. / 3)))
colors = [_to_color(x, base) for x in range(num_classes)]
cats = [
def main():
global my_dict, keys, k_len, arr, xxx, args, log_file, best_prec1
parser = argparse.ArgumentParser(
description='Single Shot MultiBox Detector Training')
parser.add_argument('--version',
default='v2',
help='conv11_2(v2) or pool6(v1) as last layer')
parser.add_argument('--basenet',
default='vgg16_reducedfc.pth',
help='pretrained base model')
parser.add_argument('--dataset',
default='ucf24',
help='pretrained base model')
parser.add_argument('--ssd_dim',
default=300,
type=int,
help='Input Size for SSD') # only support 300 now
parser.add_argument(
'--modality',
default='rgb',
type=str,
help='INput tyep default rgb options are [rgb,brox,fastOF]')
parser.add_argument('--jaccard_threshold',
default=0.5,
type=float,
help='Min Jaccard index for matching')
parser.add_argument('--batch_size',
default=40,
type=int,
help='Batch size for training')
parser.add_argument('--num_workers',
default=0,
type=int,
help='Number of workers used in dataloading')
parser.add_argument('--max_iter',
default=120000,
type=int,
help='Number of training iterations')
parser.add_argument('--man_seed',
default=123,
type=int,
help='manualseed for reproduction')
parser.add_argument('--cuda',
default=True,
type=str2bool,
help='Use cuda to train model')
parser.add_argument('--ngpu',
default=1,
type=str2bool,
help='Use cuda to train model')
parser.add_argument('--lr',
'--learning-rate',
default=0.0005,
type=float,
help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, help='momentum')
parser.add_argument('--stepvalues',
default='70000,90000',
type=str,
help='iter number when learning rate to be dropped')
parser.add_argument('--weight_decay',
default=5e-4,
type=float,
help='Weight decay for SGD')
parser.add_argument('--gamma',
default=0.2,
type=float,
help='Gamma update for SGD')
parser.add_argument('--log_iters',
default=True,
type=bool,
help='Print the loss at each iteration')
parser.add_argument('--visdom',
default=False,
type=str2bool,
help='Use visdom to for loss visualization')
parser.add_argument('--data_root',
default=relative_path + 'realtime/',
help='Location of VOC root directory')
parser.add_argument('--save_root',
default=relative_path + 'realtime/saveucf24/',
help='Location to save checkpoint models')
parser.add_argument('--iou_thresh',
default=0.5,
type=float,
help='Evaluation threshold')
parser.add_argument('--conf_thresh',
default=0.01,
type=float,
help='Confidence threshold for evaluation')
parser.add_argument('--nms_thresh',
default=0.45,
type=float,
help='NMS threshold')
parser.add_argument('--topk',
default=50,
type=int,
help='topk for evaluation')
parser.add_argument('--clip_gradient',
default=40,
type=float,
help='gradients clip')
parser.add_argument('--resume',
default=None,
type=str,
help='Resume from checkpoint')
parser.add_argument('--start_epoch',
default=0,
type=int,
help='start epoch')
parser.add_argument('--epochs',
default=35,
type=int,
metavar='N',
help='number of total epochs to run')
parser.add_argument('--eval_freq',
default=2,
type=int,
metavar='N',
help='evaluation frequency (default: 5)')
parser.add_argument('--snapshot_pref',
type=str,
default="ucf101_vgg16_ssd300_")
parser.add_argument('--lr_milestones',
default=[-2, -5],
type=float,
help='initial learning rate')
parser.add_argument('--arch', type=str, default="VGG16")
parser.add_argument('--Finetune_SSD', default=False, type=str)
parser.add_argument('-e',
'--evaluate',
dest='evaluate',
action='store_true',
help='evaluate model on validation set')
parser.add_argument('--gpus', nargs='+', type=int, default=[0, 1, 2, 3])
print(__file__)
file_name = (__file__).split('/')[-1]
file_name = file_name.split('.')[0]
print(file_name)
## Parse arguments
args = parser.parse_args()
## set random seeds
np.random.seed(args.man_seed)
torch.manual_seed(args.man_seed)
if args.cuda:
torch.cuda.manual_seed_all(args.man_seed)
if args.cuda and torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
else:
torch.set_default_tensor_type('torch.FloatTensor')
args.cfg = v2
args.train_sets = 'train'
args.means = (104, 117, 123)
num_classes = len(CLASSES) + 1
args.num_classes = num_classes
args.stepvalues = [int(val) for val in args.stepvalues.split(',')]
args.loss_reset_step = 30
args.eval_step = 10000
args.print_step = 10
args.data_root += args.dataset + '/'
## Define the experiment Name will used to same directory
day = (time.strftime('%m-%d', time.localtime(time.time())))
args.snapshot_pref = ('ucf101_CONV-SSD-{}-{}-bs-{}-{}-lr-{:05d}').format(
args.dataset, args.modality, args.batch_size, args.basenet[:-14],
int(args.lr * 100000)) + '_' + file_name + '_' + day
print(args.snapshot_pref)
if not os.path.isdir(args.save_root):
os.makedirs(args.save_root)
net = build_refine_ssd(300, args.num_classes)
net = torch.nn.DataParallel(net, device_ids=args.gpus)
if args.Finetune_SSD is True:
print("load snapshot")
pretrained_weights = "/data4/lilin/my_code/realtime/ucf24/rgb-ssd300_ucf24_120000.pth"
pretrained_dict = torch.load(pretrained_weights)
model_dict = net.state_dict() # 1. filter out unnecessary keys
pretrained_dict_2 = {
k: v
for k, v in pretrained_dict.items() if k in model_dict
} # 2. overwrite entries in the existing state dict
model_dict.update(pretrained_dict_2) # 3. load the new state dict
elif args.resume:
if os.path.isfile(args.resume):
print(("=> loading checkpoint '{}'".format(args.resume)))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
net.load_state_dict(checkpoint['state_dict'])
print(("=> loaded checkpoint '{}' (epoch {})".format(
args.evaluate, checkpoint['epoch'])))
else:
print(("=> no checkpoint found at '{}'".format(args.resume)))
elif args.modality == 'fastOF':
print(
'Download pretrained brox flow trained model weights and place them at:::=> ',
args.data_root + 'ucf24/train_data/brox_wieghts.pth')
pretrained_weights = args.data_root + 'train_data/brox_wieghts.pth'
print('Loading base network...')
net.load_state_dict(torch.load(pretrained_weights))
else:
vgg_weights = torch.load(args.data_root + 'train_data/' + args.basenet)
print('Loading base network...')
net.module.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
# initialize newly added layers' weights with xavier method
if args.Finetune_SSD is False and args.resume is None:
print('Initializing weights for extra layers and HEADs...')
net.module.clstm_1.apply(weights_init)
net.module.clstm_2.apply(weights_init)
net.module.extras_r.apply(weights_init)
net.module.loc_r.apply(weights_init)
net.module.conf_r.apply(weights_init)
net.module.extras.apply(weights_init)
net.module.loc.apply(weights_init)
net.module.conf.apply(weights_init)
parameter_dict = dict(net.named_parameters(
)) # Get parmeter of network in dictionary format wtih name being key
params = []
#Set different learning rate to bias layers and set their weight_decay to 0
for name, param in parameter_dict.items():
if name.find('vgg') > -1 and int(
name.split('.')[2]) < 23: # :and name.find('cell') <= -1
param.requires_grad = False
print(name, 'layer parameters will be fixed')
else:
if name.find('bias') > -1:
print(
name, 'layer parameters will be trained @ {}'.format(
args.lr * 2))
params += [{
'params': [param],
'lr': args.lr * 2,
'weight_decay': 0
}]
else:
print(name,
'layer parameters will be trained @ {}'.format(args.lr))
params += [{
'params': [param],
'lr': args.lr,
'weight_decay': args.weight_decay
}]
optimizer = optim.SGD(params,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = RecurrentMultiBoxLoss(args.num_classes, 0.5, True, 0, True, 3,
0.5, False, args.cuda)
scheduler = None
# scheduler = LogLR(optimizer, lr_milestones=args.lr_milestones, total_epoch=args.epochs)
scheduler = MultiStepLR(optimizer,
milestones=args.stepvalues,
gamma=args.gamma)
print('Loading Dataset...')
num_gpu = len(args.gpus)
rootpath = args.data_root
imgtype = args.modality
imagesDir = rootpath + imgtype + '/'
split = 1
splitfile = rootpath + 'splitfiles/trainlist{:02d}.txt'.format(split)
trainvideos = readsplitfile(splitfile)
splitfile = rootpath + 'splitfiles/testlist{:02d}.txt'.format(split)
testvideos = readsplitfile(splitfile)
####### val dataset does not need shuffle #######
val_data_loader = []
len_test = len(testvideos)
random.shuffle(testvideos)
for i in range(num_gpu):
testvideos_temp = testvideos[int(i * len_test /
num_gpu):int((i + 1) * len_test /
num_gpu)]
val_dataset = UCF24Detection(args.data_root,
'test',
BaseTransform(args.ssd_dim, args.means),
AnnotationTransform(),
input_type=args.modality,
full_test=False,
videos=testvideos_temp,
istrain=False)
val_data_loader.append(
data.DataLoader(val_dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=False,
collate_fn=detection_collate,
pin_memory=True,
drop_last=True))
log_file = open(
args.save_root + args.snapshot_pref + "_training_" + day + ".log", "w",
1)
log_file.write(args.snapshot_pref + '\n')
for arg in vars(args):
print(arg, getattr(args, arg))
log_file.write(str(arg) + ': ' + str(getattr(args, arg)) + '\n')
log_file.write(str(net))
torch.cuda.synchronize()
len_train = len(trainvideos)
for epoch in range(args.start_epoch, args.epochs):
####### shuffle train dataset #######
random.shuffle(trainvideos)
train_data_loader = []
for i in range(num_gpu):
trainvideos_temp = trainvideos[int(i * len_train /
num_gpu):int((i + 1) *
len_train /
num_gpu)]
train_dataset = UCF24Detection(args.data_root,
'train',
SSDAugmentation(
args.ssd_dim, args.means),
AnnotationTransform(),
input_type=args.modality,
videos=trainvideos_temp,
istrain=True)
train_data_loader.append(
data.DataLoader(train_dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=False,
collate_fn=detection_collate,
pin_memory=True,
drop_last=True))
print("Train epoch_size: ", len(train_data_loader))
print('Train SSD on', train_dataset.name)
########## train ###########
train(train_data_loader, net, criterion, optimizer, scheduler, epoch,
num_gpu)
print('Saving state, epoch:', epoch)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': net.state_dict(),
'best_prec1': best_prec1,
},
epoch=epoch)
#### log lr ###
# scheduler.step()
# evaluate on validation set
if (
epoch + 1
) % args.eval_freq == 0 or epoch == args.epochs - 1 or epoch == 0: #
torch.cuda.synchronize()
tvs = time.perf_counter()
mAP, ap_all, ap_strs = validate(args,
net,
val_data_loader,
val_dataset,
epoch,
iou_thresh=args.iou_thresh,
num_gpu=num_gpu)
# remember best prec@1 and save checkpoint
is_best = mAP > best_prec1
best_prec1 = max(mAP, best_prec1)
print('Saving state, epoch:', epoch)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': net.state_dict(),
'best_prec1': best_prec1,
}, is_best, epoch)
for ap_str in ap_strs:
print(ap_str)
log_file.write(ap_str + '\n')
ptr_str = '\nMEANAP:::=>' + str(mAP) + '\n'
print(ptr_str)
log_file.write(ptr_str)
torch.cuda.synchronize()
t0 = time.perf_counter()
prt_str = '\nValidation TIME::: {:0.3f}\n\n'.format(t0 - tvs)
print(prt_str)
log_file.write(ptr_str)
log_file.close()
from data import BaseTransform, VOC_CLASSES as labelmap
from ssd import build_ssd
if torch.cuda.is_available():
if args.cuda:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
if not args.cuda:
print(
"WARNING: It looks like you have a CUDA device, but aren't " +
"using CUDA.\nRun with --cuda for optimal speed.")
torch.set_default_tensor_type('torch.FloatTensor')
else:
torch.set_default_tensor_type('torch.FloatTensor')
net = build_ssd('test', 300, 21) # initialize SSD
net.load_state_dict(torch.load(args.weights))
transform = BaseTransform(net.size,
(104 / 256.0, 117 / 256.0, 123 / 256.0))
fps = FPS().start()
cv2_demo(net.eval(), transform)
# stop the timer and display FPS information
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# cleanup
cv2.destroyAllWindows()
#stream.stop()
if __name__ == '__main__':
args = parse_arg()
#if args.dataset == 'coco_person':
# gt_json=os.path.expanduser('~/data/datasets/COCO/annotations/instances_val2014.json')
# num_classes = 2
# config = coco_person
#elif args.dataset == 'modanet':
# num_classes = 14 # plus background
# pass
if args.dataset == 'COCO_PERSON':
dataset_root = COCO_ROOT
cfg = configs['coco_person_{}'.format(args.size)]
test_dataset = COCOPersonDetection(root=dataset_root,
image_set='val2014',
transform=BaseTransform(
cfg['min_dim'], MEANS))
gt_json = os.path.expanduser(
'~/data/datasets/COCO/annotations/instances_val2014.json')
just_person = True
elif args.dataset == 'MODANET':
cfg = configs['modanet_{}'.format(args.size)]
print(cfg)
h5_root = os.path.expanduser(
'~/data/datasets/modanet/modanet_{}_{}_{}_hdf5.hdf5')
h5_root_train = h5_root.format(cfg['min_dim'] // 2, cfg['min_dim'],
'train')
h5_root_val = h5_root.format(cfg['min_dim'] // 2, cfg['min_dim'],
'val')
test_dataset = ModanetDetectionHDF5(h5_root_val,
part='val',
transform=BaseTransform(
cv2.putText(frame, labelmap[i - 1], (int(pt[0]), int(pt[1])),
cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2,
cv2.LINE_AA)
j += 1
return frame
net = build_ssd('test') # We create an object that is our neural network ssd.
net.load_state_dict(
torch.load('ssd300_mAP_77.43_v2.pth',
map_location=lambda storage, loc: storage)
) # We get the weights of the neural network from another one that is pretrained (ssd300_mAP_77.43_v2.pth).
# Creating the transformation
transform = BaseTransform(
net.size, (104 / 256.0, 117 / 256.0, 123 / 256.0)
) # We create an object of the BaseTransform class, a class that will do the required transformations so that the image can be the input of the neural network.
reader = imageio.get_reader("funny_dog.mp4")
fps = reader.get_meta_data()["fps"]
writer = imageio.get_writer("output.mp4", fps=fps)
for i, frame in enumerate(
reader): # We iterate on the frames of the output video:
frame = detect(
frame, net.eval(), transform
) # We call our detect function (defined above) to detect the object on the frame.
writer.append_data(frame) # We add the next frame in the output video.
print(i) # We print the number of the processed frame.
writer.close(
def test():
# get device
if args.cuda:
print('use cuda')
cudnn.benchmark = True
device = torch.device("cuda")
else:
device = torch.device("cpu")
# load net
num_classes = 80
input_size = [args.input_size, args.input_size]
if args.dataset == 'COCO':
testset = COCODataset(data_dir=coco_root,
json_file='instances_val2017.json',
name='val2017',
img_size=input_size[0],
transform=BaseTransform(input_size),
debug=args.debug)
elif args.dataset == 'VOC':
testset = VOCDetection(VOC_ROOT, [('2007', 'test')],
BaseTransform(input_size))
# build model
# # yolo_v3_plus series: yolo_v3_plus, yolo_v3_plus_large, yolo_v3_plus_medium, yolo_v3_plus_small
if args.version == 'yolo_v3_plus':
from models.yolo_v3_plus import YOLOv3Plus
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'd-53'
yolo_net = YOLOv3Plus(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_plus on the COCO dataset ......')
elif args.version == 'yolo_v3_plus_large':
from models.yolo_v3_plus import YOLOv3Plus
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'csp-l'
yolo_net = YOLOv3Plus(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_plus_large on the COCO dataset ......')
elif args.version == 'yolo_v3_plus_half':
from models.yolo_v3_plus import YOLOv3Plus
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'csp-h'
yolo_net = YOLOv3Plus(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_plus_half on the COCO dataset ......')
elif args.version == 'yolo_v3_plus_medium':
from models.yolo_v3_plus import YOLOv3Plus
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'csp-m'
yolo_net = YOLOv3Plus(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_plus_medium on the COCO dataset ......')
elif args.version == 'yolo_v3_plus_small':
from models.yolo_v3_plus import YOLOv3Plus
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'csp-s'
yolo_net = YOLOv3Plus(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_plus_small on the COCO dataset ......')
# # yolo_v3_slim series:
elif args.version == 'yolo_v3_slim':
from models.yolo_v3_slim import YOLOv3Slim
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'd-tiny'
yolo_net = YOLOv3Slim(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_slim on the COCO dataset ......')
elif args.version == 'yolo_v3_slim_csp':
from models.yolo_v3_slim import YOLOv3Slim
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'csp-slim'
yolo_net = YOLOv3Slim(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_slim_csp on the COCO dataset ......')
elif args.version == 'yolo_v3_slim_csp2':
from models.yolo_v3_slim import YOLOv3Slim
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'csp-tiny'
yolo_net = YOLOv3Slim(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo_v3_slim_csp2 on the COCO dataset ......')
# # yolo_v3_spp
elif args.version == 'yolo_v3_spp':
from models.yolo_v3_spp import YOLOv3SPP
anchor_size = config.MULTI_ANCHOR_SIZE_COCO
backbone = 'd-53'
yolo_net = YOLOv3SPP(device,
input_size=input_size,
num_classes=num_classes,
conf_thresh=args.conf_thresh,
nms_thresh=args.nms_thresh,
anchor_size=anchor_size,
backbone=backbone,
diou_nms=args.diou_nms)
print('Let us test yolo-v3-spp on the COCO dataset ......')
else:
print('Unknown version !!!')
exit()
yolo_net.load_state_dict(
torch.load(args.trained_model, map_location='cuda'))
yolo_net.to(device).eval()
print('Finished loading model!')
# evaluation
test_net(yolo_net, device, testset, thresh=args.visual_threshold)
def autolabel(args):
# init model
sys.path.append(os.path.dirname(os.path.dirname(
os.path.abspath(__file__))))
from data import BaseTransform, VOC_CLASSES as labelmap
from ssd import SSD300
num_classes = len(labelmap) + 1
net = SSD300(num_classes, 'test').eval()
net.load_state_dict(torch.load(args.weights))
transform = BaseTransform(300, (104 / 256.0, 117 / 256.0, 123 / 256.0))
def predict(frame):
height, width = frame.shape[:2]
x = torch.from_numpy(transform(frame)[0]).permute(2, 0, 1)
x = Variable(x.unsqueeze(0))
y = net(x) # forward pass
detections = y.data
# scale each detection back up to the image
scale = torch.Tensor([width, height, width, height])
pts = []
for i in range(detections.size(1)): # 1--head, 2--body, 3--ass
j = 0
while detections[0, i, j, 0] >= 0.6:
pt = (detections[0, i, j, 1:] *
scale).cpu().numpy().astype(int)
pts.append([i] + pt.tolist())
j += 1
return pts
def predict2(frame):
height, width = frame.shape[:2]
x = torch.from_numpy(transform(frame)[0]).permute(2, 0, 1)
x = Variable(x.unsqueeze(0))
y = net(x) # forward pass
detections = y.data
# scale each detection back up to the image
scale = torch.Tensor([width, height, width, height])
for i in range(detections.size(1)):
j = 0
while detections[0, i, j, 0] >= 0.6:
pt = (detections[0, i, j, 1:] * scale).cpu().numpy()
cv2.rectangle(frame, (int(pt[0]), int(pt[1])),
(int(pt[2]), int(pt[3])), COLORS[i % 3], 2)
cv2.putText(frame, labelmap[i - 1], (int(pt[0]), int(pt[1])),
FONT, 2, (255, 255, 255), 2, cv2.LINE_AA)
j += 1
return frame
fid = open('anno.txt', 'w')
def write2file(imgname, bboxes):
imgname = imgname.split('/')[-2] + '_' + imgname.split('/')[-1]
fid.write(imgname)
for bbox in bboxes:
fid.write(' ' + str(bbox) + ' ')
fid.write('\n')
classes = os.listdir(args.image_dir)
import tqdm
t = tqdm.tqdm()
t.total = len(classes)
for class_id in classes:
t.update()
imgfiles = sorted([
os.path.join(os.path.join(args.image_dir, class_id), x)
for x in sorted(os.listdir(os.path.join(args.image_dir, class_id)))
if x.endswith('.jpg')
])
for imgfile in imgfiles:
img = cv2.imread(imgfile)
bboxes = predict(img)
write2file(imgfile, bboxes)
#img = predict2(img)
#cv2.imshow('img', img)
#ch = cv2.waitKey(0) & 0xff
#if ch == 27: #ord('q')
# break
#if ch == 27: #ord('q')
# break
fid.close()
coords = (pt[0], pt[1], pt[2], pt[3])
pred_num += 1
with open(filename, mode='a') as f:
f.write(
str(pred_num) + ' label: ' + label_name + ' score: ' +
str(score) + ' ' + ' || '.join(str(c)
for c in coords) + '\n')
j += 1
if __name__ == '__main__':
# load net
num_classes = len(VOC_CLASSES) + 1 # +1 background
net = build_ssd('test', 300, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# load data
testset = VOCDetection(args.voc_root, [('2007', 'test')], None,
AnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
testset,
BaseTransform(net.size, (104, 117, 123)),
thresh=args.visual_threshold)
write_voc_results_file(box_list, dataset)
do_python_eval(output_dir)
if __name__ == '__main__':
# load net
# num_classes = len(labelmap_lisa) + 1 # +1 for background
net = build_ssd('test', 300, 2) # initialize SSD
net.load_state_dict(torch.load(args.trained_model, 'cpu'))
net.eval()
print('Finished loading model!')
# load data
dataset = LISA(
args.lisa_root,
train=False,
transform=BaseTransform(300, dataset_mean),
)
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
dataset,
BaseTransform(net.size, dataset_mean),
args.top_k,
300,
thresh=args.confidence_threshold)
if args.dataset == 'VOC':
cfg = voc
else:
cfg = custom
# +1 for background
net = build_ssd(phase='test',
size=cfg['min_dim'],
num_classes=cfg['num_classes'])
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# Load data (TODO: add COCO)
if args.dataset == 'VOC':
dataset = VOCDetection(args.dataset_root, [(set_type)],
BaseTransform(cfg['min_dim'], MEANS),
VOCAnnotationTransform())
else:
dataset = CustomDetection(
root=args.dataset_root,
image_set=[(set_type)],
transform=BaseTransform(cfg['min_dim'], MEANS),
target_transform=CustomAnnotationTransform(train=False))
net = net.to(device)
# Evaluation
test_net(args.save_folder,
net,
args.cuda,
dataset,
