def test__get_distance_zero(self): """ Case where just a single item in each array that are the same """ # Arrange input_x = torch.tensor([[0, 0, 1]], dtype=torch.float) input_y = torch.tensor([[0, 0, 1]], dtype=torch.float) expected = torch.tensor([0]) sut = TripletLoss(.5) # Act actual = sut._get_distance(input_x, input_y) # Assert self.assertSequenceEqual(expected.cpu().numpy().tolist(), actual.cpu().numpy().tolist())
def test__get_distance_single(self): """ Case where just a single item in each array """ # Arrange input_x = torch.tensor([[1, 8, 7]], dtype=torch.float) input_y = torch.tensor([[2, 3, 4]], dtype=torch.float) expected = torch.tensor([35]) sut = TripletLoss(.5) # Act actual = sut._get_distance(input_x, input_y) # Assert self.assertSequenceEqual(expected.cpu().numpy().round(2).tolist(), actual.cpu().numpy().round(2).tolist())
def test_forward_max_zero(self): """ Case where the difference between p and n sample is much greater than the margin :return: """ # Arrange margin = .1 sut = TripletLoss(margin) p = torch.tensor([[0, 0, 1]], dtype=torch.float) q = torch.tensor([[0, 0, 1]], dtype=torch.float) n = torch.tensor([[1, 1, 2]], dtype=torch.float) target = torch.tensor([1]) # max ( 0, 0-3 + margin) expected = 0 # Act actual = sut.forward(p, q, n, target) # Assert self.assertEqual(round(expected, 2), round(actual.item(), 2))
def get(self, train_dataset): evaluator_factory = EvalutorFactoryServiceLocator().get_factory( "EvaluationFactory") evaluator = evaluator_factory.get_evaluator() trainer = Train(evaluator, patience_epochs=self.patience_epochs, early_stopping=self.early_stopping, epochs=self.epochs) model = ModelResnet() # Define optimiser learning_rate = float( self._get_value(self.additional_args, "learning_rate", ".0001")) weight_decay = float( self._get_value(self.additional_args, "weight_decay", "5e-5")) momentum = float( self._get_value(self.additional_args, "momentum", ".9")) optimiser = SGD(lr=learning_rate, params=model.parameters(), momentum=momentum, weight_decay=weight_decay) # optimiser = Adam(lr=self.learning_rate, params=model.parameters()) self.logger.info("Using optimiser {}".format(type(optimiser))) # Define loss function tripletloss_margin = float( self._get_value(self.additional_args, "tripletloss_margin", "2.5")) tripletloss_topk = int( self._get_value(self.additional_args, "tripletloss_topk", "25")) loss = TripletLoss(margin=tripletloss_margin, topk=tripletloss_topk) # loss = nn.CrossEntropyLoss() train_pipeline = TrainPipeline(batch_size=self.batch_size, optimiser=optimiser, trainer=trainer, num_workers=self.num_workers, loss_func=loss, model=model) return train_pipeline
def train(epoch): current_lr = adjust_learning_rate(optimizer, epoch) train_loss = AverageMeter() data_time = AverageMeter() batch_time = AverageMeter() correct = 0 total = 0 #New tripletloss_global = TripletLoss(32,4,cross_modal = False) tripletloss_cross = TripletLoss(32,4,cross_modal = True) #klloss = nn.KLDivLoss(size_average = False) #centerloss = CenterLoss(395,2048) #logsoftmax = nn.LogSoftmax(dim = 1) softmax = nn.Softmax(dim = 1) # switch to train mode net.train() end = time.time() for batch_idx, (input1, input2, label1, label2) in enumerate(trainloader): #change_flag = False input1 = Variable(input1.cuda()) input2 = Variable(input2.cuda()) label1 = Variable(label1.cuda()) label2 = Variable(label2.cuda()) labels = torch.cat((label1,label2),0) data_time.update(time.time() - end) outputs,feat,_ = net(input1, input2) if args.method =='id': loss = criterion(outputs, labels) #Klloss #outputs_rgb = outputs[0:32,:] #outputs_ir = outputs[32:,:] #outputs_ir2 = logsoftmax(outputs_ir) #outputs_rgb2 = softmax(outputs_rgb) #KLLoss2 = klloss(outputs_ir2,outputs_rgb2) score = softmax(outputs) _, predicted = torch.max(score.data, 1) correct += predicted.eq(labels).sum().item() #feat = 1.*feat / (torch.norm(feat, 2, 1, keepdim=True).expand_as(feat) + 1e-10) triloss = tripletloss_cross(feat,labels) + tripletloss_global(feat,labels) loss = triloss + loss optimizer.zero_grad() loss.backward() optimizer.step() train_loss.update(loss.item(), 2*input1.size(0)) total += labels.size(0) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if batch_idx%10 ==0: print('Epoch: [{}][{}/{}] ' 'Time: {batch_time.val:.3f} ({batch_time.avg:.3f}) ' 'Data: {data_time.val:.3f} ({data_time.avg:.3f}) ' 'lr:{} ' 'Loss: {train_loss.val:.4f} ({train_loss.avg:.4f}) ' 'Accu: {:.2f}' .format( epoch, batch_idx, len(trainloader),current_lr, 100.*correct/total, batch_time=batch_time, data_time=data_time, train_loss=train_loss))
def train(epoch): current_lr = adjust_learning_rate(optimizer, epoch) train_loss = AverageMeter() data_time = AverageMeter() batch_time = AverageMeter() correct = 0 total = 0 # New tripletloss_global = TripletLoss(args.batch_size, 4) Covloss = CovLoss(batchsize=args.batch_size, num_instance=4) softmax = nn.Softmax(dim=1) l2norm = Normalize() # switch to train mode net.train() end = time.clock() for batch_idx, (input1, input2, label1, label2) in enumerate(trainloader): input1 = Variable(input1.cuda()) input2 = Variable(input2.cuda()) label1 = Variable(label1.cuda()) label2 = Variable(label2.cuda()) labels = torch.cat((label1, label2), 0) inputs = torch.cat((input1, input2), 0) data_time.update(time.clock() - end) outputs, feat, _, outputs3, feat3, _ = net(inputs) if args.method == 'id': loss = criterion(outputs, labels) loss = loss + criterion(outputs3, labels) score = softmax(outputs) score3 = softmax(outputs3) _, predicted = torch.max(score.data, 1) correct += predicted.eq(labels).sum().item() _, predicted3 = torch.max(score3.data, 1) correct3 = predicted3.eq(labels).sum().item() correct = correct + correct3 feat = l2norm(feat) feat3 = l2norm(feat3) closs = Covloss(feat) closs3 = Covloss(feat3) triloss = tripletloss_global(feat, labels) triloss3 = tripletloss_global(feat3, labels) loss = triloss + loss + triloss3 + closs + closs3 optimizer.zero_grad() loss.backward() optimizer.step() train_loss.update(loss.item(), 2 * input1.size(0)) total += labels.size(0) # measure elapsed time batch_time.update(time.clock() - end) end = time.clock() if batch_idx % 10 == 0: print('Epoch: [{}][{}/{}] ' 'Time: {batch_time.val:.3f} ({batch_time.avg:.3f}) ' 'Data: {data_time.val:.3f} ({data_time.avg:.3f}) ' 'lr:{} ' 'Loss: {train_loss.val:.4f} ({train_loss.avg:.4f}) ' 'Accu: {:.2f}'.format(epoch, batch_idx, len(trainloader), current_lr, 50. * correct / total, batch_time=batch_time, data_time=data_time, train_loss=train_loss))
device = torch.device('cuda') else: device = torch.device('cpu') market = Market1501(root='./') train_transform = Train_Transform(True) val_transform = Val_Transform() train_sampler = RandomIdentitySampler(market.train, 16, 4) train_dataset = ImageDataset(dataset=market.train, transform=train_transform) val_dataset = ImageDataset(dataset=market.test + market.query, transform=val_transform) train_dataloader = DataLoader(train_dataset, 64, False, train_sampler) val_dataloader = DataLoader(val_dataset, 128, False) Model = Train_Model().to(device) IDloss = CrossEntropySmooth(market.num_train_id) optimizer = Make_Optimizer(Model, 3.5e-5) tripletloss = TripletLoss(0.3) warmup = Warmup(optimizer) EPOCH = 120 for epoch in range(EPOCH): print('Epoch {}/{}'.format(epoch, EPOCH - 1)) print('-' * 10) warmup.step() Model.train() for phase in ['Train', 'Val']: if phase == 'Train': start = time.clock() running_loss = 0.0 running_corrects = 0.0 running_times = 0.0 for index, data in enumerate(train_dataloader): running_times += 1