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