def forward_backward(self, data):
imgs, pids = self.parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
# softmax temporature
if self.fixed_lmda or self.lmda_decay_step == -1:
lmda = self.init_lmda
else:
lmda = self.init_lmda * self.lmda_decay_rate**(
self.epoch // self.lmda_decay_step
)
if lmda < self.min_lmda:
lmda = self.min_lmda
for k in range(self.mc_iter):
outputs = self.model(imgs, lmda=lmda)
loss = self.compute_loss(self.criterion, outputs, pids)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
loss_dict = {
'loss': loss.item(),
'acc': metrics.accuracy(outputs, pids)[0].item()
}
return loss_dict
def forward_backward(self, data):
imgs, pids = self.parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
outputs, features = self.model(imgs)
loss_t = self.compute_loss(self.criterion_t, features, pids)
loss_x = self.compute_loss(self.criterion_x, outputs, pids)
loss = self.weight_t * loss_t + self.weight_x * loss_x
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
# 日志输出
loss_summary = {
# 'loss_t': loss_t.item(),
# 'loss_xx': loss_x.item(),
'loss_tt': loss_t.item(), #三元损失
'loss_total': loss.item(), # 总
'acc': metrics.accuracy(outputs, pids)[0].item()
}
return loss_summary, loss.item()
def forward_backward(self, data):
imgs, pids = self.parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
outputs, features = self.model(imgs)
loss = 0
loss_summary = {}
if self.weight_t > 0:
loss_t = self.compute_loss(self.criterion_t, features, pids)
loss += self.weight_t * loss_t
loss_summary['loss_t'] = loss_t.item()
if self.weight_x > 0:
loss_x = self.compute_loss(self.criterion_x, outputs, pids)
loss += self.weight_x * loss_x
loss_summary['loss_x'] = loss_x.item()
loss_summary['acc'] = metrics.accuracy(outputs, pids)[0].item()
assert loss_summary
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
return loss_summary
def train(self, epoch, max_epoch, trainloader, fixbase_epoch=0, open_layers=None, print_freq=10):
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch+1)<=fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(open_layers, epoch+1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
outputs = self.model(imgs)
loss = self._compute_loss(self.criterion, outputs, pids)
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx+1) % print_freq == 0:
# estimate remaining time
num_batches = len(trainloader)
eta_seconds = batch_time.avg * (num_batches-(batch_idx+1) + (max_epoch-(epoch+1))*num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'Eta {eta}'.format(
epoch+1, max_epoch, batch_idx+1, len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str
)
)
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(self, epoch, trainloader, fixbase=False, open_layers=None, print_freq=10):
"""Trains the model for one epoch on source datasets using softmax loss.
Args:
epoch (int): current epoch.
trainloader (Dataloader): training dataloader.
fixbase (bool, optional): whether to fix base layers. Default is False.
open_layers (str or list, optional): layers open for training.
print_freq (int, optional): print frequency. Default is 10.
"""
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if fixbase and (open_layers is not None):
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
outputs = self.model(imgs)
loss = self._compute_loss(self.criterion, outputs, pids)
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx+1) % print_freq==0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'.format(
epoch + 1, batch_idx + 1, len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
acc=accs))
end = time.time()
if (self.scheduler is not None) and (not fixbase):
self.scheduler.step()
def train(epoch,
max_epoch,
model,
criterion,
optimizer,
trainloader,
fixbase_epoch=0,
open_layers=None):
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(open_layers, epoch + 1,
fixbase_epoch))
open_specified_layers(model, open_layers)
else:
open_all_layers(model)
num_batches = len(trainloader)
end = time.time()
for batch_idx, (imgs, pids, _, _) in enumerate(trainloader):
data_time.update(time.time() - end)
imgs = imgs.cuda()
pids = pids.cuda()
optimizer.zero_grad()
outputs = model(imgs)
loss = criterion(outputs, pids)
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
accs.update(accuracy(outputs, pids)[0].item())
if (batch_idx + 1) % 20 == 0:
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.format(epoch + 1,
max_epoch,
batch_idx + 1,
num_batches,
batch_time=batch_time,
data_time=data_time,
loss=losses,
acc=accs,
lr=optimizer.param_groups[0]['lr'],
eta=eta_str))
end = time.time()
def forward_backward(self, imgs, pids):
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
outputs = self.model(imgs)
loss = self.compute_loss(self.criterion, outputs, pids)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
loss_summary = {
'loss': loss.item(),
'acc': metrics.accuracy(outputs, pids)[0].item()
}
return loss_summary
def train(epoch, model, criterion, optimizer, trainloader):
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
model.train()
end = time.time()
for batch_idx, (imgs, pids) in enumerate(trainloader):
data_time.update(time.time() - end)
imgs = imgs.cuda()
pids = pids.cuda()
optimizer.zero_grad()
outputs = model(imgs)
loss = criterion(outputs, pids)
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
accs.update(accuracy(outputs, pids)[0].item())
if (batch_idx + 1) % 20 == 0:
num_batches = len(trainloader)
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(args.max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'Eta {eta}'.format(epoch + 1,
args.max_epoch,
batch_idx + 1,
len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
acc=accs,
lr=optimizer.param_groups[0]['lr'],
eta=eta_str))
end = time.time()
def forward_backward(self, data):
imgs, pids, atts = self.parse_data_for_train(data)
x, y, z = list(atts.size())
atts = torch.reshape(atts, (x, y))
atts = atts.type(torch.FloatTensor)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
atts = atts.cuda()
outputs = self.model(imgs)
loss = self.compute_loss(self.criterion, outputs[0:2], pids)
#loss2 = self.compute_loss(self.criterion, outputs[1], pids)
losst = nn.BCEWithLogitsLoss()
loss2 = losst(outputs[2], atts)
losses = [loss, loss2]
total_loss = sum(losses)
self.optimizer.zero_grad()
total_loss.backward()
self.optimizer.step()
#print(atts)
#print(atts.size())
#print(outputs[1].size())
#print(outputs[1])
#print(type(atts))
#print(type(outputs[1]))
#loss2.backward()
#self.optimizer.step()
loss_summary = {
'loss': loss.item(),
'loss2': loss2.item(),
'acc': metrics.accuracy(outputs, pids)[0].item()
}
return loss_summary
def forward_backward(self, data):
imgs, pids = self.parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
with torch.cuda.amp.autocast():
outputs = self.model(imgs)
loss = self.compute_loss(self.criterion, outputs, pids)
self.scaler.scale(loss).backward()
self.scaler.step(self.optimizer)
self.scaler.update()
self.optimizer.zero_grad()
loss_summary = {
'loss': loss.item(),
'acc': metrics.accuracy(outputs, pids)[0].item()
}
return loss_summary
def forward_backward(self, data):
imgs, pids = self.parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
outputs, features = self.model(imgs)
loss_c = self.compute_loss(self.criterion_c, features, pids)
loss_x = self.compute_loss(self.criterion_x, outputs, pids)
loss = self.weight_c * loss_c + self.weight_x * loss_x
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
loss_summary = {
'loss_c': loss_c.item(),
'loss_x': loss_x.item(),
'acc': metrics.accuracy(outputs, pids)[0].item()
}
return loss_summary
def train(self,
epoch,
max_epoch,
writer,
print_freq=10,
fixbase_epoch=0,
open_layers=None):
losses_t = AverageMeter()
losses_x = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(
open_layers, epoch + 1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
num_batches = len(self.train_loader)
end = time.time()
for batch_idx, data in enumerate(self.train_loader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
outputs, features = self.model(imgs)
loss_t = self._compute_loss(self.criterion_t, features, pids)
loss_x = self._compute_loss(self.criterion_x, outputs, pids)
loss = self.weight_t * loss_t + self.weight_x * loss_x
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses_t.update(loss_t.item(), pids.size(0))
losses_x.update(loss_x.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx + 1) % print_freq == 0:
# estimate remaining time
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss_t {loss_t.val:.4f} ({loss_t.avg:.4f})\t'
'Loss_x {loss_x.val:.4f} ({loss_x.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.format(
epoch + 1,
max_epoch,
batch_idx + 1,
num_batches,
batch_time=batch_time,
data_time=data_time,
loss_t=losses_t,
loss_x=losses_x,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str))
if writer is not None:
n_iter = epoch * num_batches + batch_idx
writer.add_scalar('Train/Time', batch_time.avg, n_iter)
writer.add_scalar('Train/Data', data_time.avg, n_iter)
writer.add_scalar('Train/Loss_t', losses_t.avg, n_iter)
writer.add_scalar('Train/Loss_x', losses_x.avg, n_iter)
writer.add_scalar('Train/Acc', accs.avg, n_iter)
writer.add_scalar('Train/Lr',
self.optimizer.param_groups[0]['lr'], n_iter)
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(epoch,
model,
criterion_xent,
criterion_htri,
optimizer,
trainloader,
use_gpu,
writer=None):
xent_losses = AverageMeter()
htri_losses = AverageMeter()
precisions = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
model.train()
end = time.time()
for batch_idx, (imgs, pids, _, adj) in enumerate(trainloader):
data_time.update(time.time() - end)
if use_gpu:
imgs, pids, adj = imgs.cuda(), pids.cuda(), adj.cuda()
outputs, features = model(imgs, adj)
if isinstance(outputs, tuple) or isinstance(outputs, list):
xent_loss = DeepSupervision(criterion_xent, outputs, pids)
else:
xent_loss = criterion_xent(outputs, pids)
if isinstance(features, tuple) or isinstance(features, list):
htri_loss = DeepSupervision(criterion_htri, features, pids)
else:
htri_loss = criterion_htri(features, pids)
loss = args.lambda_xent * xent_loss + args.lambda_htri * htri_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
xent_losses.update(xent_loss.item(), pids.size(0))
htri_losses.update(htri_loss.item(), pids.size(0))
precisions.update(metrics.accuracy(outputs, pids).mean(axis=0)[0])
if ((batch_idx + 1) % args.print_freq
== 0) or (args.print_last
and batch_idx == (len(trainloader) - 1)):
num_batches = len(trainloader)
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(args.max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('CurTime: {0}\t'
'Epoch: [{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Speed {speed:.3f} samples/s\t'
'Data {data_time.val:.4f} ({data_time.avg:.4f})\t'
'Xent {xent.val:.4f} ({xent.avg:.4f})\t'
'Htri {htri.val:.4f} ({htri.avg:.4f})\t'
'Top1 {prec.val:.4f} ({prec.avg:.4f})\t'
'Eta {eta}'.format(cur_time(),
epoch + 1,
batch_idx + 1,
len(trainloader),
speed=1 / batch_time.avg * imgs.shape[0],
batch_time=batch_time,
data_time=data_time,
xent=xent_losses,
htri=htri_losses,
prec=precisions,
eta=eta_str))
end = time.time()
writer.add_scalar(tag='loss/xent_loss',
scalar_value=xent_losses.avg,
global_step=epoch + 1)
writer.add_scalar(tag='loss/htri_loss',
scalar_value=htri_losses.avg,
global_step=epoch + 1)
def _single_model_losses(self, model, train_records, imgs, obj_ids, n_iter,
model_name, num_packages):
with autocast(enabled=self.mix_precision):
run_kwargs = self._prepare_run_kwargs(obj_ids)
model_output = model(imgs, **run_kwargs)
all_logits, all_embeddings, extra_data = self._parse_model_output(
model_output)
total_loss = torch.zeros([], dtype=imgs.dtype, device=imgs.device)
out_logits = []
loss_summary = dict()
num_trg_losses = 0
avg_acc = 0
for trg_id in range(self.num_targets):
trg_mask = train_records['dataset_id'] == trg_id
trg_obj_ids = obj_ids[trg_mask]
trg_num_samples = trg_obj_ids.numel()
if trg_num_samples == 0:
out_logits.append(None)
continue
trg_logits = all_logits[trg_id][trg_mask]
main_loss = self.main_losses[trg_id](
trg_logits,
trg_obj_ids,
aug_index=self.aug_index,
lam=self.lam,
iteration=n_iter,
scale=self.scales[model_name])
avg_acc += metrics.accuracy(trg_logits, trg_obj_ids)[0].item()
loss_summary['main_{}/{}'.format(
trg_id, model_name)] = main_loss.item()
scaled_trg_logits = self.main_losses[trg_id].get_last_scale(
) * trg_logits
out_logits.append(scaled_trg_logits)
trg_loss = main_loss
if self.enable_metric_losses:
ml_loss_module = self.ml_losses[trg_id][model_name]
embd = all_embeddings[trg_id][trg_mask]
ml_loss_module.init_iteration()
ml_loss, ml_loss_summary = ml_loss_module(
embd, trg_logits, trg_obj_ids, n_iter)
loss_summary['ml_{}/{}'.format(
trg_id, model_name)] = ml_loss.item()
loss_summary.update(ml_loss_summary)
trg_loss += ml_loss
if num_packages > 1 and self.mix_weight > 0.0:
mix_all_logits = scaled_trg_logits.view(
-1, num_packages, scaled_trg_logits.size(1))
mix_log_probs = torch.log_softmax(mix_all_logits, dim=2)
with torch.no_grad():
trg_mix_probs = torch.softmax(mix_all_logits,
dim=2).mean(dim=1,
keepdim=True)
mixing_loss = (trg_mix_probs *
mix_log_probs).sum(dim=2).neg().mean()
loss_summary['mix_{}/{}'.format(
trg_id, model_name)] = mixing_loss.item()
trg_loss += self.mix_weight * mixing_loss
total_loss += trg_loss
num_trg_losses += 1
total_loss /= float(num_trg_losses)
avg_acc /= float(num_trg_losses)
if self.enable_attr and train_records['attr'] is not None:
attributes = train_records['attr']
all_attr_logits = extra_data['attr_logits']
num_attr_losses = 0
total_attr_loss = 0
for attr_name, attr_loss_module in self.attr_losses.items():
attr_labels = attributes[self.attr_name_map[attr_name]]
valid_attr_mask = attr_labels >= 0
attr_labels = attr_labels[valid_attr_mask]
if attr_labels.numel() == 0:
continue
attr_logits = all_attr_logits[attr_name][valid_attr_mask]
attr_loss = attr_loss_module(attr_logits,
attr_labels,
iteration=n_iter)
loss_summary['{}/{}'.format(
attr_name, model_name)] = attr_loss.item()
total_attr_loss += attr_loss
num_attr_losses += 1
total_loss += total_attr_loss / float(max(1, num_attr_losses))
if self.enable_masks and train_records['mask'] is not None:
att_loss_val = 0.0
for att_map in extra_data['att_maps']:
if att_map is not None:
with torch.no_grad():
att_map_size = att_map.size()[2:]
pos_float_mask = F.interpolate(
train_records['mask'],
size=att_map_size,
mode='nearest')
pos_mask = pos_float_mask > 0.0
neg_mask = ~pos_mask
trg_mask_values = torch.where(
pos_mask, torch.ones_like(pos_float_mask),
torch.zeros_like(pos_float_mask))
num_positives = trg_mask_values.sum(dim=(1, 2, 3),
keepdim=True)
num_negatives = float(
att_map_size[0] *
att_map_size[1]) - num_positives
batch_factor = 1.0 / float(att_map.size(0))
pos_weights = batch_factor / num_positives.clamp_min(
1.0)
neg_weights = batch_factor / num_negatives.clamp_min(
1.0)
att_errors = torch.abs(att_map - trg_mask_values)
att_pos_errors = (pos_weights *
att_errors)[pos_mask].sum()
att_neg_errors = (neg_weights *
att_errors)[neg_mask].sum()
att_loss_val += 0.5 * (att_pos_errors + att_neg_errors)
if att_loss_val > 0.0:
loss_summary['att/{}'.format(
model_name)] = att_loss_val.item()
total_loss += att_loss_val
if self.regularizer is not None and (self.epoch +
1) > self.fixbase_epoch:
reg_loss = self.regularizer(model)
loss_summary['reg/{}'.format(model_name)] = reg_loss.item()
total_loss += reg_loss
return total_loss, loss_summary, avg_acc, out_logits
def train(self, epoch, max_epoch, trainloader, fixbase_epoch=0, open_layers=None, print_freq=10):
losses1 = AverageMeter()
losses2 = AverageMeter()
accs1 = AverageMeter()
accs2 = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch+1)<=fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(open_layers, epoch+1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
num_batches = len(trainloader)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
output1, output2 = self.model(imgs)
b = imgs.size(0)
loss1 = self._compute_loss(self.criterion, output1, pids[:b//2])
loss2 = self._compute_loss(self.criterion, output2, pids[b//2:b])
loss = (loss1 + loss2) * 0.5
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses1.update(loss1.item(), pids[:b//2].size(0))
losses2.update(loss2.item(), pids[b//2:b].size(0))
accs1.update(metrics.accuracy(output1, pids[:b//2])[0].item())
accs2.update(metrics.accuracy(output2, pids[b//2:b])[0].item())
if (batch_idx+1) % print_freq == 0:
# estimate remaining time
eta_seconds = batch_time.avg * (num_batches-(batch_idx+1) + (max_epoch-(epoch+1))*num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss1 {loss1.val:.4f} ({loss1.avg:.4f})\t'
'Loss2 {loss2.val:.4f} ({loss2.avg:.4f})\t'
'Acc1 {acc1.val:.2f} ({acc1.avg:.2f})\t'
'Acc2 {acc2.val:.2f} ({acc2.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.format(
epoch+1, max_epoch, batch_idx+1, num_batches,
batch_time=batch_time,
data_time=data_time,
loss1=losses1,
loss2=losses2,
acc1=accs1,
acc2=accs2,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str
)
)
if self.writer is not None:
n_iter = epoch * num_batches + batch_idx
self.writer.add_scalar('Train/Time', batch_time.avg, n_iter)
self.writer.add_scalar('Train/Data', data_time.avg, n_iter)
self.writer.add_scalar('Train/Loss1', losses1.avg, n_iter)
self.writer.add_scalar('Train/Loss2', losses2.avg, n_iter)
self.writer.add_scalar('Train/Acc1', accs1.avg, n_iter)
self.writer.add_scalar('Train/Acc2', accs2.avg, n_iter)
self.writer.add_scalar('Train/Lr', self.optimizer.param_groups[0]['lr'], n_iter)
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(self,
epoch,
max_epoch,
trainloader,
fixbase_epoch=0,
open_layers=None,
print_freq=10):
losses = AverageMeter()
top_meters = [AverageMeter() for _ in range(5)]
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(
open_layers, epoch + 1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
num_batches = len(trainloader)
global_step = num_batches * epoch + batch_idx
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
outputs = self.model(imgs)
loss = self._compute_loss(self.criterion, outputs, pids)
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
accs = metrics.accuracy(outputs, pids, topk=(1, 2, 3, 4, 5))
for i, meter in enumerate(top_meters):
meter.update(accs[i].item())
# write to Tensorboard & comet.ml
accs_dict = {
'train-accs-top-' + str(i + 1): float(r)
for i, r in enumerate(accs)
}
for i, r in enumerate(accs):
self.writer.add_scalars('optim/train-accs',
{'top-' + str(i + 1): float(r)},
global_step)
self.experiment.log_metrics(accs_dict, step=global_step)
self.writer.add_scalar(
'optim/loss', losses.val,
global_step) # loss, loss.item() or losses.val ??
# self.writer.add_scalar('optim/loss-avg',losses.avg,global_step)
self.experiment.log_metric('optim/loss',
losses.val,
step=global_step)
self.writer.add_scalar('optim/lr',
self.optimizer.param_groups[0]['lr'],
global_step)
self.experiment.log_metric('optim/lr',
self.optimizer.param_groups[0]['lr'],
step=global_step)
if (batch_idx + 1) % print_freq == 0:
# estimate remaining time
num_batches = len(trainloader)
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Top-1 {r1.val:.2f} ({r1.avg:.2f})\t'
'Top-2 {r2.val:.2f} ({r2.avg:.2f})\t'
'Top-3 {r3.val:.2f} ({r3.avg:.2f})\t'
'Top-4 {r4.val:.2f} ({r4.avg:.2f})\t'
'Top-5 {r5.val:.2f} ({r5.avg:.2f})\t'
'Lr {lr:.6f}\t'
'Eta {eta}'.format(
epoch + 1,
max_epoch,
batch_idx + 1,
len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
r1=top_meters[0],
r2=top_meters[1],
r3=top_meters[2],
r4=top_meters[3],
r5=top_meters[4],
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str))
self.writer.add_scalar('eta', eta_seconds, global_step)
self.experiment.log_metric('eta',
eta_seconds,
step=global_step)
end = time.time()
if isinstance(self.scheduler,
torch.optim.lr_scheduler.ReduceLROnPlateau):
self.scheduler.step(losses.val)
elif self.scheduler is not None:
self.scheduler.step()
def train(self,
epoch,
max_epoch,
trainloader,
fixbase_epoch=0,
open_layers=None,
print_freq=10):
use_matching_loss = False
if epoch >= self.reg_matching_score_epoch:
use_matching_loss = True
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
att_losses = AverageMeter()
part_losses = AverageMeter()
matching_losses = AverageMeter()
self.model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(
open_layers, epoch + 1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
imgs, pids, pose_heatmaps = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
pose_heatmaps = pose_heatmaps.cuda()
self.optimizer.zero_grad()
outputs, attmaps, part_score, v_g = self.model(imgs, pose_heatmaps)
#classification loss
loss_class = self._compute_loss(self.criterion, outputs, pids)
# using for weighting each part with visibility
# loss_class = self._compute_loss(self.criterion, outputs, pids, part_score.detach())
loss_matching, loss_partconstr = self.part_c_criterion(
v_g, pids, part_score, use_matching_loss)
# add matching loss
loss = loss_class + loss_partconstr
# visibility verification loss
if use_matching_loss:
loss = loss + loss_matching
matching_losses.update(loss_matching.item(), pids.size(0))
if self.use_att_loss:
loss_att = self.att_criterion(attmaps)
loss = loss + loss_att
att_losses.update(loss_att.item(), pids.size(0))
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
part_losses.update(loss_partconstr.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx + 1) % print_freq == 0:
# estimate remaining time
num_batches = len(trainloader)
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'part_Loss {loss_part.val:.4f} ({loss_part.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'Eta {eta}'.format(
epoch + 1,
max_epoch,
batch_idx + 1,
len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
loss_part=part_losses,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str),
end='\t')
if self.use_att_loss:
print(
'attLoss {attloss.val:.4f} ({attloss.avg:.4f})'.format(
attloss=att_losses),
end='\t')
if use_matching_loss:
print(
'matchLoss {match_loss.val:.4f} ({match_loss.avg:.4f})'
.format(match_loss=matching_losses),
end='\t')
print('\n')
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(self, epoch, max_epoch, trainloader, fixbase_epoch=0, open_layers=None, print_freq=10):
losses_t = AverageMeter()
losses_x = AverageMeter()
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch+1)<=fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(open_layers, epoch+1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
num_batches = len(trainloader)
global_step = num_batches * epoch + batch_idx
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
outputs, features = self.model(imgs)
loss_t = self._compute_loss(self.criterion_t, features, pids)
loss_x = self._compute_loss(self.criterion_x, outputs, pids)
loss = self.weight_t * loss_t + self.weight_x * loss_x
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses_t.update(loss_t.item(), pids.size(0))
losses_x.update(loss_x.item(), pids.size(0))
losses.update(loss.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids, topk=(1,))[0].item())
# write to Tensorboard & comet.ml
#self.writer.add_scalars('optim/accs',accs.val,global_step)
self.experiment.log_metric('optim/accs',accs.val,step=global_step)
#self.writer.add_scalar('optim/loss',losses.val,global_step) # loss, loss.item() or losses.val ??
self.experiment.log_metric('optim/loss',losses.val,step=global_step)
#self.writer.add_scalar('optim/loss_triplet',losses_t.val,global_step)
self.experiment.log_metric('optim/loss_triplet',losses_t.val,step=global_step)
#self.writer.add_scalar('optim/loss_softmax',losses_x.val,global_step)
self.experiment.log_metric('optim/loss_softmax',losses_x.val,step=global_step)
#self.writer.add_scalar('optim/lr',self.optimizer.param_groups[0]['lr'],global_step)
self.experiment.log_metric('optim/lr',self.optimizer.param_groups[0]['lr'],step=global_step)
if (batch_idx+1) % print_freq == 0:
# estimate remaining time
num_batches = len(trainloader)
eta_seconds = batch_time.avg * (num_batches-(batch_idx+1) + (max_epoch-(epoch+1))*num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Loss_t {loss_t.val:.4f} ({loss_t.avg:.4f})\t'
'Loss_x {loss_x.val:.4f} ({loss_x.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'Eta {eta}'.format(
epoch+1, max_epoch, batch_idx+1, len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
loss_t=losses_t,
loss_x=losses_x,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str
)
)
self.writer.add_scalar('eta',eta_seconds,global_step)
self.experiment.log_metric('eta',eta_seconds,step=global_step)
end = time.time()
if isinstance(self.scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):
self.scheduler.step(losses.val)
elif self.scheduler is not None:
self.scheduler.step()
def train(
self,
epoch,
max_epoch,
writer,
fixbase_epoch=0,
open_layers=None,
print_freq=10
):
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print(
'* Only train {} (epoch: {}/{})'.format(
open_layers, epoch + 1, fixbase_epoch
)
)
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
num_batches = len(self.train_loader)
end = time.time()
for batch_idx, data in enumerate(self.train_loader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
# softmax temporature
if self.fixed_lmda or self.lmda_decay_step == -1:
lmda = self.init_lmda
else:
lmda = self.init_lmda * self.lmda_decay_rate**(
epoch // self.lmda_decay_step
)
if lmda < self.min_lmda:
lmda = self.min_lmda
for k in range(self.mc_iter):
outputs = self.model(imgs, lmda=lmda)
loss = self._compute_loss(self.criterion, outputs, pids)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx+1) % print_freq == 0:
# estimate remaining time
eta_seconds = batch_time.avg * (
num_batches - (batch_idx+1) + (max_epoch -
(epoch+1)) * num_batches
)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print(
'Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.format(
epoch + 1,
max_epoch,
batch_idx + 1,
num_batches,
batch_time=batch_time,
data_time=data_time,
loss=losses,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str
)
)
if writer is not None:
n_iter = epoch*num_batches + batch_idx
writer.add_scalar('Train/Time', batch_time.avg, n_iter)
writer.add_scalar('Train/Data', data_time.avg, n_iter)
writer.add_scalar('Train/Loss', losses.avg, n_iter)
writer.add_scalar('Train/Acc', accs.avg, n_iter)
writer.add_scalar(
'Train/Lr', self.optimizer.param_groups[0]['lr'], n_iter
)
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(self,
epoch,
max_epoch,
trainloader,
fixbase_epoch=0,
open_layers=None,
print_freq=10):
losses = AverageMeter()
base_losses = AverageMeter()
my_losses = AverageMeter()
density_losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(
open_layers, epoch + 1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
num_batches = len(trainloader)
end = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
output = self.model(imgs)
output, v = output
# attention_loss = 0
# for i in range(iy.shape[1]):
# attention_loss_i = self._compute_loss(self.criterion, iy[:, i, :], pids)
# attention_loss += attention_loss_i
# if (batch_idx + 1) % print_freq == 0:
# print("test: ", i, attention_loss_i)
#self.optimizer.zero_grad()
#attention_loss.backward(retain_graph=True)
#self.optimizer.step()
#self.optimizer.zero_grad()
#print(output.shape)
#my = my.squeeze()
#print(my.shape)
#Plabels = torch.range(0, my.shape[1] - 1).long().cuda().repeat(imgs.shape[0], 1, 1, 1).reshape(-1)
#Plabels = torch.range(0, my.shape[1] - 1).long().cuda().repeat(my.shape[0], 1, 1, 1).view(-1, my.shape[1])
#print(Plabels.shape, Plabels)
#my_loss = torch.nn.CrossEntropyLoss()(my, Plabels)
base_loss = self._compute_loss(self.criterion, output, pids)
loss = base_loss # + 0.1 * my_loss #- density
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
base_losses.update(base_loss.item(), pids.size(0))
#my_losses.update(my_loss.item(), pids.size(0))
#density_losses.update(density.item(), pids.size(0))
accs.update(metrics.accuracy(output, pids)[0].item())
if (batch_idx + 1) % print_freq == 0:
# estimate remaining time
eta_seconds = batch_time.avg * (num_batches - (batch_idx + 1) +
(max_epoch -
(epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.format(
epoch + 1,
max_epoch,
batch_idx + 1,
num_batches,
batch_time=batch_time,
data_time=data_time,
loss=losses,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str))
if self.writer is not None:
n_iter = epoch * num_batches + batch_idx
self.writer.add_scalar('Train/Time', batch_time.avg, n_iter)
self.writer.add_scalar('Train/Data', data_time.avg, n_iter)
self.writer.add_scalar('Train/Loss', losses.avg, n_iter)
self.writer.add_scalar('Train/Base_Loss', base_losses.avg,
n_iter)
#self.writer.add_scalar('Train/My_Loss', my_losses.avg, n_iter)
self.writer.add_scalar('Train/Density_loss',
density_losses.avg, n_iter)
self.writer.add_scalar('Train/Acc', accs.avg, n_iter)
self.writer.add_scalar('Train/Lr',
self.optimizer.param_groups[0]['lr'],
n_iter)
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(
self,
epoch,
max_epoch,
writer,
print_freq=10,
fixbase_epoch=0,
open_layers=None
):
losses_t = AverageMeter()
losses_x = AverageMeter()
losses_recons = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
open_all_layers(self.model)
num_batches = len(self.train_loader)
end = time.time()
for batch_idx, data in enumerate(self.train_loader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
imgs_clean=imgs.clone()
if self.use_gpu:
imgs = imgs.cuda()
imgs_clean = imgs_clean.cuda()
pids = pids.cuda()
labelss=[]
if epoch >= 0 and epoch < 15:
randmt = RandomErasing(probability=0.5,sl=0.07, sh=0.3)
for i, img in enumerate(imgs):
imgs[i],p = randmt(img)
labelss.append(p)
if epoch >= 15:
randmt = RandomErasing(probability=0.5,sl=0.1, sh=0.3)
for i, img in enumerate(imgs):
imgs[i],p = randmt(img)
labelss.append(p)
binary_labels = torch.tensor(np.asarray(labelss)).cuda()
self.optimizer.zero_grad()
outputs, outputs2, recons,bin_out1,bin_out2, bin_out3 = self.model(imgs )
loss_mse = self.criterion_mse(recons, imgs_clean)
loss = self.mgn_loss(outputs, pids)
occ_loss1 = self.BCE_criterion(bin_out1.squeeze(1),binary_labels.float() )
occ_loss2 = self.BCE_criterion(bin_out2.squeeze(1),binary_labels.float() )
occ_loss3 = self.BCE_criterion(bin_out3.squeeze(1),binary_labels.float() )
loss = loss + .05*loss_mse + 0.1*occ_loss1 + 0.1*occ_loss2+0.1*occ_loss3
#loss = self.weight_t * loss_t + self.weight_x * loss_x #+ #self.weight_r*loss_mse
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
#losses_t.update(loss_t.item(), pids.size(0))
losses_x.update(loss.item(), pids.size(0))
losses_recons.update(occ_loss1.item(), binary_labels.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx + 1) % print_freq == 0:
# estimate remaining time
eta_seconds = batch_time.avg * (
num_batches - (batch_idx + 1) + (max_epoch -
(epoch + 1)) * num_batches
)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print(
'Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
#'Loss_t {loss_t.val:.4f} ({loss_t.avg:.4f})\t'
'Loss_x {loss_x.val:.4f} ({loss_x.avg:.4f})\t'
'Loss_Occlusion {loss_r.val:.4f} ({loss_r.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.format(
epoch + 1,
max_epoch,
batch_idx + 1,
num_batches,
batch_time=batch_time,
data_time=data_time,
#loss_t=losses_t,
loss_x=losses_x,
loss_r = losses_recons,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str
)
)
writer= None
if writer is not None:
n_iter = epoch * num_batches + batch_idx
writer.add_scalar('Train/Time', batch_time.avg, n_iter)
writer.add_scalar('Train/Data', data_time.avg, n_iter)
writer.add_scalar('Train/Loss_t', losses_t.avg, n_iter)
writer.add_scalar('Train/Loss_x', losses_x.avg, n_iter)
writer.add_scalar('Train/Acc', accs.avg, n_iter)
writer.add_scalar(
'Train/Lr', self.optimizer.param_groups[0]['lr'], n_iter
)
end = time.time()
if self.scheduler is not None:
self.scheduler.step()
def train(self, epoch, max_epoch, trainloader, fixbase_epoch=0, open_layers=None, print_freq=10):
losses = AverageMeter()
reg_ow_loss = AverageMeter()
metric_loss = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
self.model.train()
if (epoch + 1) <= fixbase_epoch and open_layers is not None:
print('* Only train {} (epoch: {}/{})'.format(open_layers, epoch+1, fixbase_epoch))
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
num_batches = len(trainloader)
start_time = time.time()
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - start_time)
imgs, pids = self._parse_data_for_train(data)
imgs, pids = self._apply_batch_transform(imgs, pids)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
if self.metric_loss is not None:
embeddings, outputs = self.model(imgs, get_embeddings=True)
else:
outputs = self.model(imgs)
loss = self._compute_loss(self.criterion, outputs, pids)
if (epoch + 1) > fixbase_epoch:
reg_loss = self.regularizer(self.model)
reg_ow_loss.update(reg_loss.item(), pids.size(0))
loss += reg_loss
if self.metric_loss is not None:
metric_val = self.metric_loss(F.normalize(embeddings, dim=1),
outputs, pids)
loss += metric_val
metric_loss.update(metric_val.item(), pids.size(0))
loss.backward()
self.optimizer.step()
losses.update(loss.item(), pids.size(0))
accs.update(metrics.accuracy(outputs, pids)[0].item())
batch_time.update(time.time() - start_time)
if print_freq > 0 and (batch_idx + 1) % print_freq == 0:
eta_seconds = batch_time.avg * (num_batches-(batch_idx + 1) + (max_epoch - (epoch + 1)) * num_batches)
eta_str = str(datetime.timedelta(seconds=int(eta_seconds)))
print('Epoch: [{0}/{1}][{2}/{3}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'AUX Losses {aux_losses.val:.4f} ({aux_losses.avg:.4f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'
'Lr {lr:.6f}\t'
'eta {eta}'.
format(
epoch + 1, max_epoch, batch_idx + 1, num_batches,
batch_time=batch_time,
data_time=data_time,
aux_losses=metric_loss,
loss=losses,
acc=accs,
lr=self.optimizer.param_groups[0]['lr'],
eta=eta_str,
)
)
if self.writer is not None:
n_iter = epoch * num_batches + batch_idx
self.writer.add_scalar('Train/Time', batch_time.avg, n_iter)
self.writer.add_scalar('Train/Data', data_time.avg, n_iter)
info = self.criterion.get_last_info()
for k in info:
self.writer.add_scalar('AUX info/' + k, info[k], n_iter)
self.writer.add_scalar('Loss/train', losses.avg, n_iter)
if (epoch + 1) > fixbase_epoch:
self.writer.add_scalar('Loss/reg_ow', reg_ow_loss.avg, n_iter)
self.writer.add_scalar('Accuracy/train', accs.avg, n_iter)
self.writer.add_scalar('Learning rate', self.optimizer.param_groups[0]['lr'], n_iter)
if self.metric_loss is not None:
self.writer.add_scalar('Loss/local_push_loss',
metric_val.item(), n_iter)
start_time = time.time()
if self.scheduler is not None:
self.scheduler.step()
def forward_backward(self, data):
imgs, swapped_imgs, pids, original_label, swapped_label, original_law, swapped_law = self.parse_data_for_train(
data)
# imgs, pids = self.parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
swapped_imgs = swapped_imgs.cuda()
original_label = original_label.cuda()
swapped_label = swapped_label.cuda()
original_law = original_law.cuda()
swapped_law = swapped_law.cuda()
self.optimizer.zero_grad()
outputs = self.model(imgs)
loss_x = self.compute_loss(self.criterion_x, outputs[0], pids)
loss_t = self.compute_loss(self.criterion_trip, outputs[1], pids)
# print(original_law.size())
loss_r = self.compute_loss(self.criterion_rec, outputs[2],
original_law) # reconstruction
loss_a = self.compute_loss(self.criterion_adver, outputs[3],
original_label) # adversarial
loss = 1 * loss_x + 1 * loss_t + 0.01 * loss_r + 0.01 * loss_a
# loss = self.weight_x * loss_x + self.weight_t * loss_t + self.weight_r * loss_r + self.weight_a * loss_a
loss.backward()
self.optimizer.step()
loss_summary = {
'loss_x':
loss_x.item(),
'loss_t':
loss_t.item(),
'loss_r':
loss_r.item(),
'loss_a':
loss_a.item(),
'cat_acc':
metrics.accuracy(outputs[0], pids)[0].item(),
'd_acc':
(metrics.accuracy(outputs[3], original_label)[0].item() +
metrics.accuracy(outputs[3], swapped_label)[0].item()) / 2
}
print(
'loss_x {loss_x:.4f} loss_t {loss_t:.4f} loss_r {loss_r:.4f} loss_a {loss_a:.4f}'
' cat_acc {cat_acc:.3f}'
' d_acc {d_acc:.4f} '.format(loss_x=loss_x.item(),
loss_t=loss_t.item(),
loss_r=loss_r.item(),
loss_a=loss_a.item(),
cat_acc=loss_summary['cat_acc'],
d_acc=loss_summary['d_acc']))
# print(loss_summary)
self.optimizer.zero_grad()
outputs = self.model(swapped_imgs)
loss_x = self.compute_loss(self.criterion_x, outputs[0], pids)
loss_t = self.compute_loss(self.criterion_trip, outputs[1], pids)
loss_r = self.compute_loss(self.criterion_rec, outputs[2],
swapped_law) # reconstruction
loss_a = self.compute_loss(self.criterion_adver, outputs[3],
swapped_label) # adversarial
loss = 1 * loss_x + 1 * loss_t + 0.01 * loss_r + 0.01 * loss_a
loss_summary = {
'loss_x':
loss_x.item(),
'loss_t':
loss_t.item(),
'loss_r':
loss_r.item(),
'loss_a':
loss_a.item(),
'cat_acc':
metrics.accuracy(outputs[0], pids)[0].item(),
'd_acc':
(metrics.accuracy(outputs[3], original_label)[0].item() +
metrics.accuracy(outputs[3], swapped_label)[0].item()) / 2
}
print(
'loss_x {loss_x:.4f} loss_t {loss_t:.4f} loss_r {loss_r:.4f} loss_a {loss_a:.4f}'
' cat_acc {cat_acc:.3f}'
' d_acc {d_acc:.4f} '.format(loss_x=loss_x.item(),
loss_t=loss_t.item(),
loss_r=loss_r.item(),
loss_a=loss_a.item(),
cat_acc=loss_summary['cat_acc'],
d_acc=loss_summary['d_acc']))
loss.backward()
self.optimizer.step()
return loss_summary
def train(self,
epoch,
trainloader,
fixbase=False,
open_layers=None,
print_freq=10):
"""Trains the model for one epoch on source datasets using softmax loss.
Args:
epoch (int): current epoch.
trainloader (Dataloader): training dataloader.
fixbase (bool, optional): whether to fix base layers. Default is False.
open_layers (str or list, optional): layers open for training.
print_freq (int, optional): print frequency. Default is 10.
"""
losses = AverageMeter()
accs = AverageMeter()
batch_time = AverageMeter()
data_time = AverageMeter()
p_nums = AverageMeter()
n_nums = AverageMeter()
self.model.train()
if fixbase and (open_layers is not None):
open_specified_layers(self.model, open_layers)
else:
open_all_layers(self.model)
end = time.time()
# print('QQ')
# for batch_idx, data in enumerate(trainloader):
# imgs, pids = self._parse_data_for_train(data)
# print(pids)
# print('QQ')
# tensor([691, 691, 691, 691, 68, 68, 68, 68, 468, 468, 468, 468, 67, 67,
# 67, 67, 232, 232, 232, 232, 293, 293, 293, 293, 244, 244, 244, 244,
# 13, 13, 13, 13])
# tensor([290, 290, 290, 290, 535, 535, 535, 535, 55, 55, 55, 55, 558, 558,
# 558, 558, 129, 129, 129, 129, 699, 699, 699, 699, 232, 232, 232, 232,
# 655, 655, 655, 655])
# ...
for batch_idx, data in enumerate(trainloader):
data_time.update(time.time() - end)
imgs, pids = self._parse_data_for_train(data)
if self.use_gpu:
imgs = imgs.cuda()
pids = pids.cuda()
self.optimizer.zero_grad()
outputs = self.model(imgs)
loss, p_num, n_num = self._compute_loss(self.criterion, outputs,
pids)
# loss = Variable(loss, requires_grad = True)
if loss.item() > 0:
loss.backward()
self.optimizer.step()
batch_time.update(time.time() - end)
losses.update(loss.item(), pids.size(0))
p_nums.update(p_num)
n_nums.update(n_num)
accs.update(metrics.accuracy(outputs, pids)[0].item())
if (batch_idx + 1) % print_freq == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'MS Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'P-num {p.val:.2f} ({p.avg:.2f})\t'
'N-num {n.val:.2f} ({n.avg:.2f})\t'
'Acc {acc.val:.2f} ({acc.avg:.2f})\t'.format(
epoch + 1,
batch_idx + 1,
len(trainloader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
p=p_nums,
n=n_nums,
acc=accs))
end = time.time()
if (self.scheduler is not None) and (not fixbase):
self.scheduler.step()
def forward_backward(self, data):
n_iter = self.epoch * self.num_batches + self.batch_idx
self.optimizer.zero_grad()
train_records = self.parse_data_for_train(data, True, self.enable_masks, self.use_gpu)
imgs = train_records['img']
obj_ids = train_records['obj_id']
imgs, obj_ids = self._apply_batch_transform(imgs, obj_ids)
run_kwargs = self._prepare_run_kwargs()
model_output = self.model(imgs, **run_kwargs)
all_logits, all_embeddings, extra_data = self._parse_model_output(model_output)
total_loss = torch.zeros([], dtype=imgs.dtype, device=imgs.device)
loss_summary = dict()
num_trg_losses = 0
avg_acc = 0
for trg_id in range(self.num_targets):
trg_mask = train_records['dataset_id'] == trg_id
trg_obj_ids = obj_ids[trg_mask]
trg_num_samples = trg_obj_ids.numel()
if trg_num_samples == 0:
continue
trg_logits = all_logits[trg_id][trg_mask]
main_loss = self.main_losses[trg_id](trg_logits, trg_obj_ids, iteration=n_iter)
avg_acc += metrics.accuracy(trg_logits, trg_obj_ids)[0].item()
loss_summary['main_{}'.format(trg_id)] = main_loss.item()
trg_loss = main_loss
if self.enable_metric_losses:
ml_loss_module = self.ml_losses[trg_id]
embd = all_embeddings[trg_id][trg_mask]
ml_loss_module.init_iteration()
ml_loss, ml_loss_summary = ml_loss_module(embd, trg_logits, trg_obj_ids, n_iter)
ml_loss_module.end_iteration()
loss_summary['ml_{}'.format(trg_id)] = ml_loss.item()
loss_summary.update(ml_loss_summary)
trg_loss += ml_loss
total_loss += trg_loss
num_trg_losses += 1
total_loss /= float(num_trg_losses)
avg_acc /= float(num_trg_losses)
if self.enable_attr and train_records['attr'] is not None:
attributes = train_records['attr']
all_attr_logits = extra_data['attr_logits']
num_attr_losses = 0
total_attr_loss = 0
for attr_name, attr_loss_module in self.attr_losses.items():
attr_labels = attributes[self.attr_name_map[attr_name]]
valid_attr_mask = attr_labels >= 0
attr_labels = attr_labels[valid_attr_mask]
if attr_labels.numel() == 0:
continue
attr_logits = all_attr_logits[attr_name][valid_attr_mask]
attr_loss = attr_loss_module(attr_logits, attr_labels, iteration=n_iter)
loss_summary[attr_name] = attr_loss.item()
total_attr_loss += attr_loss
num_attr_losses += 1
total_loss += total_attr_loss / float(max(1, num_attr_losses))
if self.enable_masks and train_records['mask'] is not None:
att_loss_val = 0.0
for att_map in extra_data['att_maps']:
if att_map is not None:
with torch.no_grad():
att_map_size = att_map.size()[2:]
pos_float_mask = F.interpolate(train_records['mask'], size=att_map_size, mode='nearest')
pos_mask = pos_float_mask > 0.0
neg_mask = ~pos_mask
trg_mask_values = torch.where(pos_mask,
torch.ones_like(pos_float_mask),
torch.zeros_like(pos_float_mask))
num_positives = trg_mask_values.sum(dim=(1, 2, 3), keepdim=True)
num_negatives = float(att_map_size[0] * att_map_size[1]) - num_positives
batch_factor = 1.0 / float(att_map.size(0))
pos_weights = batch_factor / num_positives.clamp_min(1.0)
neg_weights = batch_factor / num_negatives.clamp_min(1.0)
att_errors = torch.abs(att_map - trg_mask_values)
att_pos_errors = (pos_weights * att_errors)[pos_mask].sum()
att_neg_errors = (neg_weights * att_errors)[neg_mask].sum()
att_loss_val += 0.5 * (att_pos_errors + att_neg_errors)
if att_loss_val > 0.0:
loss_summary['att'] = att_loss_val.item()
total_loss += att_loss_val
if self.regularizer is not None and (self.epoch + 1) > self.fixbase_epoch:
reg_loss = self.regularizer(self.model)
loss_summary['reg'] = reg_loss.item()
total_loss += reg_loss
loss_summary['loss'] = total_loss.item()
total_loss.backward()
self.optimizer.step()
return loss_summary, avg_acc
