def forward(self, outputs, labels):
cross_entropy_loss = CrossEntropyLoss()
triplet_loss = TripletLoss(margin=1.2)
triplet_loss_pose = TripletLoss(margin=0.8)
Triplet_Loss = [
triplet_loss(output, labels) for output in outputs[1:5]
]
Triplet_Loss = sum(Triplet_Loss) / len(Triplet_Loss)
CrossEntropy_Loss = [
cross_entropy_loss(output, labels) for output in outputs[5:-2]
]
CrossEntropy_Loss = sum(CrossEntropy_Loss) / len(CrossEntropy_Loss)
list_loss_pose = outputs[-1][:7]
visuable = torch.Tensor(outputs[-1][-1]).t().to('cuda')
Triplet_Loss_pose = [
triplet_loss_pose(_loss[_vis == 1, :], labels[_vis == 1])
for _loss, _vis in zip(list_loss_pose, visuable)
if len(labels[_vis == 1]) != 0
]
Triplet_Loss_pose = sum(Triplet_Loss_pose) / len(Triplet_Loss_pose)
loss_sum = 2 * Triplet_Loss + 4 * CrossEntropy_Loss + Triplet_Loss_pose
print(
'\rtotal loss:%.2f Triplet_Loss:%.2f CrossEntropy_Loss:%.2f Triplet_Loss_pose:%.2f'
% (loss_sum.data.cpu().numpy(), Triplet_Loss.data.cpu().numpy(),
CrossEntropy_Loss.data.cpu().numpy(),
Triplet_Loss_pose.data.cpu().numpy()),
end=' ')
return loss_sum
def forward(self, outputs, id_label, color_label):
cross_entropy_loss = CrossEntropyLoss()
triplet_loss = TripletLoss(margin=1.2)
center_loss = CenterLoss(num_classes=333, feat_dim=512)
Triplet_Loss = [
triplet_loss(output, id_label) for output in outputs[1:4]
]
Triplet_Loss = sum(Triplet_Loss) / len(Triplet_Loss)
Centor_Loss = [
center_loss(output, id_label) for output in outputs[1:4]
]
Centor_Loss = sum(Centor_Loss) / len(Centor_Loss) * 0.0005
CrossEntropy_Loss_id = [
cross_entropy_loss(output, id_label) for output in outputs[4:7]
]
CrossEntropy_Loss_id = sum(CrossEntropy_Loss_id) / len(
CrossEntropy_Loss_id)
CrossEntropy_Loss_color = [
cross_entropy_loss(output, color_label) for output in outputs[7:]
]
CrossEntropy_Loss_color = sum(CrossEntropy_Loss_color) / len(
CrossEntropy_Loss_color)
loss_sum = Triplet_Loss + 2 * (CrossEntropy_Loss_id +
CrossEntropy_Loss_color) + Centor_Loss
return loss_sum, Triplet_Loss, CrossEntropy_Loss_id, CrossEntropy_Loss_color, Centor_Loss
def forward(self, outputs, labels):
cross_entropy_loss = CrossEntropyLoss(
) if opt.label_smooth_ce else CrossEntropyLabelSmooth()
triplet_loss = TripletLoss(margin=1.2)
center_loss = CenterLoss()
Triplet_Loss = [
triplet_loss(output, labels) for output in outputs[1:4]
]
Triplet_Loss = sum(Triplet_Loss) / len(Triplet_Loss)
CrossEntropy_Loss = [
cross_entropy_loss(output, labels) for output in outputs[4:]
]
CrossEntropy_Loss = sum(CrossEntropy_Loss) / len(CrossEntropy_Loss)
loss_sum = Triplet_Loss + 2 * CrossEntropy_Loss
if opt.use_centerloss:
center_loss = [
center_loss(output, labels) for output in outputs[1:4]
]
center_loss = sum(center_loss) / len(center_loss)
loss_sum += 0.0005 * center_loss
print('\rtotal loss:%.2f Triplet_Loss:%.2f CrossEntropy_Loss:%.2f' %
(loss_sum.data.cpu().numpy(), Triplet_Loss.data.cpu().numpy(),
CrossEntropy_Loss.data.cpu().numpy()),
end=' ')
return loss_sum
def forward(self, outputs, labels):
num_cls = outputs[1][0].size(-1)
cross_entropy_loss = CrossEntropyLoss(num_cls, label_smooth=self.lsm)
loss_sum = 0
triplet_loss = TripletLoss(margin=self.margin)
if isinstance(outputs[0], (tuple, list)):
Triplet_Loss = [
triplet_loss(output, labels) for output in outputs[0]
]
Triplet_Loss = sum(Triplet_Loss) / len(Triplet_Loss)
else:
Triplet_Loss = triplet_loss(outputs[0], labels)
if isinstance(outputs[1], (tuple, list)):
crossen = [
cross_entropy_loss(output, labels) for output in outputs[1]
]
crossen = sum(crossen) / len(crossen)
else:
crossen = cross_entropy_loss(outputs[1], labels)
loss_sum = crossen * 2 + Triplet_Loss
print('\rtotal loss:%.2f Triplet_Loss:%.2f CrossEntropy_Loss:%.2f' %
(loss_sum.data.cpu().numpy(), Triplet_Loss.data.cpu().numpy(),
crossen.data.cpu().numpy()),
end=' ')
return loss_sum
def train(model, train_loader, scheduler, optimizer, loss_function):
running_loss = 0.0
for image, target in train_loader:
image = image.to('cuda')
target = target.to("cuda")
optimizer.zero_grad()
pred = model(image)
# loss=loss_function(pred,target)
triplet_loss = TripletLoss(margin=1.2)
labels = target.long()
loss = triplet_loss(pred[1], labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
scheduler.step()
epoch_loss = running_loss / len(train_loader)
print("loss:{},learning_rate:{}".format(epoch_loss,
scheduler.get_last_lr()))
return epoch_loss
def __init__(self, model):
super(Loss, self).__init__()
self.tanh = Tanh()
self.l1_loss = L1Loss()
self.bce_loss = BCELoss()
self.cross_entropy_loss = CrossEntropyLoss()
self.triplet_loss = TripletLoss(margin=1.2)
self.model = model
self.optimizer, self.optimizer_D = get_optimizer(model)
def __init__(self,
triplet_margin=1.2,
l_triplet=1,
l_xentropy=2,
**kwargs):
super(Loss, self).__init__()
self.triplet = 0
self.cross_entropy = 0
self.total = 0
self.cross_entropy_loss = CrossEntropyLoss()
self.triplet_loss = TripletLoss(margin=triplet_margin)
self.total_loss = lambda triplet, xentropy: (l_triplet * triplet) + (
l_xentropy * xentropy)
def forward(self, outputs, labels):
cross_entropy_loss = CrossEntropyLoss()
triplet_loss = TripletLoss(margin=1.2)
Triplet_Loss = triplet_loss(outputs[1], labels)
#Triplet_Loss = sum(Triplet_Loss) / len(Triplet_Loss)
CrossEntropy_Loss = cross_entropy_loss(outputs[2], labels)
#CrossEntropy_Loss = sum(CrossEntropy_Loss) / len(CrossEntropy_Loss)
loss_sum = Triplet_Loss + 2 * CrossEntropy_Loss
print('\rtotal loss:%.2f Triplet_Loss:%.2f CrossEntropy_Loss:%.2f' %
(loss_sum.data.cpu().numpy(), Triplet_Loss.data.cpu().numpy(),
CrossEntropy_Loss.data.cpu().numpy()),
end=' ')
return loss_sum
inputs, classes = next(iter(dataloaders))
##############################################
y_loss = []
y_err = []
# model = ft_net(len(class_names))
model = Model()
TVT, TMO = set_devices(args.sys_device_ids)
# criterion = nn.CrossEntropyLoss()
margin = args.margin
tri_loss = TripletLoss(margin)
#ignored_params = list(map(id, model.model.fc.parameters() )) + list(map(id, model.classifier.parameters() ))
#base_params = filter(lambda p: id(p) not in ignored_params, model.parameters())
base_params = model.parameters()
optimizer_ft = optim.SGD([
{'params': base_params, 'lr': 0.01}
# {'params': model.model.fc.parameters(), 'lr': 0.1},
# {'params': model.classifier.parameters(), 'lr': 0.1}
], weight_decay=5e-4, momentum=0.9, nesterov=True)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=args.lr_decay_epochs, gamma=0.1)
model = DataParallel(model)