def compute_loss(input, target, smoothing): if config.loss.type == 'focal': compute_class_loss = FocalLoss(gamma=config.loss.focal.gamma) elif config.loss.type == 'f2': compute_class_loss = f2_loss elif config.loss.type == 'lsep': compute_class_loss = lsep_loss elif config.loss.type == 'lovasz': compute_class_loss = lovasz_loss else: raise AssertionError('invalid loss {}'.format(config.loss.type)) if smoothing is not None: target = (1 - smoothing) * target + smoothing / 2 if config.model.predict_thresh: logits, thresholds = input.split(input.size(-1) // 2, -1) thresholds = thresholds[:, :1] class_loss = compute_class_loss(input=logits, target=target) thresh_loss = bce_loss(input=logits - thresholds, target=target) loss = (class_loss + thresh_loss) / 2 else: loss = compute_class_loss(input=input, target=target) assert loss.dim() == 0 return loss
def train(): model.train() acc_loss, acc_crit, acc_reg = [], [], [] while True: for iter, (data, target, _) in enumerate(dl_train): print('iter: {}'.format(iter)) target = torch.clamp(target[:, aus], 0, 1) data, target = data.cuda(), target.cuda() data, target = Variable(data).float(), Variable(target).float() optimizer.zero_grad() pred, mu, logvar = model(data) print(torch.mean((mu[0:1, :]-mu[1:2, :])**2, 1)) print(torch.mean((mu[0:1, :]-mu[2:, :])**2, 1)) crit_val = bce_loss(pred, target) metric_val = npair_loss(mu[0:1, :], mu[1:2, :], mu[2:, :]) reg_val = kld(mu, logvar) / len(data) loss = args.alpha*metric_val + args.beta*reg_val loss.backward() optimizer.step() if iter % args.log_interval == 0: print('Train Epoch: {} [{}/{}]\tLoss: {:.4f} + {}*{:.4f} + {}*{:.8f} = {:.4f}'.format( epoch, iter, n_iter_train, crit_val.data, args.alpha, metric_val.data, args.beta, reg_val.data, loss.data)) break info = { 'loss_train': loss.data, 'crit_train': crit_val.data, 'reg_train': reg_val.data } for tag, value in info.items(): logger.scalar_summary( tag, value, n_iter_train*(epoch-1)+iter+1) acc_loss.append(loss.data.cpu().numpy()) acc_crit.append(crit_val.data.cpu().numpy()) acc_reg.append(reg_val.data.cpu().numpy()) return np.mean(acc_loss), np.mean(acc_crit), np.mean(acc_reg)
def train(): print(model.training) model.train() print(model.training) acc_loss, acc_crit, acc_reg = [], [], [] for iter, (data, target, _) in enumerate(dl_train): target = torch.clamp(target[:, aus], 0, 1) data, target = data.cuda(), target.cuda() data, target = Variable(data).float(), Variable(target).float() optimizer.zero_grad() pred, mu, logvar = model(data) crit_val = bce_loss(pred, target) reg_val = kld(mu, logvar) / len(data) loss = crit_val + beta * reg_val loss.backward() optimizer.step() if iter % args.log_interval == 0: print('Train Epoch: {} [{}/{}]\tLoss: {:.4f} + {}*{:.8f} = {:.4f}'. format(epoch, iter, n_iter_train, crit_val.data, beta, reg_val.data, loss.data)) info = { 'loss_train': loss.data, 'crit_train': crit_val.data, 'reg_train': reg_val.data } for tag, value in info.items(): logger.scalar_summary(tag, value, n_iter_train * (epoch - 1) + iter + 1) acc_loss.append(loss.data.cpu().numpy()) acc_crit.append(crit_val.data.cpu().numpy()) acc_reg.append(reg_val.data.cpu().numpy()) return np.mean(acc_loss), np.mean(acc_crit), np.mean(acc_reg)
def test(model, data_loader, params): # NOTE the test loss only tracks the BCE it is not the full loss used during training # the test loss is the -log() of the correct class prediction probability, the lower is better model.eval() loss_avg = ut.AverageMeter() inds = torch.arange(params['batch_size']).to(params['device']) with torch.no_grad(): for loc_feat, loc_class in data_loader: ''' loc_feat: (batch_size, input_feat_dim) loc_class: (batch_size) ''' # loc_pred: (batch_size, num_classes) loc_pred = model(loc_feat) # pos_loss: (batch_size) pos_loss = lo.bce_loss(loc_pred[inds[:loc_feat.shape[0]], loc_class]) loss = pos_loss.mean() loss_avg.update(loss.item(), loc_feat.shape[0]) print('Test loss : {:.4f}'.format(loss_avg.avg))
def test(): model.eval() f1s, acc_loss, acc_crit, acc_reg = [], [], [], [] for i, dl_test_pose in enumerate(dl_test): targets, preds = [], [] print( '-----------------------------------Evaluating POSE {} ------------------------- ' .format(poses[i])) for iter, (data, target, _) in enumerate(dl_test_pose): target = torch.clamp(target[:, aus], 0, 1) data, target = data.cuda(), target.cuda() data, target = Variable(data).float(), Variable(target).float() with torch.no_grad(): pred, mu, logvar = model(data) pred = F.sigmoid(pred) crit_val = bce_loss(pred, target) reg_val = kld(mu, logvar) / len(data) loss = crit_val + beta * reg_val acc_crit.append(crit_val.data) acc_reg.append(reg_val.data) acc_loss.append(loss.data) preds.append(pred) targets.append(target.data.cpu().numpy()) preds = np.asarray(np.concatenate(preds)) print('preds min:{}, max:{}, mean:{}'.format(preds.min(), preds.max(), np.mean(preds))) targets = np.clip(np.rint(np.concatenate(targets)), 0, 1).astype(np.uint8) ''' Evaluate model per pose''' f1_pose = [] for t in eval_thresholds: preds_f = np.copy(preds) preds_f[np.where(preds_f < t)] = 0 preds_f[np.where(preds_f >= t)] = 1 preds_f = np.reshape(preds_f, (-1, n_classes)) if t == 0.5: print('--------EVAL PRED------ t = {}'.format(t)) _, _, f1, _, _ = evaluate_model(targets, preds_f, verbose=True) else: _, _, f1, _, _ = evaluate_model(targets, preds_f, verbose=False) f1_pose.append(f1) f1s.append(f1_pose) ''' Log validation loss ''' info = { 'loss_test': np.mean(acc_loss), 'crit_test': np.mean(acc_crit), 'reg_test': np.mean(acc_reg) } for tag, value in info.items(): logger.scalar_summary(tag, value, epoch) ''' Log F1 per threshold''' f1s = np.mean(f1s, axis=0) for i, t in enumerate(eval_thresholds): info = {'f1_val_t_' + str(t): f1s[i]} for tag, value in info.items(): logger.scalar_summary(tag, value, epoch) return np.mean(acc_loss), np.mean(acc_crit), np.mean(acc_reg), f1s