def train(train_loader, model, optimizer, epoch, logger): # switch to train mode model.train() pbar = tqdm(enumerate(train_loader)) for batch_idx, (data_a, data_p, data_n) in pbar: if args.cuda: data_a, data_p, data_n = data_a.cuda(), data_p.cuda(), data_n.cuda( ) data_a, data_p, data_n = Variable(data_a), Variable(data_p), Variable( data_n) out_a, out_p, out_n = model(data_a), model(data_p), model(data_n) #hardnet loss loss = loss_random_sampling(out_a, out_p, out_n, margin=args.margin) if args.decor: loss += CorrelationPenaltyLoss()(out_a) optimizer.zero_grad() loss.backward() optimizer.step() adjust_learning_rate(optimizer) if (logger != None): logger.log_value('loss', loss.data[0]).step() if batch_idx % args.log_interval == 0: pbar.set_description( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.data[0])) torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict() }, '{}/checkpoint_{}.pth'.format(LOG_DIR, epoch))
def train(train_loader, model, optimizer, epoch, logger, load_triplets = False): # switch to train mode model.train() pbar = tqdm(enumerate(train_loader)) for batch_idx, data in pbar: if load_triplets: data_a, data_p, data_n = data else: data_a, data_p = data if args.cuda: data_a, data_p = data_a.cuda(), data_p.cuda() data_a, data_p = Variable(data_a), Variable(data_p) out_a = model(data_a) out_p = model(data_p) if load_triplets: data_n = data_n.cuda() data_n = Variable(data_n) out_n = model(data_n) if args.batch_reduce == 'L2Net': loss = loss_L2Net(out_a, out_p, anchor_swap = args.anchorswap, margin = args.margin, loss_type = args.loss) elif args.batch_reduce == 'random_global': loss = loss_random_sampling(out_a, out_p, out_n, margin=args.margin, anchor_swap=args.anchorswap, loss_type = args.loss) else: loss = loss_HardNet(out_a, out_p, margin=args.margin, anchor_swap=args.anchorswap, anchor_ave=args.anchorave, batch_reduce = args.batch_reduce, loss_type = args.loss) if args.decor: loss += CorrelationPenaltyLoss()(out_a) if args.gor: loss += args.alpha*global_orthogonal_regularization(out_a, out_n) optimizer.zero_grad() loss.backward() optimizer.step() adjust_learning_rate(optimizer) if batch_idx % args.log_interval == 0: pbar.set_description( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) if (args.enable_logging): logger.log_value('loss', loss.item()).step() try: os.stat('{}{}'.format(args.model_dir,suffix)) except: os.makedirs('{}{}'.format(args.model_dir,suffix)) torch.save({'epoch': epoch + 1, 'state_dict': model.state_dict()}, '{}{}/checkpoint_{}.pth'.format(args.model_dir,suffix,epoch)) del loss, data_p, data_a, data, out_a, out_p
def train(test_loader, train_loader, model, optimizer, epoch, logger, load_triplets = False): # switch to train mode model.train() pbar = tqdm(enumerate(train_loader)) for batch_idx, data in pbar: if load_triplets: data_a, data_p, data_n = data else: data_a, data_p = data # print("data_a",data_a.size()) if args.cuda: data_a, data_p = data_a.cuda(), data_p.cuda() data_a, data_p = Variable(data_a), Variable(data_p) out_a, out_p = model(data_a), model(data_p) if load_triplets: data_n = data_n.cuda() data_n = Variable(data_n) out_n = model(data_n) if args.batch_reduce == 'L2Net': loss = loss_L2Net(out_a, out_p, anchor_swap = args.anchorswap, margin = args.margin, loss_type = args.loss) elif args.batch_reduce == 'random_global': loss = loss_random_sampling(out_a, out_p, out_n, margin=args.margin, anchor_swap=args.anchorswap, loss_type = args.loss) else: loss = loss_HardNet(out_a, out_p, margin=args.margin, anchor_swap=args.anchorswap, anchor_ave=args.anchorave, batch_reduce = args.batch_reduce, loss_type = args.loss) if args.decor: loss += args.cor_weights * CorrelationPenaltyLoss()(out_a) if args.gor: loss += args.alpha * global_orthogonal_regularization(out_a, out_n) if args.evendis: loss += args.even_weights * Even_distributeLoss()(out_a) if args.quan: loss += args.quan_weights * QuantilizeLoss(args.quan_scale)(out_a) optimizer.zero_grad() loss.backward() optimizer.step() if not args.constantlr: adjust_learning_rate(optimizer) if batch_idx % args.log_interval == 0: pbar.set_description( 'Train Epoch: {} [{}/{} ({:.0f}%)]lr:{:f} \tLoss_T: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), optimizer.param_groups[0]['lr'], loss.data[0])) if (args.enable_logging): logger.log_value('loss', loss.data.item()).step() try: os.stat('{}{}'.format(args.model_dir,suffix)) except: os.makedirs('{}{}'.format(args.model_dir,suffix)) torch.save({'epoch': epoch + 1, 'optimizer':optimizer.state_dict() ,'state_dict': model.state_dict()}, '{}{}/checkpoint_{}{}.pth'.format(args.model_dir,suffix,newstart,epoch)) # torch.save(model,'{}{}/checkpoint_{}.pth'.format(args.model_dir,suffix,epoch)) print("model {}{}/checkpoint_{}{}.pth is saved".format(args.model_dir,suffix,newstart,epoch)) if (args.enable_logging): logger.log_value(test_loader['name']+'loss is:', loss.data[0]) return loss.data.item()
def train(self, train_loader, model, optimizer, epoch, logger, load_triplets = False): print("Training model") # switch to train mode model.train() pbar = tqdm(enumerate(train_loader)) for batch_idx, data in pbar: if load_triplets: data_a, data_p, data_n = data else: data_a, data_p = data if self.args.cuda: data_a, data_p = data_a.cuda(), data_p.cuda() data_a, data_p = Variable(data_a), Variable(data_p) out_a = model(data_a) out_p = model(data_p) if load_triplets: data_n = data_n.cuda() data_n = Variable(data_n) out_n = model(data_n) if self.args.loss == 'qht': loss = loss_SOSNet(out_a, out_p, batch_reduce=self.args.batch_reduce, no_cuda=self.args.no_cuda) else: if self.args.batch_reduce == 'L2Net': loss = loss_L2Net(out_a, out_p, anchor_swap = self.args.anchorswap, margin = self.args.margin, loss_type = self.args.loss) elif self.args.batch_reduce == 'random_global': loss = loss_random_sampling(out_a, out_p, out_n, margin=self.args.margin, anchor_swap=self.args.anchorswap, loss_type = self.args.loss) else: loss = loss_HardNet(out_a, out_p, margin=self.args.margin, anchor_swap=self.args.anchorswap, anchor_ave=self.args.anchorave, batch_reduce = self.args.batch_reduce, loss_type = self.args.loss, no_cuda = self.args.no_cuda) if self.args.decor: loss += CorrelationPenaltyLoss()(out_a) if self.args.gor: loss += self.args.alpha*global_orthogonal_regularization(out_a, out_n) if self.print_summary: with torch.no_grad(): # We can only do it here because the input are only switched # to cuda types above. summary(model, input_size=(1, self.args.imageSize, self.args.imageSize)) self.print_summary = False optimizer.zero_grad() loss.backward() optimizer.step() if self.change_lr: self.adjust_learning_rate(optimizer) if batch_idx % self.args.log_interval == 0: pbar.set_description( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) if (self.args.enable_logging): logger.log_value('loss', loss.item()).step() try: os.stat('{}{}'.format(self.args.model_dir,self.suffix)) except: os.makedirs('{}{}'.format(self.args.model_dir,self.suffix)) torch.save({'epoch': epoch + 1, 'state_dict': model.state_dict()}, '{}{}/checkpoint_{}.pth'.format(self.args.model_dir,self.suffix,epoch))
def train(train_loader, model, optimizer, epoch, logger, load_triplets=False): # switch to train mode model.train() pbar = tqdm(enumerate(train_loader)) for batch_idx, data in pbar: #print( data) if load_triplets: data_a, data_p, data_n = data if args.cuda: data_a, data_p, data_n = data_a.cuda(), data_p.cuda( ), data_n.cuda() data_a, data_p, data_n = Variable(data_a), Variable( data_p), Variable(data_n) out_a, out_p, out_n = model(data_a), model(data_p), model(data_n) loss = loss_random_sampling(out_a, out_p, out_n, margin=args.margin, anchor_swap=args.anchorswap, loss_type=args.loss) else: data_a, data_p = data if args.cuda: data_a, data_p = data_a.cuda(), data_p.cuda() data_a, data_p = Variable(data_a), Variable(data_p) out_a, out_p = model(data_a), model(data_p) #hardnet loss if args.batch_reduce == 'L2Net': loss = loss_L2Net(out_a, out_p, column_row_swap=True, anchor_swap=args.anchorswap, margin=args.margin, loss_type=args.loss) else: loss = loss_HardNet(out_a, out_p, margin=args.margin, column_row_swap=True, anchor_swap=args.anchorswap, anchor_ave=args.anchorave, batch_reduce=args.batch_reduce, loss_type=args.loss) if args.decor: loss += CorrelationPenaltyLoss()(out_a) optimizer.zero_grad() loss.backward() optimizer.step() adjust_learning_rate(optimizer) if (args.enable_logging): logger.log_value('loss', loss.data[0]).step() if batch_idx % args.log_interval == 0: pbar.set_description( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.data[0])) torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict() }, '{}/checkpoint_{}.pth'.format(LOG_DIR, epoch))
def train(train_loader, model, optimizer, epoch, logger, load_triplets=False): # switch to train mode model.train() pbar = tqdm(enumerate(train_loader)) for batch_idx, data in pbar: if load_triplets: data_a, data_p, data_n = data else: data_a, data_p = data if args.cuda: data_a, data_p = data_a.cuda(), data_p.cuda() data_a, data_p = Variable(data_a), Variable(data_p) out_a, out_p = model(data_a), model(data_p) # load_triplets=Flase for the L2Net and HardNet, these two generate the positive patch based on the batch data if load_triplets: data_n = data_n.cuda() data_n = Variable(data_n) out_n = model(data_n) # for the comparision with L2Net, and random_global if args.batch_reduce == 'L2Net': loss = loss_L2Net(out_a, out_p, anchor_swap=args.anchorswap, margin=args.margin, loss_type=args.loss) elif args.batch_reduce == 'random_global': # using the random nagative patch samples from the dataset loss = loss_random_sampling(out_a, out_p, out_n, margin=args.margin, anchor_swap=args.anchorswap, loss_type=args.loss) else: loss = loss_HardNet(out_a, out_p, margin=args.margin, anchor_swap=args.anchorswap, anchor_ave=args.anchorave, batch_reduce=args.batch_reduce, loss_type=args.loss) # E2 loss in L2Net for descriptor componet correlation if args.decor: loss += CorrelationPenaltyLoss()(out_a) # gor for HardNet if args.gor: loss += args.alpha * global_orthogonal_regularization(out_a, out_n) optimizer.zero_grad() loss.backward() optimizer.step() adjust_learning_rate(optimizer, args) if batch_idx % args.log_interval == 0: pbar.set_description( 'Train Epoch: {} [{}/{} ({:.0f}%)] Loss: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.data[0])) if (args.enable_logging): logger.log_string( 'logs', 'Train Epoch: {} [{}/{} ({:.0f}%)] Loss: {:.6f}'.format( epoch, batch_idx * len(data_a), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.data[0])) try: os.stat('{}{}'.format(args.model_dir, suffix)) except: os.makedirs('{}{}'.format(args.model_dir, suffix)) torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict() }, '{}{}/checkpoint_{}.pth'.format(args.model_dir, suffix, epoch))