def valid_trainer(model, valid_loader, criterion): model.eval() loss_meter = AverageMeter() preds_probs = [] gt_list = [] with torch.no_grad(): for step, (imgs, gt_label, gt_depth, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() gt_depth = gt_depth.cuda() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 valid_logits, _ = model(imgs) valid_loss = criterion(valid_logits, gt_label) + loss_autoencoder( _, gt_depth) valid_probs = torch.sigmoid(valid_logits) preds_probs.append(valid_probs.cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) valid_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) return valid_loss, gt_label, preds_probs
def valid_trainer(model, valid_loader, criterion): model.eval() loss_meter = AverageMeter() preds_probs = [] gt_list = [] with torch.no_grad(): for step, (imgs, gt_label, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 valid_logits = model(imgs) valid_loss = criterion(valid_logits, gt_label) #去除sigmoid for mcc valid_probs = torch.sigmoid(valid_logits) # valid_probs = valid_logits preds_probs.append(valid_probs.cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) valid_loss = loss_meter.avg print(f'valid losss: {valid_loss}') gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) return valid_loss, gt_label, preds_probs
def valid_trainer(model, valid_loader, criterion): model.eval() loss_meter = AverageMeter() preds_probs = [] gt_list = [] with torch.no_grad(): for step, (imgs, depth, gt_label, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 valid_logits = model(imgs, depth) #valid_logits = model(imgs, gt_label) #valid_logits, output_depth_0,output_depth_1,output_depth_2 = model(imgs, depth) #valid_logits, depth_logits = model(imgs, depth) valid_loss = criterion(valid_logits, gt_label) valid_probs = torch.sigmoid(valid_logits) preds_probs.append(valid_probs.cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) #show_on_image(imgname, output_0) #vif(imgname,output_depth_0,output_depth_1,output_depth_2,output_depth_3, output_depth_4, output_depth_5) #return 0 valid_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) return valid_loss, gt_label, preds_probs
def batch_trainer(epoch, model, train_loader, criterion, optimizer): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[1]['lr'] for step, (imgs, gt_label, imgname) in enumerate(train_loader): batch_time = time.time() imgs, gt_label = imgs.cuda(), gt_label.cuda() feat_map, output = model(imgs) loss_list = [] for k in range(len(output)): out = output[k] loss_list.append(criterion(out, gt_label)) loss = sum(loss_list) #maximum voting output = torch.max( torch.max(torch.max(torch.max(output[0], output[1]), output[2]), output[3]), output[4]) train_loss = loss optimizer.zero_grad() train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = torch.sigmoid(output) preds_probs.append(train_probs.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print( f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print( f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}' ) return train_loss, gt_label, preds_probs
def batch_trainer(epoch, model, train_loader, criterion, optimizer, loss): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[0]['lr'] for step, (imgs, gt_label, imgname) in enumerate(train_loader): batch_time = time.time() imgs, gt_label = imgs.cuda(), gt_label.cuda() train_logit_1, train_logit_2, train_logit_3, train_logit_4 = model( imgs) if loss == 'Multi_Level_Loss': train_loss = 0.1 * criterion( train_logit_1, gt_label) + 0.3 * criterion( train_logit_2, gt_label) + 0.7 * criterion( train_logit_3, gt_label) + criterion( train_logit_4, gt_label) train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() optimizer.zero_grad() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = torch.sigmoid(train_logit_4) #train_probs_2 = torch.sigmoid(train_logit_2) #train_probs_3 = torch.sigmoid(train_logit_3) #train_probs_4 = torch.sigmoid(train_logit_4) #train_max = (train_probs + train_probs_2)/2 #preds_probs.append(train_max.detach().cpu().numpy()) preds_probs.append(train_probs.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print( f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print( f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}' ) return train_loss, gt_label, preds_probs
def valid_trainer(model, valid_loader, criterion): model.eval() loss_meter = AverageMeter() preds_probs = [] gt_list = [] with torch.no_grad(): for step, (imgs, gt_label, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() valid_logit_1, valid_logit_2, valid_logit_3, valid_logit_4 = model( imgs) #pdb.set_trace() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 #valid_logits, cha_att, spa_att = model(imgs) #pdb.set_trace() #valid_loss = 0 valid_loss = criterion(valid_logit_4, gt_label) valid_probs = torch.sigmoid(valid_logit_4) #valid_probs_2 = torch.sigmoid(valid_logit_2) #valid_probs_3 = torch.sigmoid(valid_logit_3) #valid_probs_4 = torch.sigmoid(valid_logit_4) #pdb.set_trace() #pred_max = (valid_probs + valid_probs_2)/2 #preds_probs.append(pred_max.cpu().numpy()) preds_probs.append(valid_probs.detach().cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) #show_filter(imgname, gt_label, valid_logit_2) #pdb.set_trace() #nmf_show(imgname, feature_map) #show_att(imgname, mask,mask ) #affine(imgname, theta) #vif(imgname, valid_logit_4, valid_logit_4) #return 0 #get_mask_block(imgname, gt_label, valid_logit_l, valid_logit_3, valid_logit_2) #get_att(imgname, gt_label, valid_logit_2, valid_logit_l) #pdb.set_trace() #get_detector(gt_label, valid_logit_4,valid_probs_2, valid_logit_3) #np.save('part_detector.py', part_detector) valid_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) #save_part() return valid_loss, gt_label, preds_probs
def batch_trainer(epoch, model, train_loader, criterion, optimizer, loss): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[0]['lr'] for step, (imgs, gt_label, gt_depth, imgname) in enumerate(train_loader): #print(step) batch_time = time.time() imgs, gt_label, gt_depth = imgs.cuda(), gt_label.cuda(), gt_depth.cuda( ) train_logits, _ = model(imgs) #print("sssssssssssssssssssssssssssss") #pdb.set_trace() if loss == 'BCE_LOSS': train_loss = criterion(train_logits, gt_label) + loss_autoencoder( _, gt_depth) train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() optimizer.zero_grad() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = torch.sigmoid(train_logits) preds_probs.append(train_probs.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print( f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print( f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}' ) return train_loss, gt_label, preds_probs
def valid_trainer(model, valid_loader, criterion): model.eval() loss_meter = AverageMeter() preds_probs = [] gt_list = [] with torch.no_grad(): for step, (imgs, gt_label, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 #valid_logits = model(imgs) valid_logits, valid_logits_2 = model(imgs) #pdb.set_trace() #valid_logits = model(imgs) #valid_loss = criterion(valid_logits, gt_label) #+ criterion(valid_logits_2, gt_label) #valid_loss = criterion(valid_logits, gt_label) #+ F.kl_div(torch.mean(valid_logits_2.squeeze(), 0)[0], torch.from_numpy(label_att).float().cuda(), reduction='sum') valid_loss = criterion( valid_logits_2, gt_label ) #+criterion(valid_logits_2, gt_label) #+ 0.3*mse_loss_fn(torch.mean(valid_logits_2.squeeze()[0], 0), torch.from_numpy(label_att).float().cuda()) valid_probs = torch.sigmoid(valid_logits_2) ''' valid_probs_2 = torch.sigmoid(valid_logits_2) #pdb.set_trace() # accessory valid_prob = valid_probs > 0.5 for i in range(valid_logits.size()[0]): if (valid_prob[i,15] and valid_prob[i,16]): print(str(valid_probs[i,15]) + ' '+str(valid_probs[i,16])) ''' preds_probs.append(valid_probs.cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) #show_on_image(imgname, output) #vif(imgname,output_depth_0,output_depth_1,output_depth_2,output_depth_3, output_depth_4, output_depth_5) #return 0 valid_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) return valid_loss, gt_label, preds_probs
def valid_trainer(model, valid_loader, criterion): model.eval() grad_cam = GradCam(model=model, target_layer_names=["layer4"], use_cuda=True) loss_meter = AverageMeter() preds_probs = [] gt_list = [] if True: #with torch.no_grad(): for step, (imgs, gt_label, imgname) in enumerate(tqdm(valid_loader)): #pdb.set_trace() imgs = imgs.cuda() gt_label = gt_label.cuda() gt_list.append(gt_label.cpu().numpy()) #gt_list.append(gt_label[:, 6:].cpu().numpy()) gt_label[gt_label == -1] = 0 valid_logits = model(imgs) #mask_cam = grad_cam(imgs, 22)#mask: bs, 256, 192 valid_loss = criterion( valid_logits, gt_label ) #+ 0.2*(torch.sum(torch.abs(cha_att))+torch.sum(torch.abs(spa_att))) #valid_loss = criterion(valid_logits * (mask.expand_as(valid_logits)), gt_label * (mask.expand_as(gt_label)))#+ 0.2*(torch.sum(torch.abs(cha_att))+torch.sum(torch.abs(spa_att))) valid_probs = torch.sigmoid(valid_logits) #valid_probs = torch.sigmoid(valid_logits[:, 6:]) preds_probs.append(valid_probs.detach().cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) #show_att(imgname, spa_att,spa_att ) #affine(imgname, theta) #vif(imgname, spa_att, spa_att) #show_on_image(imgname, mask_cam, 22, gt_label) #return 0 valid_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) return valid_loss, gt_label, preds_probs
def valid_trainer(epoch, model, valid_loader, criterion): model.eval() loss_meter = AverageMeter() preds_probs = [] gt_list = [] with torch.no_grad(): for step, (imgs, gt_label, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 output = model(imgs) loss_list = [] for k in range(len(output)): out = output[k] loss_list.append(criterion(out, gt_label)) loss = sum(loss_list) # maximum voting output = torch.max( torch.max( torch.max(torch.max(output[0], output[1]), output[2]), output[3]), output[4]) valid_loss = loss valid_probs = torch.sigmoid(output) preds_probs.append(valid_probs.detach().cpu().numpy()) loss_meter.update(to_scalar(valid_loss)) valid_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) return valid_loss, gt_label, preds_probs
def batch_trainer(epoch, model, train_loader, criterion, optimizer, loss): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[1]['lr'] for step, (imgs, gt_label, imgname) in enumerate(train_loader): #print(step) if step >= 319: continue batch_time = time.time() imgs, gt_label = imgs.cuda(), gt_label.cuda() train_logits, train_logits_2 = model(imgs, gt_label) #train_logits = model(imgs, gt_label) if loss == 'KL_LOSS': sim = np.load('src/sim.npy') cls_weight = model.state_dict( )['module.classifier.logits.0.weight'] #pdb.set_trace() cls_weight_t = torch.transpose(cls_weight, 1, 0) cls = torch.mm(cls_weight, cls_weight_t) cls = torch.triu(cls, 1).view(-1) sim = torch.from_numpy(sim).float().cuda(non_blocking=True) #pdb.set_trace() sim = torch.triu(sim, 1).view(-1) #pdb.set_trace() kl_mean = F.kl_div(cls.softmax(dim=-1).log(), sim.softmax(dim=-1), reduction='sum') train_loss = criterion(train_logits, gt_label) + kl_mean if loss == 'KL2_LOSS': sim = np.load('src/sim.npy') cls_weight = l2_norm(train_logits, 0) cls_weight_t = torch.transpose(cls_weight, 1, 0) cls = torch.mm(cls_weight_t, cls_weight) cls = torch.triu(cls, 1).view(-1) sim = torch.from_numpy(sim).float().cuda(non_blocking=True) sim = torch.triu(sim, 1).view(-1) #pdb.set_trace() kl_mean = F.kl_div(cls.softmax(dim=-1).log(), sim.softmax(dim=-1), reduction='sum') train_loss = criterion(train_logits, gt_label) + kl_mean if loss == 'BCE_LOSS': train_loss = criterion( train_logits, gt_label) #+ criterion(train_logits_2, gt_label) if loss == 'MMA_LOSS': #pdb.set_trace() #label_att = np.load('tools/att_label.npy') ''' for name, m in model.named_modules(): #print(name) #'name' can be used to exclude some specified layers if name=='module.classifier.fc_1': #pdb.set_trace() #cal_corre = np.corrcoef(m.weight.cpu().detach().numpy()) #cal_corre = torch.from_numpy(cal_corre).float().cuda() #weight_ = F.normalize(m.weight, p=2, dim=1) #cosine = torch.matmul(weight_, weight_.t()) mma_2 = mse_loss_fn((m.weight).view(-1), ((torch.from_numpy(fc_loss).float().cuda())).view(-1)) #mma = twin_loss(m.weight.cuda(), torch.from_numpy(fc_loss).float().cuda()) #pdb.set_trace() ''' #train_loss = criterion(train_logits, gt_label) + F.kl_div(torch.mean(train_logits_2.squeeze(), 0)[0], torch.from_numpy(label_att).float().cuda(), reduction='sum') #train_loss = criterion(train_logits, gt_label) + 0.3*mse_loss_fn(torch.mean(train_logits_2.squeeze(), 0)[0], torch.from_numpy(label_att).float().cuda()) train_loss = criterion( train_logits_2, gt_label ) #+ mma_2 + criterion(train_logits_2, gt_label) #+ 20*mma_2 ''' train_pro =(torch.sigmoid(train_logits)>0.5).float() train_loss_2 = torch.matmul((train_loss_2*train_pro).t(), train_loss_2*train_pro)*mask train_loss = 0.5*torch.sum(train_loss_2)/train_logits.size()[0] + train_loss_1 ''' train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() optimizer.zero_grad() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) #train_probs = torch.sigmoid(train_logits) train_probs_2 = torch.sigmoid(train_logits_2) preds_probs.append(train_probs_2.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print( f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print( f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}' ) return train_loss, gt_label, preds_probs
def valid_trainer(args, model, ema_model, valid_loader, criterion, loss_w=[ 1, ]): model.eval() loss_meter = AverageMeter() loss_meter_ema = AverageMeter() cls_l_meter = AverageMeter() inter_l_meter = AverageMeter() intra_l_meter = AverageMeter() preds_probs = [] preds_probs_ema = [] gt_list = [] imgname_list = [] with torch.no_grad(): for step, (imgs, gt_label, imgname) in enumerate(tqdm(valid_loader)): imgs = imgs.cuda() gt_label = gt_label.cuda() gt_list.append(gt_label.cpu().numpy()) gt_label[gt_label == -1] = 0 with autocast(): valid_logits, feat = model(imgs, gt_label) valid_logits_ema, feat_ema = ema_model(imgs, gt_label) loss_list = criterion(valid_logits, gt_label, feat) loss_list_ema = criterion(valid_logits_ema, gt_label, feat_ema) valid_loss = loss_list[0] valid_probs = torch.sigmoid(valid_logits) preds_probs.append(valid_probs.cpu().numpy()) valid_loss_ema = loss_list_ema[0] valid_probs_ema = torch.sigmoid(valid_logits_ema) preds_probs_ema.append(valid_probs_ema.cpu().numpy()) # if args.distributed: # if len(loss_list) > 1: # cls_l_meter.update(to_scalar(reduce_tensor(loss_list[0], args.world_size))) # inter_l_meter.update(to_scalar(reduce_tensor(loss_list[1], args.world_size))) # loss_meter.update(to_scalar(reduce_tensor(valid_loss, args.world_size))) # else: if len(loss_list) > 1: cls_l_meter.update(to_scalar(loss_list[0])) inter_l_meter.update(to_scalar(loss_list[1])) loss_meter.update(to_scalar(valid_loss)) loss_meter_ema.update(to_scalar(valid_loss_ema)) torch.cuda.synchronize() imgname_list.append(imgname) valid_loss = loss_meter.avg if args.local_rank == 0: print( f'cls_loss:{cls_l_meter.val:.4f}, inter_loss:{inter_l_meter.val:.4f}, ' f'intra_loss:{intra_l_meter.val:.4f}') gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) preds_probs_ema = np.concatenate(preds_probs_ema, axis=0) return valid_loss, gt_label, preds_probs, preds_probs_ema, imgname_list
def batch_trainer(cfg, args, epoch, model, model_ema, train_loader, criterion, optimizer, loss_w=[ 1, ], scheduler=None): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] imgname_list = [] # lr = optimizer.param_groups[1]['lr'] scaler = GradScaler() for step, (imgs, gt_label, imgname) in enumerate(train_loader): batch_time = time.time() imgs, gt_label = imgs.cuda(), gt_label.cuda() with autocast(): train_logits, feat = model(imgs, gt_label) loss_list = criterion(train_logits, gt_label, feat, epoch) train_loss = loss_list[0] optimizer.zero_grad() scaler.scale(train_loss).backward() scaler.step(optimizer) scaler.update() if scheduler: scheduler.step() # train_loss.backward() # if cfg.TRAIN.CLIP_GRAD: # clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works # optimizer.step() if model_ema is not None: model_ema.update(model) torch.cuda.synchronize() # if args.distributed: # reduced_loss = reduce_tensor(train_loss.data, args.world_size) # loss_meter.update(to_scalar(reduced_loss)) # else: loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = train_logits.sigmoid() preds_probs.append(train_probs.detach().cpu().numpy()) imgname_list.append(imgname) log_interval = 100 if step % log_interval == 0 or step % len(train_loader) == 0: if args.local_rank == 0: print( f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, LR {optimizer.param_groups[1]["lr"]:.1e}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}', f'train_avg_loss:{loss_meter.avg:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) if args.local_rank == 0: print( f'Epoch {epoch}, LR {optimizer.param_groups[1]["lr"]:.1e}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.val:.4f}' ) return train_loss, gt_label, preds_probs, imgname_list
def batch_trainer(epoch, model, train_loader, criterion, optimizer, loss): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[0]['lr'] for step, (img_l, img_s, img_lf, img_sf, gt_label,img_mask, imgname) in enumerate(train_loader): #print(step) batch_time = time.time() img_l, img_s, img_lf, img_sf, gt_label, img_mask = img_l.cuda(), img_s.cuda(), img_lf.cuda(), img_sf.cuda(), gt_label.cuda(), img_mask.cuda() #pdb.set_trace() train_logit_l, train_logit_2, train_logit_3, train_logit_4, train_logit_5, _= model(img_l, img_mask, gt_label) #get_att(imgname, gt_label, train_logit_4, train_logit_4) #pdb.set_trace() #train_logit_s, cha_att_s, spa_att_s = model(img_s, gt_label) #train_logit_lf, cha_att_lf, spa_att_lf = model(img_lf, gt_label) #train_logit_sf, cha_att_sf, spa_att_sf = model(img_sf, gt_label) ''' show_mask(imgname, spa_att_l, spa_att_lf, spa_att_s, spa_att_sf) pdb.set_trace() ''' #flip ''' flip_grid_large = grid_l.expand(img_l.size()[0], -1, -1, -1) flip_grid_large = Variable(flip_grid_large, requires_grad = False) flip_grid_large = flip_grid_large.permute(0, 2, 3, 1) hm_l = F.grid_sample(spa_att_l, flip_grid_large, mode = 'bilinear', padding_mode = 'border') ''' #pdb.set_trace() ''' flip_grid_small = grid_s.expand(img_l.size()[0], -1, -1, -1) flip_grid_small = Variable(flip_grid_small, requires_grad = False) flip_grid_small = flip_grid_small.permute(0, 2, 3, 1) hm_s = F.grid_sample(spa_att_s, flip_grid_small, mode = 'bilinear',padding_mode = 'border') ''' #flip_loss = F.mse_loss(hm_l, spa_att_lf) #+ F.mse_loss(hm_s, spa_att_sf) #scale ''' hm_l = F.upsample(spa_att_l, (32, 24)) #hm_s = F.upsample(spa_att_lf, (32, 24)) scale_loss = F.mse_loss(hm_l, spa_att_s) #+ F.mse_loss(hm_s, spa_att_sf) ''' if loss == 'CONSIST_LOSS': train_loss_l = 0.3*criterion(train_logit_l, gt_label) + 0.3*criterion(train_logit_3, gt_label)+ 0.7*criterion(train_logit_4, gt_label) +criterion(train_logit_5, gt_label)#+ 0.7*criterion(train_logit_3, gt_label)+1*criterion(train_logit_4, gt_label)#+train_logit_4#+criterion(train_logit_2, gt_label) ''' #每个属性关注的区域尽量正交 logit = train_logit_3.permute(1,0,2,3)#35, BS, H, W logit = logit.reshape(64, 35 ,-1) #pdb.set_trace() dot = torch.matmul(logit, logit.permute(0,2,1))#BS , 35, 35 mask = torch.from_numpy(np.load('mask.npy', allow_pickle=True)).float().cuda() mask = mask.unsqueeze(0) mask = mask.expand_as(dot) dot = dot[mask==1] ''' ''' for i in range(64): #pdb.set_trace() dot[i] = dot[i] - torch.diag(torch.diag(dot[i])) #pdb.set_trace() ''' ''' loss_1 = torch.mean(dot) #每个属性关注的距离关系 loc = 0 for i in range(64): #pdb.set_trace() feat = logit[i].reshape(35, -1) sort, index = torch.max(feat, dim=1) index = (index/12).float() height_0 = torch.mean(index[0:5]) height_1 = torch.mean(index[5:15]) height_2 = torch.mean(index[15:21]) height_3 = torch.mean(index[21:25]) height_4 = torch.mean(index[25:30]) loc = loc+torch.mean(torch.exp(-(height_3-height_4))+torch.exp(-(height_3-height_2))+torch.exp(-(height_2-height_1))+torch.exp(-(height_4-height_2))+torch.exp(-(height_1-height_0))) ''' #pdb.set_trace() ''' for name, m in model.named_modules(): # 'name' can be used to exclude some specified layers if isinstance(m, (nn.Linear, nn.Conv2d)): #pdb.set_trace() mma_loss = get_mma_loss(m.weight) train_loss_l = train_loss_l + 0.03 * mma_loss ''' #loc = get_feat_loss(feature_map, gt_label) # #train_loss_s = criterion(train_logit_s, gt_label) #train_loss_lf = criterion(train_logit_lf, gt_label) #train_loss_sf = criterion(train_logit_sf, gt_label) #keypoints = cha_att_l.view(-1,35,2) #var_h = torch.std(keypoints[:,:,0], dim=1) #var_w = torch.std(keypoints[:,:,1], dim=1) #height_0, height_1, height_2, height_3 = keypoints[:,0], keypoints[:,3], keypoints[:,6], keypoints[:,9] #loc = torch.sum(torch.exp(-(height_3-height_2))+torch.exp(-(height_2-height_1))+torch.exp(-(height_1-height_0))) #height = torch.mean(torch.mean(torch.max(keypoints, dim=2)[1].float(), dim=2), dim=0) #height_0, height_1, height_2, height_3 = height[0], height[1], height[2], height[3] #loc = torch.sum(torch.exp(-(height_3-height_2))+torch.exp(-(height_2-height_1))+torch.exp(-(height_1-height_0))) train_loss = train_loss_l+_#+loss_1 + 0.03*loc #+ 30*(torch.exp(-torch.sum(var_w))) #pdb.set_trace() #train_loss = train_loss_l #+ dice_loss_with_sigmoid(spa_att_l, img_seg) train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() optimizer.zero_grad() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = torch.sigmoid(train_logit_l) #train_probs_2 = torch.sigmoid(train_logit_2) #train_probs_3 = torch.sigmoid(train_logit_3) #train_probs_4 = torch.sigmoid(train_logit_4) #train_max = (train_probs + train_probs_2)/2 #preds_probs.append(train_max.detach().cpu().numpy()) preds_probs.append(train_probs.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print(f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print(f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}') return train_loss, gt_label, preds_probs
def batch_trainer(epoch, model, train_loader, criterion, optimizer, loss): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[1]['lr'] for step, (imgs, gt_label, imgname) in enumerate(train_loader): #print(step) batch_time = time.time() imgs, gt_label = imgs.cuda(), gt_label.cuda() train_logits = model(imgs, gt_label) if loss == 'KL_LOSS': sim = np.load('src/sim.npy') cls_weight = model.state_dict( )['module.classifier.logits.0.weight'] #pdb.set_trace() cls_weight_t = torch.transpose(cls_weight, 1, 0) cls = torch.mm(cls_weight, cls_weight_t) cls = torch.triu(cls, 1).view(-1) sim = torch.from_numpy(sim).float().cuda(non_blocking=True) #pdb.set_trace() sim = torch.triu(sim, 1).view(-1) #pdb.set_trace() kl_mean = F.kl_div(cls.softmax(dim=-1).log(), sim.softmax(dim=-1), reduction='sum') train_loss = criterion(train_logits, gt_label) + kl_mean if loss == 'KL2_LOSS': sim = np.load('src/sim.npy') cls_weight = l2_norm(train_logits, 0) cls_weight_t = torch.transpose(cls_weight, 1, 0) cls = torch.mm(cls_weight_t, cls_weight) cls = torch.triu(cls, 1).view(-1) sim = torch.from_numpy(sim).float().cuda(non_blocking=True) sim = torch.triu(sim, 1).view(-1) #pdb.set_trace() kl_mean = F.kl_div(cls.softmax(dim=-1).log(), sim.softmax(dim=-1), reduction='sum') train_loss = criterion(train_logits, gt_label) + kl_mean if loss == 'MAP_LOSS': #drivation #index = torch.argmax(spa_att) #pdb.set_trace() #IOU c_2 = torch.sum(mask.float().cuda() * spa_att) #l1 norm c_3 = torch.sum(spa_att).float().cuda() train_loss = criterion( train_logits, gt_label) - torch.log(c_2) + 1.2 * torch.log(c_3) if loss == 'BCE_LOSS': ''' for name, m in model.named_modules(): #print(name) #'name' can be used to exclude some specified layers if name=='module.classifier.fc_1': #pdb.set_trace() #for i in [1,6,12,19,22,23,28,29,31,35,40,42,45,50,52,58,60]: # y_cov = y_cov + output_0[:,i,:,:] mma = get_mma_loss(m.weight) ''' #pdb.set_trace() #mm = torch.stack( [torch.sum(cha_att, dim=0), torch.sum(spa_att, dim=0)], dim=0) #mma = get_mma_loss(mm) train_loss = criterion( train_logits, gt_label ) #+0.5*mma#+ 0.5*criterion(cha_att, gt_label) #+ 0.02*torch.abs((32-torch.sum(torch.abs(cha_att)))) #train_loss = criterion(train_logits * (mask.expand_as(train_logits)), gt_label * (mask.expand_as(gt_label))) #+0.5*mma#+ 0.5*criterion(cha_att, gt_label) #+ 0.02*torch.abs((32-torch.sum(torch.abs(cha_att)))) train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() optimizer.zero_grad() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = torch.sigmoid(train_logits) #gt_list.append(gt_label[:, 6:].cpu().numpy()) #train_probs = torch.sigmoid(train_logits[:, 6:]) preds_probs.append(train_probs.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print( f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print( f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}' ) return train_loss, gt_label, preds_probs
def batch_trainer(epoch, model, train_loader, criterion, optimizer, loss): model.train() epoch_time = time.time() loss_meter = AverageMeter() batch_num = len(train_loader) gt_list = [] preds_probs = [] lr = optimizer.param_groups[1]['lr'] for step, (imgs, depth, gt_label, imgname) in enumerate(train_loader): #pdb.set_trace() #print(step) batch_time = time.time() imgs, gt_label = imgs.cuda(), gt_label.cuda() #train_logits, depth_logits = model(imgs, depth, gt_label) train_logits = model(imgs, depth, gt_label) #train_logits = model(imgs, gt_label) if loss == 'KL_LOSS': sim = np.load('src/sim.npy') cls_weight = model.state_dict()['module.classifier.logits.0.weight'] #pdb.set_trace() cls_weight_t = torch.transpose(cls_weight, 1, 0) cls = torch.mm(cls_weight, cls_weight_t) cls = torch.triu(cls, 1).view(-1) sim = torch.from_numpy(sim).float().cuda(non_blocking=True) #pdb.set_trace() sim = torch.triu(sim, 1).view(-1) #pdb.set_trace() kl_mean = F.kl_div(cls.softmax(dim=-1).log(), sim.softmax(dim=-1), reduction='sum') train_loss = criterion(train_logits, gt_label) + kl_mean if loss == 'KL2_LOSS': sim = np.load('src/sim.npy') cls_weight = l2_norm(train_logits, 0) cls_weight_t = torch.transpose(cls_weight, 1, 0) cls = torch.mm(cls_weight_t, cls_weight) cls = torch.triu(cls, 1).view(-1) sim = torch.from_numpy(sim).float().cuda(non_blocking=True) sim = torch.triu(sim, 1).view(-1) #pdb.set_trace() kl_mean = F.kl_div(cls.softmax(dim=-1).log(), sim.softmax(dim=-1), reduction='sum') train_loss = criterion(train_logits, gt_label) + kl_mean if loss == 'BCE_LOSS': train_loss = criterion(train_logits, gt_label) train_loss.backward() clip_grad_norm_(model.parameters(), max_norm=10.0) # make larger learning rate works optimizer.step() optimizer.zero_grad() loss_meter.update(to_scalar(train_loss)) gt_list.append(gt_label.cpu().numpy()) train_probs = torch.sigmoid(train_logits) preds_probs.append(train_probs.detach().cpu().numpy()) log_interval = 20 if (step + 1) % log_interval == 0 or (step + 1) % len(train_loader) == 0: print(f'{time_str()}, Step {step}/{batch_num} in Ep {epoch}, {time.time() - batch_time:.2f}s ', f'train_loss:{loss_meter.val:.4f}') train_loss = loss_meter.avg gt_label = np.concatenate(gt_list, axis=0) preds_probs = np.concatenate(preds_probs, axis=0) print(f'Epoch {epoch}, LR {lr}, Train_Time {time.time() - epoch_time:.2f}s, Loss: {loss_meter.avg:.4f}') return train_loss, gt_label, preds_probs