# train set
# -- Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = args.cuda
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# ship to cuda
if args.cuda:
im_data = im_data.cuda()
# train val test set
roidb_path = os.path.join(args.roidb_dir, args.dataset, args.imdb_name)
roidb = get_roidb(roidb_path)
roidb_val_path = os.path.join(args.roidb_dir, args.dataset,
args.valdb_name)
roidb_val = get_roidb(roidb_val_path)
roidb_test_path = os.path.join(args.roidb_dir, args.dataset,
args.testdb_name)
roidb_test = get_roidb(roidb_test_path)
logger.info('{:d} roidb entries'.format(len(roidb)))
dataset = roibatchLoader(roidb,
phase='train',
len_train=args.len_train,
length_support=args.length_support,
shot=args.shot)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
num_workers=args.num_workers,
shuffle=True)
dataset_val = roibatchLoader(roidb_val,
phase='val',
length_support=args.length_support,
shot=args.shot)
dataloader_val = torch.utils.data.DataLoader(dataset_val,
batch_size=args.batch_size,
num_workers=args.num_workers,
shuffle=False)
# train set
roidb_path = args.roidb_dir + "/" + args.dataset + "/" + args.imdb_name
roidb = get_roidb(roidb_path)
print('{:d} roidb entries'.format(len(roidb)))
model_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(model_dir):
os.makedirs(model_dir)
output_dir = args.output_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
num_workers=args.num_workers,
shuffle=True)
support_set_roidb = get_roidb(args.trimmed_support_set_data)
# initialize the network here.
if args.net == 'c3d':
tdcnn_demo = c3d_tdcnn_fewshot(pretrained=True)
elif args.net == 'res18':
tdcnn_demo = resnet_tdcnn(depth=18, pretrained=True)
elif args.net == 'res34':
tdcnn_demo = resnet_tdcnn(depth=34, pretrained=True)
elif args.net == 'res50':
fasterRCNN.train()
# Get database, and merge the class proto
imdb, roidb, ratio_list, ratio_index = combined_roidb(
args.dataset,
"trainvalStep{}".format(group),
classes=cfg.CLASSES[:now_cls_high],
ext=cfg.EXT,
data_extra=flatten(class_proto[:now_cls_low], distinct=True))
train_size = len(roidb)
sampler_batch = RcnnSampler(train_size, cfg.TRAIN.BATCH_SIZE)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
cfg.TRAIN.BATCH_SIZE,
now_cls_high,
training=True)
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=cfg.TRAIN.BATCH_SIZE,
sampler=sampler_batch,
num_workers=min(cfg.TRAIN.BATCH_SIZE * 2, os.cpu_count()))
tqdm.write('{:d} roidb entries'.format(len(roidb)))
iters_per_epoch = train_size // cfg.TRAIN.BATCH_SIZE
tqdm.write("===== Representation learning {} =====".format(group))
repr_labels = []
repr_features = []
repr_images = []
def evaluator(model, args, evl_rec=False):
fasterRCNN = model
np.random.seed(cfg.RNG_SEED)
if args.dataset == "pascal_voc":
args.imdb_name = "voc_2007_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'
]
elif args.dataset == "pascal_voc_0712":
args.imdb_name = "voc_2007_trainval+voc_2012_trainval"
args.imdbval_name = "voc_2007_test"
args.set_cfgs = [
'ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'
]
args.cfg_file = "cfgs/{}_ls.yml".format(
args.net) if args.large_scale else "cfgs/{}.yml".format(args.net)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
print('Using config:')
pprint.pprint(cfg)
cfg.TRAIN.USE_FLIPPED = False
imdb, roidb, ratio_list, ratio_index = combined_roidb(
args.imdbval_name, False)
imdb.competition_mode(on=True)
print('{:d} roidb entries'.format(len(roidb)))
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# ship to cuda
if args.cuda:
im_data = im_data.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
# make variable
im_data = Variable(im_data)
im_info = Variable(im_info)
num_boxes = Variable(num_boxes)
gt_boxes = Variable(gt_boxes)
if args.cuda:
cfg.CUDA = True
if args.cuda:
fasterRCNN.cuda()
start = time.time()
max_per_image = 100
vis = False
if vis:
thresh = 0.05
else:
thresh = 0.0
save_name = 'faster_rcnn_10'
num_images = len(imdb.image_index)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
output_dir = get_output_dir(imdb, save_name)
# These models are pytorch pretrained with RGB channel
rgb = True if args.net in ('res18', 'res34', 'inception') else False
dataset = roibatchLoader(roidb, ratio_list, ratio_index, 1, \
imdb.num_classes, training=False, normalize = False, rgb=rgb)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=False,
num_workers=0,
pin_memory=True)
data_iter = iter(dataloader)
_t = {'im_detect': time.time(), 'misc': time.time()}
det_file = os.path.join(output_dir, 'detections.pkl')
fasterRCNN.eval()
empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0))
if evl_rec:
true_postive, ground_truth = 0.0, 0.0
recall = AverageMeter()
for i in range(num_images):
data = next(data_iter)
im_data.data.resize_(data[0].size()).copy_(data[0])
im_info.data.resize_(data[1].size()).copy_(data[1])
gt_boxes.data.resize_(data[2].size()).copy_(data[2])
num_boxes.data.resize_(data[3].size()).copy_(data[3])
det_tic = time.time()
rois, cls_prob, bbox_pred, \
rpn_loss_cls, rpn_loss_box, \
RCNN_loss_cls, RCNN_loss_bbox, \
rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes)
scores = cls_prob.data
boxes = rois.data[:, :, 1:5]
if cfg.TEST.BBOX_REG:
# Apply bounding-box regression deltas
box_deltas = bbox_pred.data
if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:
# Optionally normalize targets by a precomputed mean and stdev
if args.class_agnostic:
box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
+ torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
box_deltas = box_deltas.view(1, -1, 4)
else:
box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
+ torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
box_deltas = box_deltas.view(1, -1, 4 * len(imdb.classes))
pred_boxes = bbox_transform_inv(boxes, box_deltas, 1)
pred_boxes = clip_boxes(pred_boxes, im_info.data, 1)
else:
# Simply repeat the boxes, once for each class
pred_boxes = np.tile(boxes, (1, scores.shape[1]))
pred_boxes /= data[1][0][2].item()
if evl_rec:
# evluate rpn recall only
boxes_per_img = boxes.squeeze().cpu().numpy() / data[1][0][2].item(
)
#pdb.set_trace()
#TP, GT = evaluate_final_recall(pred_boxes.squeeze().cpu().numpy(), i, imdb, thr=0.5)
TP, GT = evaluate_recall(boxes_per_img, i, imdb, thr=0.5)
recall.update(TP, GT)
sys.stdout.write('TP/GT: {}/{} | Recall: {:.3f} \r'.format(
TP, GT, recall.avg))
sys.stdout.flush()
continue
scores = scores.squeeze()
pred_boxes = pred_boxes.squeeze()
det_toc = time.time()
detect_time = det_toc - det_tic
misc_tic = time.time()
if vis:
im = cv2.imread(imdb.image_path_at(i))
im2show = np.copy(im)
for j in xrange(1, imdb.num_classes):
inds = torch.nonzero(scores[:, j] > thresh).view(-1)
# if there is det
if inds.numel() > 0:
cls_scores = scores[:, j][inds]
_, order = torch.sort(cls_scores, 0, True)
if args.class_agnostic:
cls_boxes = pred_boxes[inds, :]
else:
cls_boxes = pred_boxes[inds][:, j * 4:(j + 1) * 4]
cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)), 1)
# cls_dets = torch.cat((cls_boxes, cls_scores), 1)
cls_dets = cls_dets[order]
keep = nms(cls_dets, cfg.TEST.NMS)
cls_dets = cls_dets[keep.view(-1).long()]
if vis:
im2show = vis_detections(im2show, imdb.classes[j],
cls_dets.cpu().numpy(), 0.3)
all_boxes[j][i] = cls_dets.cpu().numpy()
else:
all_boxes[j][i] = empty_array
# Limit to max_per_image detections *over all classes*
if max_per_image > 0:
image_scores = np.hstack(
[all_boxes[j][i][:, -1] for j in xrange(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in xrange(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
misc_toc = time.time()
nms_time = misc_toc - misc_tic
sys.stdout.write('im_detect: {:d}/{:d} {:.3f}s {:.3f}s \r' \
.format(i + 1, num_images, detect_time, nms_time))
sys.stdout.flush()
if vis:
cv2.imwrite('result.png', im2show)
pdb.set_trace()
#cv2.imshow('test', im2show)
#cv2.waitKey(0)
if evl_rec:
print('\r\nThe average rpn recall is: {:.4f}'.format(recall.avg))
return recall.avg
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
mAP = imdb.evaluate_detections(all_boxes, output_dir)
end = time.time()
print("test time: %0.4fs" % (end - start))
return mAP
def train(self):
#参数
net='vgg16'
num_workers=1
lr_decay_step=5
large_scale=False
dataset='pascal_voc'
imdb_name = "voc_2007_trainval"
imdbval_name = "voc_2007_test"
set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '20']
save_dir='models'
batch_size=1
optimizer='sgd'
resume=False
checksession=1
checkepoch=1
checkpoint=0
mGPUs=False
use_tfboard=False
start_epoch=1
max_epochs=20
lr_decay_gamma=0.1
disp_interval=100
session=1
cfg.TRAIN.USE_FLIPPED = False
cfg.USE_GPU_NMS = True
cfg_file = "./mydetector/cfgs/{}_ls.yml".format(net) if large_scale else "./mydetector/cfgs/{}.yml".format(net)
if cfg_file is not None:
cfg_from_file(cfg_file)
if set_cfgs is not None:
cfg_from_list(set_cfgs)
print('Using config:')
pprint.pprint(cfg)
np.random.seed(cfg.RNG_SEED)
# torch.backends.cudnn.benchmark = True
# train set
# -- Note: Use validation set and disable the flipped to enable faster loading.
imdb, roidb, ratio_list, ratio_index = combined_roidb(imdb_name)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
output_dir = save_dir + "/" + net + "/" + dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch = sampler(train_size, batch_size)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, batch_size, \
imdb.num_classes, training=True)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
sampler=sampler_batch, num_workers=num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# ship to cuda
im_data = im_data.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
# make variable
im_data = Variable(im_data)
im_info = Variable(im_info)
num_boxes = Variable(num_boxes)
gt_boxes = Variable(gt_boxes)
# initilize the network here.
if net == 'vgg16':
fasterRCNN = vgg16(imdb.classes, pretrained=True, class_agnostic=False)
elif net == 'res101':
fasterRCNN = resnet(imdb.classes, 101, pretrained=True, class_agnostic=False)
elif net == 'res50':
fasterRCNN = resnet(imdb.classes, 50, pretrained=True, class_agnostic=False)
elif net == 'res152':
fasterRCNN = resnet(imdb.classes, 152, pretrained=True, class_agnostic=False)
else:
print("network is not defined")
pdb.set_trace()
fasterRCNN.create_architecture()
lr = cfg.TRAIN.LEARNING_RATE
lr = lr
# tr_momentum = cfg.TRAIN.MOMENTUM
# tr_momentum = args.momentum
params = []
for key, value in dict(fasterRCNN.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params': [value], 'lr': lr * (cfg.TRAIN.DOUBLE_BIAS + 1), \
'weight_decay': cfg.TRAIN.BIAS_DECAY and cfg.TRAIN.WEIGHT_DECAY or 0}]
else:
params += [{'params': [value], 'lr': lr, 'weight_decay': cfg.TRAIN.WEIGHT_DECAY}]
fasterRCNN.cuda()
if optimizer == "adam":
lr = lr * 0.1
optimizer = torch.optim.Adam(params)
elif optimizer == "sgd":
optimizer = torch.optim.SGD(params, momentum=cfg.TRAIN.MOMENTUM)
if resume:
load_name = os.path.join(output_dir,
'faster_rcnn_{}_{}_{}.pth'.format(checksession, checkepoch,
checkpoint))
print("loading checkpoint %s" % (load_name))
checkpoint = torch.load(load_name)
session = checkpoint['session']
start_epoch = checkpoint['epoch']
fasterRCNN.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr = optimizer.param_groups[0]['lr']
if 'pooling_mode' in checkpoint.keys():
cfg.POOLING_MODE = checkpoint['pooling_mode']
print("loaded checkpoint %s" % (load_name))
if mGPUs:
fasterRCNN = nn.DataParallel(fasterRCNN)
iters_per_epoch = int(train_size / batch_size)
if use_tfboard:
from tensorboardX import SummaryWriter
logger = SummaryWriter("logs")
for epoch in range(start_epoch, max_epochs + 1):
# setting to train mode
fasterRCNN.train()
loss_temp = 0
start = time.time()
if epoch % (lr_decay_step + 1) == 0:
adjust_learning_rate(optimizer, lr_decay_gamma)
lr *= lr_decay_gamma
data_iter = iter(dataloader)
for step in range(iters_per_epoch):
data = next(data_iter)
with torch.no_grad():
im_data.resize_(data[0].size()).copy_(data[0])
im_info.resize_(data[1].size()).copy_(data[1])
gt_boxes.resize_(data[2].size()).copy_(data[2])
num_boxes.resize_(data[3].size()).copy_(data[3])
fasterRCNN.zero_grad()
rois, cls_prob, bbox_pred, \
rpn_loss_cls, rpn_loss_box, \
RCNN_loss_cls, RCNN_loss_bbox, \
rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes)
loss = rpn_loss_cls.mean() + rpn_loss_box.mean() \
+ RCNN_loss_cls.mean() + RCNN_loss_bbox.mean()
loss_temp += loss.item()
# backward
optimizer.zero_grad()
loss.backward()
if net == "vgg16":
clip_gradient(fasterRCNN, 10.)
optimizer.step()
if step % disp_interval == 0:
end = time.time()
if step > 0:
loss_temp /= (disp_interval + 1)
if mGPUs:
loss_rpn_cls = rpn_loss_cls.mean().item()
loss_rpn_box = rpn_loss_box.mean().item()
loss_rcnn_cls = RCNN_loss_cls.mean().item()
loss_rcnn_box = RCNN_loss_bbox.mean().item()
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
else:
loss_rpn_cls = rpn_loss_cls.item()
loss_rpn_box = rpn_loss_box.item()
loss_rcnn_cls = RCNN_loss_cls.item()
loss_rcnn_box = RCNN_loss_bbox.item()
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
print("[session %d][epoch %2d][iter %4d/%4d] loss: %.4f, lr: %.2e" \
% (session, epoch, step, iters_per_epoch, loss_temp, lr))
print("\t\t\tfg/bg=(%d/%d), time cost: %f" % (fg_cnt, bg_cnt, end - start))
print("\t\t\trpn_cls: %.4f, rpn_box: %.4f, rcnn_cls: %.4f, rcnn_box %.4f" \
% (loss_rpn_cls, loss_rpn_box, loss_rcnn_cls, loss_rcnn_box))
if use_tfboard:
info = {
'loss': loss_temp,
'loss_rpn_cls': loss_rpn_cls,
'loss_rpn_box': loss_rpn_box,
'loss_rcnn_cls': loss_rcnn_cls,
'loss_rcnn_box': loss_rcnn_box
}
logger.add_scalars("logs_s_{}/losses".format(session), info,
(epoch - 1) * iters_per_epoch + step)
loss_temp = 0
start = time.time()
save_name = os.path.join(output_dir, 'faster_rcnn_{}_{}_{}.pth'.format(session, epoch, step))
save_checkpoint({
'session': session,
'epoch': epoch + 1,
'model': fasterRCNN.module.state_dict() if mGPUs else fasterRCNN.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.POOLING_MODE,
'class_agnostic': False,
}, save_name)
print('save model: {}'.format(save_name))
args.net, args.dataset)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg.USE_GPU_NMS = args.cuda
cfg.CUDA = args.cuda
print('Using config:')
pprint.pprint(cfg)
roidb_path = args.roidb_dir + "/" + args.dataset + "/" + args.imdbval_name
roidb = get_roidb(roidb_path)
dataset = roibatchLoader(roidb, phase='test')
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
num_workers=args.num_workers,
shuffle=False)
num_videos = len(dataset)
args.num_videos = num_videos
print('{:d} roidb entries'.format(num_videos))
model_dir = args.load_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(model_dir):
raise Exception(
'There is no input directory for loading network from ' +
model_dir)
output_dir = args.output_dir + "/" + args.net + "/" + args.dataset
if args.active_learning:
num_images_ws = len(imdb_ws.image_index)
if args.imdbval_name != "Stanford_Dog":
num_images_n = len(imdb_n.image_index)
all_boxes = [[[] for _ in range(num_images_s)]
for _ in range(imdb_s.num_classes)]
if args.active_learning:
all_boxes_ws = [[[] for _ in range(num_images_ws)]
for _ in range(imdb_ws.num_classes)]
if args.imdbval_name != "Stanford_Dog":
all_boxes_n = [[[] for _ in range(num_images_n)]
for _ in range(imdb_n.num_classes)]
output_dir = get_output_dir(imdb_s, save_name)
dataset_s = roibatchLoader(roidb_s, ratio_list_s, ratio_index_s, 1, \
imdb_s.num_classes, is_ws = False, training=False, normalize = False)
dataloader_s = torch.utils.data.DataLoader(
dataset_s,
batch_size=1,
shuffle=False,
num_workers=0,
)
if args.active_learning:
dataset_ws = roibatchLoader(roidb_ws, ratio_list_ws, ratio_index_ws, 1, \
imdb_ws.num_classes, is_ws = True, training=False, normalize = False)
dataloader_ws = torch.utils.data.DataLoader(dataset_ws,
batch_size=1,
shuffle=False,
num_workers=0,
pin_memory=True)
if args.imdbval_name != "Stanford_Dog":
os.path.join(
input_dir, 'meta_type_{}'.format(args.meta_type),
str(args.phase) + '_shots_' + str(args.shots) +
'_mean_class_attentions.pkl'), 'rb'))
num_images = len(imdb.image_index)
all_boxes = [[[] for _ in range(num_images)] for _ in range(num_cls)]
output_dir = os.path.join(input_dir, args.dataset)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
args.batch_size,
num_cls,
training=False,
normalize=False)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=0,
pin_memory=True)
data_iter = iter(dataloader)
_t = {'im_detect': time.time(), 'misc': time.time()}
det_file = os.path.join(output_dir, 'detections.pkl')
with torch.no_grad():
if torch.cuda.is_available() and not args.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
# train set
# -- Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = False
cfg.USE_GPU_NMS = args.cuda
'''Dataloader for the training'''
imdb_train, roidb_train, ratio_list_train, ratio_index_train = combined_roidb(
args.imdb_name)
train_size = len(roidb_train)
print('{:d} roidb entries'.format(len(roidb_train)))
sampler_batch = sampler(train_size, args.batch_size)
dataset_train = roibatchLoader(roidb_train, ratio_list_train, ratio_index_train, args.batch_size, \
imdb_train.num_classes, training=True)
dataloader_train = torch.utils.data.DataLoader(
dataset_train,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers)
'''Dataloader for the validation/testing'''
imdb_val, roidb_val, ratio_list_val, ratio_index_val = combined_roidb(
args.imdbval_name)
val_size = len(roidb_val)
print('{:d} roidb entries'.format(len(roidb_train)))
sampler_batch = sampler(val_size, args.batch_size)
dataset_val = roibatchLoader(roidb_val, ratio_list_val, ratio_index_val, args.batch_size, \
imdb_val.num_classes, training=True)
dataloader_val = torch.utils.data.DataLoader(dataset_val,
batch_size=args.batch_size,
train_size_s = len(roidb_s)
train_size_ws = len(roidb_ws)
# train_size = number of images
print('{:d} strong roidb entries'.format(len(roidb_s)))
print('{:d} weak roidb entries'.format(len(roidb_ws)))
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch_s = sampler(train_size_s, args.batch_size)
sampler_batch_ws = sampler(train_size_ws, args.batch_size)
dataset_s = roibatchLoader(roidb_s, ratio_list_s, ratio_index_s, args.batch_size, \
imdb_s.num_classes, is_ws= False, training=True)
dataloader_s = torch.utils.data.DataLoader(dataset_s, batch_size=args.batch_size,
sampler=sampler_batch_s, num_workers=args.num_workers)
dataset_ws = roibatchLoader(roidb_ws, ratio_list_ws, ratio_index_ws, args.batch_size,
imdb_ws.num_classes, is_ws = True, training=True)
dataloader_ws = torch.utils.data.DataLoader(dataset_ws, batch_size=args.batch_size,
sampler=sampler_batch_ws, num_workers=args.num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
im_label = torch.FloatTensor(1)
# train set
# -- Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = args.cuda
# create dataloader
imdb, roidb, ratio_list, ratio_index, query = combined_roidb(
args.imdb_name, True, seen=args.seen)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
sampler_batch = sampler(train_size, args.batch_size)
# cfg.train_categories = imdb.list
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
query,
args.batch_size,
imdb.num_classes,
training=True,
m_imdb=imdb)
assert dataset.list == imdb.list, (dataset.list, imdb.list)
assert dataset.list_ind == imdb.inverse_list, (dataset.list, imdb.list)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers)
# create output directory
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
os.makedirs(output_dir)
# -------------------------
# SOURCE DATA
# -------------------------
imdb_s, roidb_s, ratio_list_s, ratio_index_s = combined_roidb(
args.imdb_name)
train_size_s = len(roidb_s)
print('{:d} roidb entries'.format(len(roidb_s)))
sampler_batch_s = sampler(train_size_s, args.batch_size)
dataset_s = roibatchLoader(roidb_s,
ratio_list_s,
ratio_index_s,
args.batch_size,
imdb_s.num_classes,
training=True)
dataloader_s = torch.utils.data.DataLoader(dataset_s,
batch_size=args.batch_size,
sampler=sampler_batch_s,
num_workers=args.num_workers)
# -------------------------
# TARGET DATA
# -------------------------
imdb_t, roidb_t, ratio_list_t, ratio_index_t = combined_roidb(
args.imdbval_name)
train_size_t = len(roidb_t)
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name)
cfg.TRAIN.USE_FLIPPED = False
imdbval, roidbval, ratio_listval, ratio_indexval = combined_roidb(args.imdbval_name)
print('{:d} roidb training entries'.format(len(roidb)))
print('{:d} roidb validation entries'.format(len(roidbval)))
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
dataset = {}
dataset = {'train': roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, args.RGB, args.NIR, args.DEPTH, training=True),
'val': roibatchLoader(roidbval, ratio_listval, ratio_indexval, args.batch_size, \
imdbval.num_classes, args.RGB, args.NIR, args.DEPTH, training=True, normalize = False)}
set_size = {}
'''set_size = {'train': len(roidb),
'val': len(roidbval)}'''
set_size = {phase: len(dataset[phase]) for phase in ['train','val']}
train_sampler_batch = sampler(set_size['train'], args.batch_size)
dataloader = {}
dataloader={'train': torch.utils.data.DataLoader(dataset['train'], batch_size=args.batch_size,
sampler=train_sampler_batch, num_workers=args.num_workers),
'val': torch.utils.data.DataLoader(dataset['val'], batch_size=args.batch_size,
shuffle=False, num_workers=0,
pin_memory=True)}
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = args.cuda
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name)
test_imdb, test_roidb, test_ratio_list, test_ratio_index = combined_roidb(
args.imdbval_name, False)
test_imdb.competition_mode(on=True)
train_size = len(roidb)
print("{:d} roidb entries".format(len(roidb)))
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
args.batch_size,
imdb.num_classes,
training=True)
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers,
)
test_dataset = roibatchLoader(
test_roidb,
test_ratio_list,
test_ratio_index,
1,
max_per_image = 100
vis = args.vis
if vis:
thresh = 0.05
else:
thresh = 0.00
save_name = 'faster_rcnn_'+str(args.checksession)
num_images = len(imdb.image_index)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
output_dir = get_output_dir(imdb, save_name)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, args.RGB, args.NIR, args.DEPTH, training=False, normalize = False)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size,
shuffle=False, num_workers=0,
pin_memory=True)
data_iter = iter(dataloader)
_t = {'im_detect': time.time(), 'misc': time.time()}
det_file = os.path.join(output_dir, 'detections_'+str(args.checksession)+'.pkl')
fasterRCNN.eval()
empty_array = np.transpose(np.array([[],[],[],[],[]]), (1,0))
InferTime = np.zeros(num_images)
for i in range(num_images):
data = next(data_iter)
# target dataset
imdb_t, roidb_t, ratio_list_t, ratio_index_t = combined_roidb(
args.imdb_name_target)
train_size_t = len(roidb_t)
print('{:d} source roidb entries'.format(len(roidb)))
print('{:d} target roidb entries'.format(len(roidb_t)))
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch = sampler(train_size, args.batch_size)
sampler_batch_t = sampler(train_size_t, args.batch_size)
dataset_s = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True, target=False)
dataloader_s = torch.utils.data.DataLoader(dataset_s,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers)
dataset_t = roibatchLoader(roidb_t, ratio_list_t, ratio_index_t, args.batch_size, \
imdb.num_classes, training=True, target=True)
dataloader_t = torch.utils.data.DataLoader(dataset_t,
batch_size=args.batch_size,
sampler=sampler_batch_t,
num_workers=args.num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
s = torch.FloatTensor(1)
t = torch.FloatTensor(1)
unsup_ratio_index = np.asarray(unsup_ratio_index)
unsup_train_size = unsup_ratio_list.shape[0]
print('Remaining unsupervised {:d} roidb entries. Done!'.format(unsup_train_size))
#pdb.set_trace()
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# two supervised datum streams
sup_sampler_batch_1 = sampler(train_size, args.batch_size)
sup_sampler_batch_2 = sampler(train_size, args.batch_size)
dataset = roibatchLoader(ori_roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True)
sup_dataloader_1 = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, sampler=sup_sampler_batch_1, num_workers=args.num_workers)
sup_dataloader_2 = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, sampler=sup_sampler_batch_2, num_workers=args.num_workers)
# one unsupervised datum stream
unsup_sampler_batch = sampler(unsup_train_size, args.batch_size)
unsup_dataset = roibatchLoader(ori_roidb, unsup_ratio_list, unsup_ratio_index, \
args.batch_size, imdb.num_classes, training=True)
unsup_dataloader = torch.utils.data.DataLoader(unsup_dataset, batch_size=args.batch_size, sampler=unsup_sampler_batch, num_workers=args.num_workers)
#pdb.set_trace()
cfg.USE_GPU_NMS = args.cuda
imdb_cityscapes, roidb_cityscapes, ratio_list_cityscapes, ratio_index_cityscapes = combined_roidb(
'fullycityscapes_train')
train_size_cityscapes = len(roidb_cityscapes)
print('{:d} roidb entries in pretrain dataset'.format(
len(roidb_cityscapes)))
output_dir = args.save_dir + "/" + args.net + "/" + 'foggycityscapes'
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch_cityscapes = sampler(train_size_cityscapes, args.batch_size)
dataset_cityscapes = roibatchLoader(roidb_cityscapes, ratio_list_cityscapes, ratio_index_cityscapes, args.batch_size, \
imdb_cityscapes.num_classes, training=True)
dataloader_cityscapes = torch.utils.data.DataLoader(
dataset_cityscapes,
batch_size=args.batch_size,
sampler=sampler_batch_cityscapes,
num_workers=args.num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# ship to cuda
if args.cuda:
def test_model_while_training(fasterRCNN, args):
# args = parse_args()
# args = set_dataset_args(args, test=True)
# np.random.seed(cfg.RNG_SEED)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg.TRAIN.USE_FLIPPED = False
# args.imdbval_name = 'clipart_test'
imdb, roidb, ratio_list, ratio_index = combined_roidb(
args.imdbval_name_target, False)
# breakpoint()
imdb.competition_mode(on=True)
print('{:d} roidb entries'.format(len(roidb)))
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
if args.cuda:
im_data = im_data.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
# make variable
im_data = Variable(im_data)
im_info = Variable(im_info)
num_boxes = Variable(num_boxes)
gt_boxes = Variable(gt_boxes)
if args.cuda:
cfg.CUDA = True
# if args.cuda:
# fasterRCNN.cuda()
start = time.time()
max_per_image = 100
thresh = 0.0
save_name = args.load_name.split('/')[-1]
num_images = len(imdb.image_index)
all_boxes = [[[] for _ in range(num_images)]
for _ in range(imdb.num_classes)]
output_dir = get_output_dir(imdb, save_name)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, 1, \
imdb.num_classes, training=False, normalize = False, path_return=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=False,
num_workers=0,
pin_memory=True)
data_iter = iter(dataloader)
_t = {'im_detect': time.time(), 'misc': time.time()}
det_file = os.path.join(output_dir, 'detections.pkl')
fasterRCNN.eval()
empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0))
for i in range(num_images):
data = next(data_iter)
im_data.data.resize_(data[0].size()).copy_(data[0])
#print(data[0].size())
im_info.data.resize_(data[1].size()).copy_(data[1])
gt_boxes.data.resize_(data[2].size()).copy_(data[2])
num_boxes.data.resize_(data[3].size()).copy_(data[3])
det_tic = time.time()
rois, cls_prob, bbox_pred, \
rpn_loss_cls, rpn_loss_box, \
RCNN_loss_cls, RCNN_loss_bbox, \
rois_label, _, _ = fasterRCNN(im_data, im_info, gt_boxes, num_boxes)
scores = cls_prob.data
boxes = rois.data[:, :, 1:5]
# d_pred = d_pred.data
path = data[4]
if cfg.TEST.BBOX_REG:
# Apply bounding-box regression deltas
box_deltas = bbox_pred.data
if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:
# Optionally normalize targets by a precomputed mean and stdev
if args.class_agnostic:
box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
+ torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
box_deltas = box_deltas.view(1, -1, 4)
else:
box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
+ torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
box_deltas = box_deltas.view(1, -1, 4 * len(imdb.classes))
pred_boxes = bbox_transform_inv(boxes, box_deltas, 1)
pred_boxes = clip_boxes(pred_boxes, im_info.data, 1)
else:
# Simply repeat the boxes, once for each class
pred_boxes = np.tile(boxes, (1, scores.shape[1]))
pred_boxes /= data[1][0][2].item()
scores = scores.squeeze()
pred_boxes = pred_boxes.squeeze()
det_toc = time.time()
detect_time = det_toc - det_tic
misc_tic = time.time()
for j in range(1, imdb.num_classes):
inds = torch.nonzero(scores[:, j] > thresh).view(-1)
# if there is det
if inds.numel() > 0:
cls_scores = scores[:, j][inds]
_, order = torch.sort(cls_scores, 0, True)
if args.class_agnostic:
cls_boxes = pred_boxes[inds, :]
else:
cls_boxes = pred_boxes[inds][:, j * 4:(j + 1) * 4]
cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)), 1)
# cls_dets = torch.cat((cls_boxes, cls_scores), 1)
cls_dets = cls_dets[order]
keep = nms(cls_dets, cfg.TEST.NMS)
cls_dets = cls_dets[keep.view(-1).long()]
all_boxes[j][i] = cls_dets.cpu().numpy()
else:
all_boxes[j][i] = empty_array
# Limit to max_per_image detections *over all classes*
if max_per_image > 0:
image_scores = np.hstack(
[all_boxes[j][i][:, -1] for j in range(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in range(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
# misc_toc = time.time()
sys.stdout.write('im_detect: {:d}/{:d} {:.3f}s \r' \
.format(i + 1, num_images, detect_time))
sys.stdout.flush()
imdb.evaluate_detections(all_boxes, output_dir)
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
print('Using config:')
pprint.pprint(cfg)
# Load dataset
cfg.TRAIN.USE_FLIPPED = False
imdb_vu, roidb_vu, ratio_list_vu, ratio_index_vu, query_vu = combined_roidb(
args.imdbval_name, False, seen=args.seen)
imdb_vu.competition_mode(on=True)
dataset_vu = roibatchLoader(roidb_vu,
ratio_list_vu,
ratio_index_vu,
query_vu,
1,
imdb_vu.num_classes,
training=False,
seen=args.seen)
# initilize the network here.
if args.net == 'vgg16':
fasterRCNN = vgg16(imdb_vu.classes,
pretrained=False,
class_agnostic=args.class_agnostic)
elif args.net == 'res101':
fasterRCNN = resnet(imdb_vu.classes,
101,
pretrained=False,
class_agnostic=args.class_agnostic)
elif args.net == 'res50':
max_per_image = 100
vis = args.vis
if vis:
thresh = 0.05
else:
thresh = 0.0
save_name = 'faster_rcnn_10'
num_images = len(imdb.image_index)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
output_dir = get_output_dir(imdb, save_name)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=False, normalize = False)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size,
shuffle=False, num_workers=0,
pin_memory=True)
data_iter = iter(dataloader)
_t = {'im_detect': time.time(), 'misc': time.time()}
det_file = os.path.join(output_dir, 'detections.pkl')
fasterRCNN.eval()
empty_array = np.transpose(np.array([[],[],[],[],[]]), (1,0))
for i in range(num_images):
data = next(data_iter)
im_data.data.resize_(data[0].size()).copy_(data[0])
# dataset
imdb, roidb, ratio_list, ratio_index, imdb_test, roidb_test, ratio_list_test, ratio_index_test = combined_roidb_meta(
args.imdb_name)
base_train_size = len(roidb)
meta_train_size = len(roidb_test)
iters_per_base = int(base_train_size / args.batch_size)
iters_per_meta = int(meta_train_size / args.batch_size)
print('{:d} roidb entries'.format(len(roidb)))
# base data
sampler_batch = sampler(base_train_size, args.batch_size)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
args.batch_size,
imdb.num_classes,
training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers,
pin_memory=True)
# meta data
sampler_batch_meta = sampler(meta_train_size, args.batch_size)
dataset_meta = roibatchLoader(roidb_test,
ratio_list_test,
ratio_index_test,
args.batch_size,
imdb_test.num_classes,
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name)
train_size = len(roidb)
imdb_classes = imdb.classes
print('{:d} roidb frame pairs'.format(train_size))
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if args.use_det:
vid_sampler_batch = sampler(vid_train_size, args.batch_size)
det_sampler_batch = sampler(det_train_size, args.batch_size)
# Build VID and DET datasets
vid_dataset = roibatchLoader(vid_roidb,vid_ratio_list, vid_ratio_index,
args.batch_size, vid_imdb.num_classes, training=True)
det_dataset = roibatchLoader(det_roidb,det_ratio_list, det_ratio_index,
args.batch_size, det_imdb.num_classes, training=True)
vid_dataloader = torch.utils.data.DataLoader(vid_dataset,
batch_size=args.batch_size,
sampler=vid_sampler_batch,
num_workers=args.num_workers)
det_dataloader = torch.utils.data.DataLoader(det_dataset,
batch_size=args.batch_size,
sampler=det_sampler_batch,
num_workers=args.num_workers)
else:
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb,ratio_list, ratio_index, args.batch_size, imdb.num_classes, training=True)
def train(args):
file_utils.rm_all_dir(dir='./train/cache/') # clean cache
dataset_name = "voc_2007_trainval"
args.set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '20']
args.cfg_file = "cfgs/{}_ls.yml".format(args.backbone) if args.large_scale else "cfgs/{}.yml".format(args.backbone)
if args.cfg_file is not None: cfg_from_file(args.cfg_file)
if args.set_cfgs is not None: cfg_from_list(args.set_cfgs)
np.random.seed(cfg.RNG_SEED)
cfg.TRAIN.USE_FLIPPED = opt.BUBBLE_TRAIN_FLIP
cfg.USE_GPU_NMS = opt.cuda
_, _, _, name_lists = file_utils.get_files('./train/images/')
file_utils.makeTrainIndex(names=name_lists, save_to='./train/trainval.txt')
imdb, roidb, ratio_list, ratio_index = combined_roidb(dataset_name)
train_size = len(roidb)
print('TRAIN IMAGE NUM: {:d}'.format(len(roidb)))
file_utils.mkdir(dir=[args.save_models])
sampler_batch = sampler(train_size, args.batch)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch,\
imdb.num_classes, training=True)
dataloader = DataLoader(dataset, batch_size=args.batch,
sampler=sampler_batch, num_workers=args.num_workers)
im_data = Variable(torch.FloatTensor(1).cuda())
im_info = Variable(torch.FloatTensor(1).cuda())
num_boxes = Variable(torch.LongTensor(1).cuda())
gt_boxes = Variable(torch.FloatTensor(1).cuda())
fasterRCNN = resnet(imdb.classes, 101, pretrained=True, class_agnostic=False)
fasterRCNN.create_architecture()
lr = args.lr
params = []
for key, value in dict(fasterRCNN.named_parameters()).items():
if value.requires_grad:
if 'bias' in key:
params += [{'params': [value], 'lr': lr * (cfg.TRAIN.DOUBLE_BIAS + 1),\
'weight_decay': cfg.TRAIN.BIAS_DECAY and cfg.TRAIN.WEIGHT_DECAY or 0}]
else:
params += [{'params': [value], 'lr': lr, 'weight_decay': cfg.TRAIN.WEIGHT_DECAY}]
if args.optimizer == "adam":
lr = lr * 0.1
optimizer = torch.optim.Adam(params)
elif args.optimizer == "sgd":
optimizer = torch.optim.SGD(params, momentum=cfg.TRAIN.MOMENTUM)
if opt.cuda:
cfg.CUDA = True
fasterRCNN.cuda()
if args.resume:
load_name = os.path.join(args.save_models,
'Speech-Bubble-Detector-{}-{}-{}.pth'.format(args.backbone, args.resume_epoch, args.resume_batch))
checkpoint = torch.load(load_name)
args.session = checkpoint['session']
args.start_epoch = checkpoint['epoch']
fasterRCNN.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr = optimizer.param_groups[0]['lr']
if 'pooling_mode' in checkpoint.keys():
cfg.POOLING_MODE = checkpoint['pooling_mode']
if args.multi_gpus:
fasterRCNN = nn.DataParallel(fasterRCNN)
iters_per_epoch = int(train_size / args.batch)
if args.use_tfboard:
from tensorboardX import SummaryWriter
logger = SummaryWriter("logs")
args.max_epochs = args.epoch
for epoch in range(1, args.epoch + 1):
fasterRCNN.train()
loss_temp = 0
start = time.time()
if epoch % (args.lr_decay_step + 1) == 0:
adjust_learning_rate(optimizer, args.lr_decay_gamma)
lr *= args.lr_decay_gamma
data_iter = iter(dataloader)
for step in range(iters_per_epoch):
data = next(data_iter)
im_data.data.resize_(data[0].size()).copy_(data[0])
im_info.data.resize_(data[1].size()).copy_(data[1])
gt_boxes.data.resize_(data[2].size()).copy_(data[2])
num_boxes.data.resize_(data[3].size()).copy_(data[3])
fasterRCNN.zero_grad()
rois, cls_prob, bbox_pred, \
rpn_loss_cls, rpn_loss_box, \
RCNN_loss_cls, RCNN_loss_bbox, \
rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes)
loss = rpn_loss_cls.mean() + rpn_loss_box.mean() \
+ RCNN_loss_cls.mean() + RCNN_loss_bbox.mean()
loss_temp += loss.item()
# backward
optimizer.zero_grad()
loss.backward()
if args.backbone == "vgg16":
clip_gradient(fasterRCNN, 10.)
optimizer.step()
if step % args.display_interval == 0:
end = time.time()
if step > 0:
loss_temp /= (args.display_interval + 1)
if args.multi_gpus:
loss_rpn_cls = rpn_loss_cls.mean().item()
loss_rpn_box = rpn_loss_box.mean().item()
loss_rcnn_cls = RCNN_loss_cls.mean().item()
loss_rcnn_box = RCNN_loss_bbox.mean().item()
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
else:
loss_rpn_cls = rpn_loss_cls.item()
loss_rpn_box = rpn_loss_box.item()
loss_rcnn_cls = RCNN_loss_cls.item()
loss_rcnn_box = RCNN_loss_bbox.item()
fg_cnt = torch.sum(rois_label.data.ne(0))
bg_cnt = rois_label.data.numel() - fg_cnt
print("[epoch %d][iter %d/%d] loss: %.4f, lr: %.2e" \
% (epoch, step, iters_per_epoch, loss_temp, lr))
print("\t\t\tfg/bg=(%d/%d), time cost: %f" % (fg_cnt, bg_cnt, end - start))
print("\t\t\trpn_cls: %.4f, rpn_box: %.4f, rcnn_cls: %.4f, rcnn_box %.4f" \
% (loss_rpn_cls, loss_rpn_box, loss_rcnn_cls, loss_rcnn_box))
if args.use_tfboard:
info = {
'loss': loss_temp,
'loss_rpn_cls': loss_rpn_cls,
'loss_rpn_box': loss_rpn_box,
'loss_rcnn_cls': loss_rcnn_cls,
'loss_rcnn_box': loss_rcnn_box
}
logger.add_scalars("logs_s_{}/losses".format(args.session), info,
(epoch - 1) * iters_per_epoch + step)
loss_temp = 0
start = time.time()
save_name = args.save_models + args.backbone + '-' + str(epoch) + '.pth'
save_checkpoint({
'session': args.session,
'epoch': epoch + 1,
'model': fasterRCNN.module.state_dict() if args.multi_gpus else fasterRCNN.state_dict(),
'optimizer': optimizer.state_dict(),
'pooling_mode': cfg.POOLING_MODE,
'class_agnostic': False,
}, save_name)
print('save model: {}'.format(save_name))
if args.use_tfboard:
logger.close()
tgt_imdb_val, tgt_roidb_val, tgt_ratio_list_val, tgt_ratio_index_val = combined_roidb(
args.imdbval_tgt_name, False)
tgt_val_size = len(tgt_roidb_val)
print()
print('{:d} roidb entries for source domain'.format(len(roidb)))
print('{:d} roidb entries for target domain'.format(len(tgt_roidb)))
output_dir = args.save_dir + "/" + args.net + "/" + args.model_config
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# define the dataloader for source domain
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=sampler_batch,
num_workers=args.num_workers)
dataset_val = roibatchLoader(roidb_val, ratio_list_val, ratio_index_val, 1, \
imdb_val.num_classes, training=False, normalize=False)
dataloader_val = torch.utils.data.DataLoader(dataset_val,
batch_size=1,
shuffle=False,
num_workers=0,
pin_memory=True)
# define the dataloader for target domain
tgt_sampler_batch = sampler(tgt_train_size, args.batch_size)
cfg_from_file(hyp_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
val_imdb, val_roidb, val_ratio_list, val_ratio_index = combined_roidb(
args.val_imdb_name, training=False, USE_FLIPPED=False)
val_imdb.competition_mode(on=True)
val_size = len(val_roidb)
print('{:d} roidb entries for validation'.format(val_size))
val_dataset = roibatchLoader(val_roidb,
val_ratio_list,
val_ratio_index,
1,
val_imdb.num_classes,
training=False,
normalize=False)
val_dataloader = torch.utils.data.DataLoader(val_dataset,
batch_size=1,
shuffle=False,
num_workers=0,
pin_memory=True)
model_dir = args.load_dir + "/" + args.net + "/" + args.dataset
if not os.path.exists(model_dir):
raise Exception(
'There is no input directory for loading network from ' +
model_dir)
maps = []
unlabel_train_size = len(unlabel_roidb)
print('{:d} roidb entries'.format(len(roidb)))
print('{:d} roidb entries'.format(len(unlabel_roidb)))
output_dir = os.path.join(args.save_dir, args.arch, args.net, args.dataset)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
supervised_batch_size = 1
unsupervised_batch_size = args.batch_size - supervised_batch_size
sampler_batch = sampler(train_size, supervised_batch_size)
dataset = roibatchLoader(roidb,
ratio_list,
ratio_index,
supervised_batch_size,
imdb.num_classes,
training=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=supervised_batch_size,
sampler=sampler_batch,
num_workers=args.num_workers,
drop_last=True)
unlabel_sampler_batch = sampler(unlabel_train_size,
unsupervised_batch_size)
unlabel_dataset = roibatchLoader(unlabel_roidb,
unlabel_ratio_list,
unlabel_ratio_index,
unsupervised_batch_size,
imdb.num_classes,
max_per_image = 100
vis = args.vis
if vis:
thresh = 0.05
else:
thresh = 0.0
save_name = 'faster_rcnn_10'
num_images = len(imdb.image_index)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
output_dir = get_output_dir(imdb, save_name)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, 1, \
imdb.num_classes, training=False, normalize = False)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=False,
num_workers=0,
pin_memory=True)
data_iter = iter(dataloader)
_t = {'im_detect': time.time(), 'misc': time.time()}
det_file = os.path.join(output_dir, 'detections.pkl')
fasterRCNN.eval()
empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0))
for i in range(num_images):
# ratio_list.clamp_(0.5, 2)
# resort aspect ratio
print('{:d} roidb entries'.format(len(roidb)))
if args.save_dir is "local":
output_dir = "models/" + args.net
else:
output_dir = "/srv/share/jyang375/models/" + args.net
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb, args.batch_size, imdb.num_classes, training=True, normalize = False)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size,
sampler=sampler_batch, num_workers=args.nworker)
# dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, sampler=None, num_workers=args.nworker)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# ship to cuda
if args.cuda > 0:
im_data = im_data.cuda()
# train set
# -- Note: Use validation set and disable the flipped to enable faster loading.
cfg.TRAIN.USE_FLIPPED = True
cfg.USE_GPU_NMS = args.cuda
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name)
train_size = len(roidb)
print('{:d} roidb entries'.format(len(roidb)))
output_dir = os.path.join(args.save_dir, args.arch, args.net, args.dataset)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
sampler_batch = sampler(train_size, args.batch_size)
dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size,
sampler=sampler_batch, num_workers=args.num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
# ship to cuda
if args.cuda:
im_data = im_data.cuda()
im_info = im_info.cuda()
doc['k_fold'] = k_fold
with open("cfgs/train.yml", 'w', encoding="utf-8") as f:
yaml.dump(doc, f)
print('fold_' + str(k_fold) + ' is running...')
imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdb_name, training=True, USE_FLIPPED=True)
val_imdb, val_roidb, val_ratio_list, val_ratio_index = combined_roidb(args.val_imdb_name, training=False,
USE_FLIPPED=False)
train_size = len(roidb)
val_size = len(val_roidb)
print('{:d} roidb entries for training'.format(train_size))
print('{:d} roidb entries for validation'.format(val_size))
sampler_batch = sampler(train_size, args.batch_size)
train_dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, imdb.num_classes, training=True)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, sampler=sampler_batch,
num_workers=args.num_workers)
val_dataset = roibatchLoader(val_roidb, val_ratio_list, val_ratio_index, 1, val_imdb.num_classes,
training=False, normalize=False)
val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False,
num_workers=0, pin_memory=True)
output_dir = args.save_dir + "/" + args.net + "/" + args.dataset + "/" + f"_fold_{k_fold}"
print(f'output_dir is {output_dir}')
os.makedirs(output_dir, exist_ok=True)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
