def forward(self, imgs, gt_mb_locs, gt_mb_labels): mb_locs, mb_confs = self.model(imgs) loc_loss, conf_loss = multibox_loss(mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, self.k) loss = loc_loss * self.alpha + conf_loss chainer.reporter.report({'loss': loss, 'loss/loc': loc_loss, 'loss/conf': conf_loss}, self) return loss
def _check_forward(self, mb_locs_local, mb_confs_local, gt_mb_locs_local, gt_mb_labels_local, k): loc_loss_local, conf_loss_local = multibox_loss( mb_locs_local, mb_confs_local, gt_mb_locs_local, gt_mb_labels_local, k, self.comm) loc_loss_local = cuda.to_cpu(loc_loss_local.array) conf_loss_local = cuda.to_cpu(conf_loss_local.array) loc_loss = self.comm.allreduce_obj(loc_loss_local) / self.comm.size conf_loss = self.comm.allreduce_obj(conf_loss_local) / self.comm.size expect_loc_loss, expect_conf_loss = multibox_loss( self.mb_locs, self.mb_confs, self.gt_mb_locs, self.gt_mb_labels, k) np.testing.assert_almost_equal(loc_loss, expect_loc_loss.array, decimal=2) np.testing.assert_almost_equal(conf_loss, expect_conf_loss.array, decimal=2)
def __call__(self, imgs, gt_mb_locs, gt_mb_labs): mb_locs, mb_confs = self.model(imgs) loc_loss, conf_loss = multibox_loss( mb_locs, mb_confs, gt_mb_locs, gt_mb_labs, self.k) loss = loc_loss * self.alpha + conf_loss chainer.reporter.report( {'loss': loss, 'loss/loc': loc_loss, 'loss/conf': conf_loss}, self) return loss
def _check_forward(self, mb_locs_local, mb_confs_local, gt_mb_locs_local, gt_mb_labels_local, k): loc_loss_local, conf_loss_local = multibox_loss( mb_locs_local, mb_confs_local, gt_mb_locs_local, gt_mb_labels_local, k, self.comm) loc_loss_local = cuda.to_cpu(loc_loss_local.array) conf_loss_local = cuda.to_cpu(conf_loss_local.array) from mpi4py import MPI self.comm.mpi_comm.Allreduce(MPI.IN_PLACE, loc_loss_local) self.comm.mpi_comm.Allreduce(MPI.IN_PLACE, conf_loss_local) loc_loss, conf_loss = multibox_loss(self.mb_locs, self.mb_confs, self.gt_mb_locs, self.gt_mb_labels, k) np.testing.assert_almost_equal(loc_loss_local, loc_loss.array, decimal=2) np.testing.assert_almost_equal(conf_loss_local, conf_loss.array, decimal=2)
def __call__(self, imgs, gt_mb_locs, gt_mb_labels): mb_locs, mb_confs = self.model(imgs) loc_loss, conf_loss = multibox_loss(mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, self.k) loss = loc_loss * self.alpha + conf_loss chainer.reporter.report( { self.loss_labels[0]: loss, self.loss_labels[1]: loc_loss, self.loss_labels[2]: conf_loss }, self) return loss
def __call__(self, params_detection_loss, params_segmentation_loss): mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, k = params_detection_loss score, mask_gt = params_segmentation_loss loc_loss, conf_loss = multibox_loss(mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, k) detection_loss = loc_loss * self.alpha + conf_loss segmentation_loss = mask_loss(score, mask_gt) loss_pre = detection_loss + segmentation_loss if self.param1.array is None: self.param1.initialize([1]) if self.param2.array is None: self.param2.initialize([1]) param1_precision = chainer.functions.exp(-self.param1) param2_precision = chainer.functions.exp(-self.param2) loss = detection_loss * param1_precision + 2 * self.param1 \ + segmentation_loss * param2_precision + self.param2 return loss, (loss, loss_pre, loc_loss, conf_loss, segmentation_loss, self.param1, self.param2)
def __call__(self, imgs, gt_mb_locs, gt_mb_labels, gt_mask): detection_result, segmentation_result = self.model(imgs) # mb_locs, mb_confs = self.model(imgs) detection = False segmentation = False if detection_result is not None: detection = True if segmentation_result is not None: segmentation = True if segmentation and detection: self.multi_task_loss = self.multi_task_loss else: self.multi_task_loss = False if detection: mb_locs, mb_confs = detection_result if segmentation: score = segmentation_result if not self.multi_task_loss: if detection: loc_loss, conf_loss = multibox_loss(mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, self.k) loss_detection = loc_loss * self.alpha + conf_loss if segmentation: loss_segmentation = F.softmax_cross_entropy(score, gt_mask) if segmentation and detection: if self.use_dynamic_loss: pass else: loss = 2 * self.loss_split * loss_detection + 2 * ( 1 - self.loss_split) * loss_segmentation chainer.reporter.report( { 'loss': loss, 'loss/loc': loc_loss, 'loss/conf': conf_loss, 'loss/mask': loss_segmentation, 'loss/split': self.loss_split }, self) elif segmentation: loss = loss_segmentation chainer.reporter.report( { 'loss': loss, 'loss/mask': loss_segmentation }, self) elif detection: loss = loss_detection chainer.reporter.report( { 'loss': loss, 'loss/loc': loc_loss, 'loss/conf': conf_loss }, self) else: loss, report_values = self.multi_loss( (mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, self.k), (score, gt_mask)) # loss, (loss_pre, loc_loss, conf_loss, segmentation_loss) chainer.reporter.report( { 'loss': report_values[0].data[0], 'loss/pre': report_values[1], 'loss/loc': report_values[2], 'loss/conf': report_values[3], 'loss/mask': report_values[4], 'param_det': report_values[5].data[0], 'param_seg': report_values[6].data[0] }, self) return loss
def _check_forward(self, mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, k): if self.variable: mb_locs = chainer.Variable(mb_locs) mb_confs = chainer.Variable(mb_confs) gt_mb_locs = chainer.Variable(gt_mb_locs) gt_mb_labels = chainer.Variable(gt_mb_labels) loc_loss, conf_loss = multibox_loss(mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, k) self.assertIsInstance(loc_loss, chainer.Variable) self.assertEqual(loc_loss.shape, ()) self.assertEqual(loc_loss.dtype, mb_locs.dtype) self.assertIsInstance(conf_loss, chainer.Variable) self.assertEqual(conf_loss.shape, ()) self.assertEqual(conf_loss.dtype, mb_confs.dtype) if self.variable: mb_locs = mb_locs.array mb_confs = mb_confs.array gt_mb_locs = gt_mb_locs.array gt_mb_labels = gt_mb_labels.array mb_locs = cuda.to_cpu(mb_locs) mb_confs = cuda.to_cpu(mb_confs) gt_mb_locs = cuda.to_cpu(gt_mb_locs) gt_mb_labels = cuda.to_cpu(gt_mb_labels) loc_loss = cuda.to_cpu(loc_loss.array) conf_loss = cuda.to_cpu(conf_loss.array) n_positive_total = 0 expect_loc_loss = 0 expect_conf_loss = 0 for i in six.moves.xrange(gt_mb_labels.shape[0]): n_positive = 0 negatives = [] for j in six.moves.xrange(gt_mb_labels.shape[1]): loc = F.huber_loss(mb_locs[np.newaxis, i, j], gt_mb_locs[np.newaxis, i, j], 1).array conf = F.softmax_cross_entropy(mb_confs[np.newaxis, i, j], gt_mb_labels[np.newaxis, i, j]).array if gt_mb_labels[i, j] > 0: n_positive += 1 expect_loc_loss += loc expect_conf_loss += conf else: negatives.append(conf) n_positive_total += n_positive if n_positive > 0: expect_conf_loss += sum(sorted(negatives)[-n_positive * k:]) if n_positive_total == 0: expect_loc_loss = 0 expect_conf_loss = 0 else: expect_loc_loss /= n_positive_total expect_conf_loss /= n_positive_total np.testing.assert_almost_equal(loc_loss, expect_loc_loss, decimal=2) np.testing.assert_almost_equal(conf_loss, expect_conf_loss, decimal=2)
def _check_forward(self, mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, k): if self.variable: mb_locs = chainer.Variable(mb_locs) mb_confs = chainer.Variable(mb_confs) gt_mb_locs = chainer.Variable(gt_mb_locs) gt_mb_labels = chainer.Variable(gt_mb_labels) loc_loss, conf_loss = multibox_loss( mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, k) self.assertIsInstance(loc_loss, chainer.Variable) self.assertEqual(loc_loss.shape, ()) self.assertEqual(loc_loss.dtype, mb_locs.dtype) self.assertIsInstance(conf_loss, chainer.Variable) self.assertEqual(conf_loss.shape, ()) self.assertEqual(conf_loss.dtype, mb_confs.dtype) if self.variable: mb_locs = mb_locs.array mb_confs = mb_confs.array gt_mb_locs = gt_mb_locs.array gt_mb_labels = gt_mb_labels.array mb_locs = cuda.to_cpu(mb_locs) mb_confs = cuda.to_cpu(mb_confs) gt_mb_locs = cuda.to_cpu(gt_mb_locs) gt_mb_labels = cuda.to_cpu(gt_mb_labels) loc_loss = cuda.to_cpu(loc_loss.array) conf_loss = cuda.to_cpu(conf_loss.array) n_positive_total = 0 expect_loc_loss = 0 expect_conf_loss = 0 for i in six.moves.xrange(gt_mb_labels.shape[0]): n_positive = 0 negatives = [] for j in six.moves.xrange(gt_mb_labels.shape[1]): loc = F.huber_loss( mb_locs[np.newaxis, i, j], gt_mb_locs[np.newaxis, i, j], 1).array conf = F.softmax_cross_entropy( mb_confs[np.newaxis, i, j], gt_mb_labels[np.newaxis, i, j]).array if gt_mb_labels[i, j] > 0: n_positive += 1 expect_loc_loss += loc expect_conf_loss += conf else: negatives.append(conf) n_positive_total += n_positive if n_positive > 0: expect_conf_loss += sum(sorted(negatives)[-n_positive * k:]) if n_positive_total == 0: expect_loc_loss = 0 expect_conf_loss = 0 else: expect_loc_loss /= n_positive_total expect_conf_loss /= n_positive_total np.testing.assert_almost_equal( loc_loss, expect_loc_loss, decimal=2) np.testing.assert_almost_equal( conf_loss, expect_conf_loss, decimal=2)