def train(self):
"""
training process
"""
# set model in training mode
self.model.train()
self.losses = []
step_index = 0
# start with a trained model if exists
if self.pretrained_model:
start = int(self.pretrained_model.split('/')[-1])
else:
start = 0
# start training
start_time = time.time()
batch_iterator = iter(self.train_loader)
for i in range(start, self.num_iterations):
if i in self.sched_milestones:
step_index += 1
self.adjust_learning_rate(optimizer=self.optimizer,
gamma=self.sched_gamma,
step=step_index)
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(self.train_loader)
images, targets = next(batch_iterator)
images = to_var(images, self.use_gpu)
targets = [to_var(target, self.use_gpu) for target in targets]
class_loss, loc_loss, loss = self.model_step(images, targets)
# print out loss log
if (i + 1) % self.loss_log_step == 0:
self.print_loss_log(start_time=start_time,
cur_iter=i,
class_loss=class_loss,
loc_loss=loc_loss,
loss=loss)
self.losses.append([i, class_loss, loc_loss, loss])
# save model
if (i + 1) % self.model_save_step == 0:
self.save_model(i)
self.save_model(i)
# print losses
print('\n--Losses--')
for i, class_loss, loc_loss, loss in self.losses:
print(i, "{:.4f} {:.4f} {:.4f}".format(class_loss.item(),
loc_loss.item(),
loss.item()))
def eval(self, data_loader):
"""
Returns the count of top 1 and top 5 predictions
"""
# set the model to eval mode
self.model.eval()
top_1_correct = 0
top_5_correct = 0
total = 0
with torch.no_grad():
for images, labels in data_loader:
images = to_var(images, self.use_gpu)
labels = to_var(torch.LongTensor(labels), self.use_gpu)
output = self.model(images)
total += labels.size()[0]
# top 1
# get the max for each instance in the batch
_, top_1_output = torch.max(output.data, dim=1)
top_1_correct += torch.sum(
torch.eq(labels.squeeze(), top_1_output))
# top 5
_, top_5_output = torch.topk(output.data, k=5, dim=1)
for i, label in enumerate(labels):
if label in top_5_output[i]:
top_5_correct += 1
return top_1_correct.item(), top_5_correct, total
def forward(self, class_preds, class_targets, loc_preds, loc_targets,
anchors):
b, num_anchors, _ = loc_preds.shape
class_m = torch.LongTensor(b, num_anchors)
loc_m = torch.Tensor(b, num_anchors, 4)
class_m = to_var(class_m, self.use_gpu)
loc_m = to_var(loc_m, self.use_gpu)
for i in range(b):
class_m[i], loc_m[i] = match(threshold=self.threshold,
class_target=class_targets[i],
loc_target=loc_targets[i],
anchors=anchors.data,
variances=self.variance)
class_targets = class_m
loc_targets = loc_m
pos = class_targets > 0
# loc loss
pos_mask = pos.unsqueeze(pos.dim()).expand_as(loc_preds)
loc_loss = F.smooth_l1_loss(loc_preds[pos_mask].view(-1, 4),
loc_targets[pos_mask].view(-1, 4),
size_average=False)
# compute max conf across batch for hard negative mining
batch_conf = class_preds.view(-1, self.class_count)
class_loss = self.log_sum_exp(batch_conf) - batch_conf.gather(
1, class_targets.view(-1, 1))
# hard negative mining
class_loss = class_loss.view(b, -1)
class_loss[pos] = 0
_, loss_index = class_loss.sort(1, descending=True)
_, index_rank = loss_index.sort(1)
num_pos = pos.long().sum(1, keepdim=True)
num_neg = torch.clamp(self.pos_neg_ratio * num_pos,
max=pos.shape[1] - 1)
neg = index_rank < num_neg.expand_as(index_rank)
# class loss including positive and negative examples
pos_index = pos.unsqueeze(2).expand_as(class_preds)
neg_index = neg.unsqueeze(2).expand_as(class_preds)
preds = class_preds[(pos_index + neg_index).gt(0)]
preds = preds.view(-1, self.class_count)
targets_weighted = class_targets[(pos + neg).gt(0)]
class_loss = F.cross_entropy(preds,
targets_weighted,
size_average=False)
num_matched = num_pos.data.sum()
class_loss /= num_matched.float()
loc_loss /= num_matched.float()
loss = class_loss + loc_loss
return class_loss, loc_loss, loss
def train(self):
"""
Training process
"""
self.losses = []
self.top_1_acc = []
self.top_5_acc = []
iters_per_epoch = len(self.data_loader)
# start with a trained model if exists
if self.pretrained_model:
start = int(self.pretrained_model.split('/')[-1])
else:
start = 0
# start training
start_time = time.time()
for e in range(start, self.num_epochs):
for i, (images, labels) in enumerate(tqdm(self.data_loader)):
images = to_var(images, self.use_gpu)
labels = to_var(torch.LongTensor(labels), self.use_gpu)
loss = self.model_step(images, labels)
# print out loss log
if (e + 1) % self.loss_log_step == 0:
self.print_loss_log(start_time, iters_per_epoch, e, i, loss)
self.losses.append((e, loss))
# save model
if (e + 1) % self.model_save_step == 0:
self.save_model(e)
# evaluate on train dataset
# if (e + 1) % self.train_eval_step == 0:
# top_1_acc, top_5_acc = self.train_evaluate(e)
# self.top_1_acc.append((e, top_1_acc))
# self.top_5_acc.append((e, top_5_acc))
# print losses
write_print(self.output_txt, '\n--Losses--')
for e, loss in self.losses:
write_print(self.output_txt, str(e) + ' {:.4f}'.format(loss))
# print top_1_acc
write_print(self.output_txt, '\n--Top 1 accuracy--')
for e, acc in self.top_1_acc:
write_print(self.output_txt, str(e) + ' {:.4f}'.format(acc))
# print top_5_acc
write_print(self.output_txt, '\n--Top 5 accuracy--')
for e, acc in self.top_5_acc:
write_print(self.output_txt, str(e) + ' {:.4f}'.format(acc))
def forward(self, class_preds, class_targets, loc_preds, loc_targets,
anchors):
b, num_anchors, _ = loc_preds.shape
class_m = torch.Tensor(b, num_anchors)
loc_m = torch.Tensor(b, num_anchors, 4)
class_m = to_var(class_m, self.use_gpu)
loc_m = to_var(loc_m, self.use_gpu)
for i in range(b):
class_m[i], loc_m[i] = match(threshold=self.threshold,
class_target=class_targets[i],
loc_target=loc_targets[i],
anchors=anchors.data,
variances=self.variance)
class_targets = class_m
loc_targets = loc_m
pos = class_targets > 0
num_matched = pos.data.long().sum()
# loc_loss
pos_mask = pos.unsqueeze(2).expand_as(loc_preds)
loc_loss = F.smooth_l1_loss(loc_preds[pos_mask],
loc_targets[pos_mask],
size_average=False)
# class loss
class_preds = class_preds.view(-1, self.class_count)
class_targets = class_targets.view(-1)
class_loss = self.focal_loss(class_preds, class_targets)
class_loss /= num_matched.float()
loc_loss /= num_matched.float()
loss = class_loss + loc_loss
return class_loss, loc_loss, loss
def train_iter(self, start):
step_index = 0
start_time = time.time()
batch_iterator = iter(self.train_loader)
for i in range(start, self.num_iterations):
if i in self.sched_milestones:
step_index += 1
self.adjust_learning_rate(optimizer=self.optimizer,
gamma=self.sched_gamma,
step=step_index)
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(self.train_loader)
images, targets = next(batch_iterator)
images = to_var(images, self.use_gpu)
targets = [to_var(target, self.use_gpu) for target in targets]
class_loss, loc_loss, loss = self.model_step(images, targets)
# print out loss log
if (i + 1) % self.loss_log_step == 0:
self.print_loss_log(start_time=start_time,
cur=i,
total=self.num_iterations,
class_loss=class_loss,
loc_loss=loc_loss,
loss=loss)
self.losses.append([i, class_loss, loc_loss, loss])
# save model
if (i + 1) % self.model_save_step == 0:
self.save_model(i)
self.save_model(i)
def eval(self, dataset, top_k, threshold):
num_images = len(dataset)
all_boxes = [[[] for _ in range(num_images)]
for _ in range(self.class_count)]
# timers
_t = {'im_detect': Timer(), 'misc': Timer()}
results_path = osp.join(self.result_save_path,
self.pretrained_model)
det_file = osp.join(results_path,
'detections.pkl')
for i in range(num_images):
image, target, h, w = dataset.pull_item(i)
image = to_var(image.unsqueeze(0), self.use_gpu)
_t['im_detect'].tic()
detections = self.model(image).data
detect_time = _t['im_detect'].toc(average=False)
# skip j = 0 because it is the background class
for j in range(1, detections.shape[1]):
dets = detections[0, j, :]
mask = dets[:, 0].gt(0.).expand(5, dets.size(0)).t()
dets = torch.masked_select(dets, mask).view(-1, 5)
if dets.shape[0] == 0:
continue
boxes = dets[:, 1:]
boxes[:, 0] *= w
boxes[:, 2] *= w
boxes[:, 1] *= h
boxes[:, 3] *= h
scores = dets[:, 0].cpu().numpy()
cls_dets = np.hstack((boxes.cpu().numpy(),
scores[:, np.newaxis])).astype(np.float32,
copy=False)
all_boxes[j][i] = cls_dets
print('im_detect: {:d}/{:d} {:.3f}s'.format(i + 1,
num_images,
detect_time))
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
if self.dataset == 'voc':
voc_save(all_boxes, dataset, results_path)
do_python_eval(results_path, dataset)
def train_epoch(self, start):
step_index = 0
start_time = time.time()
iters_per_epoch = len(self.train_loader)
for e in range(start, self.num_epochs):
if e in self.sched_milestones:
step_index += 1
for i, (images, targets) in enumerate(tqdm(self.train_loader)):
self.adjust_learning_rate(optimizer=self.optimizer,
gamma=self.sched_gamma,
step=step_index,
i=i,
iters_per_epoch=iters_per_epoch,
epoch=e)
images = to_var(images, self.use_gpu)
targets = [to_var(target, self.use_gpu) for target in targets]
class_loss, loc_loss, loss = self.model_step(images, targets)
# print out loss log
if (e + 1) % self.loss_log_step == 0:
self.print_loss_log(start_time=start_time,
cur=e,
total=self.num_epochs,
class_loss=class_loss,
loc_loss=loc_loss,
loss=loss)
self.losses.append([e, class_loss, loc_loss, loss])
# save model
if (e + 1) % self.model_save_step == 0:
self.save_model(e)
self.save_model(e)
def set_mask(self, mask):
self.mask = to_var(mask, requires_grad=False)
#self.mask_bias = to_var(mask_bias, requires_grad=False)
self.weight.data = self.weight.data * self.mask.data
#self.bias.data= self.bias.data*self.mask_bias.data
self.mask_flag = True
