def init_optimizer_and_model(): global checkpoint if checkpoint is None: model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] best_loss = checkpoint['best_loss'] print('\nLoaded checkpoint from epoch %d. Best loss so far is %.3f.\n' % (start_epoch, best_loss)) model = checkpoint['model'] optimizer = checkpoint['optimizer'] return optimizer, model
def load(self): #self.dataset = load_dataset_from_pascal_voc_jar(self.jar_path, "TRAIN") self.dataset = load_dataset_from_icdar_jar(self.jar_path, "TRAIN") if self.augment == False: self.dataset.turn_off_augment() self.loader = self.__loader_from_dataset(self.dataset, self.batch_size, self.workers) if self.chekpoint_tar_path: self.start_epoch, self.model, self.optimizer = self.__load_checkpoint( self.chekpoint_tar_path) print('\nLoaded checkpoint from epoch %d.\n' % self.start_epoch) else: self.model = SSD300(n_classes=self.n_classes) for param_name, param in self.model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): self.biases.append(param) else: self.not_biases.append(param) self.optimizer = torch.optim.SGD(params=[{ 'params': self.biases, 'lr': 2 * self.lr }, { 'params': self.not_biases }], lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay) self.model = self.model.to(device) self.criterion = MultiBoxLoss( priors_cxcy=self.model.priors_cxcy).to(device)
def evaluate(): checkpoint_path = os.path.join(args.model_root, args.model_name) checkpoint = torch.load(checkpoint_path, map_location=device) model = SSD300(n_classes=len(label_map), device=device).to(device) model.load_state_dict(checkpoint['model']) transform = Transform(size=(300, 300), train=False) test_dataset = VOCDataset(root=args.data_root, image_set=args.image_set, transform=transform, keep_difficult=True) test_loader = DataLoader(dataset=test_dataset, collate_fn=collate_fn, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False, pin_memory=True) detected_bboxes = [] detected_labels = [] detected_scores = [] true_bboxes = [] true_labels = [] true_difficulties = [] model.eval() with torch.no_grad(): bar = tqdm(test_loader, desc='Evaluate the model') for i, (images, bboxes, labels, difficulties) in enumerate(bar): images = images.to(device) bboxes = [b.to(device) for b in bboxes] labels = [l.to(device) for l in labels] difficulties = [d.to(device) for d in difficulties] predicted_bboxes, predicted_scores = model(images) _bboxes, _labels, _scores = model.detect_objects(predicted_bboxes, predicted_scores, min_score=0.01, max_overlap=0.45, top_k=200) detected_bboxes += _bboxes detected_labels += _labels detected_scores += _scores true_bboxes += bboxes true_labels += labels true_difficulties += difficulties all_ap, mean_ap = calculate_mAP(detected_bboxes, detected_labels, detected_scores, true_bboxes, true_labels, true_difficulties, device=device) pretty_printer = PrettyPrinter() pretty_printer.pprint(all_ap) print('Mean Average Precision (mAP): %.4f' % mean_ap)
def main_train(): cudnn.benchmark = True if TrainParams.checkpoint is None: start_epoch = 0 model = SSD300(n_classes=TrainParams.n_classes) biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * TrainParams.lr }, { 'params': not_biases }], lr=TrainParams.lr, momentum=TrainParams.momentum, weight_decay=TrainParams.weight_decay) else: checkpoint = torch.load(TrainParams.checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(TrainParams.device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to( TrainParams.device) train_dataset = BCCDDataset(TrainParams.data_folder, split='train', keep_difficult=TrainParams.keep_difficult) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=TrainParams.batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=TrainParams.workers, pin_memory=True) epochs = start_epoch + 1 for epoch in range(start_epoch, epochs): train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch, device=TrainParams.device) save_checkpoint(epoch, model, optimizer)
def main(): global epochs_since_improvement, start_epoch, label_map, best_loss, epoch, checkpoint if checkpoint is None: model = SSD300(n_classes=n_classes) biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endwith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params':biases, 'lr':2 * lr}, {'params':not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] best_loss = checkpoint['best_loss'] print('\nLoaded checkpoint from epoch %d. Best loss so far is %.3f.\n' % (start_epoch, best_loss)) model = checkpoint['model'] optimizer = checkpoint['optimizer'] model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.prior_cxcy).to(device) train_dataset = PascalVocDataset(data_folder,split='train',keep_difficult=keep_diffcult) val_dataset = PascalVocDataset(data_folder,split='test',keep_diffcult=keep_diffcult) train_loader = torch.utils.data.DataLoader(train_dataset,batch_size=batch_size,shuffle=True,collate_fn=train_dataset.collate_fn,num_workers=workers,pin_memory=True) val_loader = torch.utils.data.DataLoader(val_dataset,batch_size=batch_size,shuffle=True,collate_fn=val_dataset.collate_fn,num_workers=workers,pin_memory=True) # epochs for epoch in range(start_epoch,epochs): # One epoch training train(train_loader=train_loader,model=model,criterion=criterion,optimizer=optimizer,epoch=epoch) # One epoch validation val_loss = validate(val_loader=val_loader,model=model,criterion=criterion) is_best = val_loss < best_loss best_loss = min(val_loss,best_loss) if not is_best: epochs_since_improvement += 1 print("\n Epochs since last improvement:%d\n" % (epochs_since_improvement,)) else: epochs_since_improvement = 0 save_checkpoint(epoch,epochs_since_improvement,model,optimizer,val_loss,best_loss,is_best)
def main(config): """ Training """ global label_map, log out_dir = './models' out_dir = os.path.join('./models', config.model_name) if not os.path.exists(out_dir): os.makedirs(out_dir) log.open(os.path.join(out_dir, config.model_name + '.txt'), mode='a') log.write('\tout_dir = %s\n' % out_dir) log.write('\n') # Initialize model or load checkpoint if config.checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, which twice the default learning rate for bias biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * config.lr}, {'params': not_biases}], lr=config.lr, momentum=config.momentum, weight_decay=config.weight_decay) else: checkpoint = torch.load(config.checkpoint) start_epoch = checkpoint['epoch'] + 1 model = checkpoint['model'] optimizer = checkpoint['optimizer'] log('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) train_dataset = PascalVOCDataset(data_dir=config.data_folder, split='train', keep_difficult=config.keep_difficult) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=config.num_workers, pin_memory=True) for epoch in range(start_epoch, config.epochs): if epoch in config.decay_lr_at: adjust_learning_rate(optimizer, config.decay_lr_to) train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # Save checkpoint save_checkpoints(os.path.join(out_dir, 'checkpoint', 'checkpoint_epoch_{0}.pth.tar'.format(epoch+1)))
def main(): """ Training and validation. """ global epochs_since_improvement, start_epoch, label_map, best_loss, epoch # Initialize model model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay)
def create_model(num_classes=21, device=torch.device('cpu')): backbone = Backbone(pretrain_path='./pretrain/resnet50.pth') model = SSD300(backbone=backbone, num_classes=num_classes) pre_ssd_path = './pretrain/nvidia_ssdpyt_fp32.pt' pre_model_dict = torch.load(pre_ssd_path, map_location=device) pre_weights_dict = pre_model_dict['model'] # only use the pre_trained bounding boxes regression weights del_conf_loc_dict = {} for k, v in pre_weights_dict.items(): split_key = k.split('.') if 'conf' in split_key: continue del_conf_loc_dict.update({k: v}) missing_keys, unexpected_keys = model.load_state_dict(del_conf_loc_dict, strict=False) # if len(missing_keys) != 0 or len(unexpected_keys) != 0: # print('missing_keys: ', missing_keys) # print('unexpected_keys: ', unexpected_keys) return model
def main(): wandb.init() # Config is a variable that holds and saves hyperparameters and inputs #wandb.watch(model) torch.manual_seed(30) """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at #print(device) # Initialize model or load checkpoint # if checkpoint is None: start_epoch = 79 model = SSD300(n_classes=n_classes) #checkpoint = torch.load(checkpoint) # if checkpoint is None: # start_epoch = 0 # model = SSD300(n_classes=n_classes) # # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo # biases: List[Any] = list() # not_biases = list() # for param_name, param in model.named_parameters(): # if param.requires_grad: # if param_name.endswith('.bias'): # biases.append(param) # else: # not_biases.append(param) # optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], # lr=lr, momentum=momentum, weight_decay=weight_decay) # # else: # checkpoint = torch.load(checkpoint) # start_epoch = checkpoint['epoch'] + 1 # print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) # model = checkpoint['model'] # optimizer = checkpoint['optimizer'] # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases: List[Any] = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay) scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.0003, max_lr=0.0008, step_size_up=26, step_size_down=26) # print(model) # else: # checkpoint = torch.load(checkpoint) # start_epoch = checkpoint['epoch'] + 1 # print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) # model = checkpoint['model'] # optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) checkpoint = torch.load('modelfi.pt') model.load_state_dict(checkpoint) # checkpoint = torch.load('model_best.pth.tar') criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) wandb.watch(model, log="all") # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) # print(train_dataset) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here test_dataset = PascalVOCDataset(data_folder,split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) #print(next(iter(test_loader))) # print(train_loader) # a=next(iter(train_loader)) # print(a) # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations # epochs = iterations // (len(train_dataset) // 8) #print(epochs) #decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] epochs = 100 # Epochs for epoch in range(start_epoch, epochs): # # # Decay learning rate at particular epochs # if epoch in decay_lr_at: # adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(train_loader=train_loader, model=model, scheduler=scheduler, criterion=criterion, optimizer=optimizer, epoch=epoch) test(test_loader=test_loader, model=model, criterion=criterion, #optimizer=optimizer, epoch=epoch)
'''Convert pretrained VGG model to SSD. VGG model download from PyTorch model zoo: https://download.pytorch.org/models/vgg16-397923af.pth ''' import torch from model import SSD300 vgg = torch.load("/home/pzl/pytorch-hed/model/vgg16.pth") ssd = SSD300() layer_indices = [0, 2, 5, 7, 10, 12, 14, 17, 19, 21] for layer_idx in layer_indices: ssd.base[layer_idx].weight.data = vgg['features.%d.weight' % layer_idx] ssd.base[layer_idx].bias.data = vgg['features.%d.bias' % layer_idx] # [24,26,28] ssd.conv5_1.weight.data = vgg['features.24.weight'] ssd.conv5_1.bias.data = vgg['features.24.bias'] ssd.conv5_2.weight.data = vgg['features.26.weight'] ssd.conv5_2.bias.data = vgg['features.26.bias'] ssd.conv5_3.weight.data = vgg['features.28.weight'] ssd.conv5_3.bias.data = vgg['features.28.bias'] torch.save(ssd.state_dict(), 'pretained/ssd.pth')
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at # Initialize model or load checkpoint if checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations epochs = iterations // (len(train_dataset) // 32) decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] # Epochs for epoch in range(start_epoch, epochs): # Decay learning rate at particular epochs if epoch in decay_lr_at: adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # Save checkpoint save_checkpoint(epoch, model, optimizer)
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at # Initialize model or load checkpoint if checkpoint is None: print("checkpoint none") start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) # differnet optimizer # optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], # lr=lr, momentum=momentum, weight_decay=weight_decay) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) #optimizer = torch.optim.SGD(params=[{'params':model.parameters(), 'lr': 2 * lr}, {'params': model.parameters}], lr=lr, momentum=momentum, weight_decay=weight_decay) else: print("checkpoint load") checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # now it is mobilenet v3,VGG paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations, epochs = 600 # decay_lr_at =[154, 193] # print("decay_lr_at:",decay_lr_at) print("epochs:", epochs) for param_group in optimizer.param_groups: optimizer.param_groups[1]['lr'] = lr print("learning rate. The new LR is %f\n" % (optimizer.param_groups[1]['lr'], )) # Epochs,I try to use different learning rate shcheduler #different scheduler six way you could try #scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,T_max = (epochs // 7) + 1) scheduler = ReduceLROnPlateau(optimizer, mode="min", factor=0.1, patience=15, verbose=True, threshold=0.00001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08) for epoch in range(start_epoch, epochs): # Decay learning rate at particular epochs # if epoch in decay_lr_at: # adjust_learning_rate_epoch(optimizer,epoch) # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) print("epoch loss:", train_loss) scheduler.step(train_loss) # Save checkpoint save_checkpoint(epoch, model, optimizer)
def main(): """ Training and validation. """ # Training settings parser = argparse.ArgumentParser(description='SSD VOC AL') parser.add_argument('--trial_number', type=int, default=1, metavar='N', help='trial number for given acquisition function (default: 1)') parser.add_argument('--acquisition_function', type=str, default='RANDOM', metavar='N', help='type of acquisition. Options are: RANDOM, MARGIN_SAMPLING') parser.add_argument('--lr', type=float, default=1e-3, metavar='N', help='learning rate (default: 1e-3)') parser.add_argument('--save_dir', type=str, default='./results/', metavar='N', help='directory to save to (default: ./result/)') parser.add_argument('--reset_weight',type=bool, default=False, metavar='N', help='reset network weights (default: False') args = parser.parse_args() print("Training with the following acquisition function: ", args.acquisition_function) print("Training for trial #: ", args.trial_number) global epochs_since_improvement, start_epoch, label_map, epoch, checkpoint # Initialize model or load checkpoint if checkpoint is None: model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * args.lr}, {'params': not_biases}], lr=args.lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) print("Loading checkpoint model.") model = checkpoint['model'] optimizer = checkpoint['optimizer'] # use lr for param_group in optimizer.param_groups: param_group['lr'] = args.lr model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Read data files, partition train/pool and test set with open(os.path.join(data_folder, 'TRAIN_images.json'), 'r') as j: train_images = json.load(j) with open(os.path.join(data_folder, 'TRAIN_objects.json'), 'r') as j: train_objects = json.load(j) all_train_indices = np.arange(len(train_images)) train_indices = all_train_indices[:init_train_size] pool_indices = all_train_indices[init_train_size:5011] #ONLY VOC 2007, remove 5011 to use all data with open(os.path.join(data_folder, 'TEST_images.json'), 'r') as j: test_images = json.load(j) with open(os.path.join(data_folder, 'TEST_objects.json'), 'r') as j: test_objects = json.load(j) all_test_indices = np.arange(len(test_images)) test_indices = all_test_indices # Custom dataloaders train_dataset = TrainDataset(train_images, train_objects, train_indices, keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here pool_dataset = PoolDataset(train_images, train_objects, pool_indices, pool_subset, num_of_queries, keep_difficult=keep_difficult) val_dataset = TestDataset(test_images, test_objects, test_indices, keep_difficult=keep_difficult) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=True, collate_fn=val_dataset.collate_fn, num_workers=workers, pin_memory=True) training_data = list() training_data.append(train_indices) mAP_list = list() APs_list = list() for i in range(acquisition_iterations): #grab new data from pool img_indices = list() if (args.acquisition_function == 'MARGIN_SAMPLING'): print("Doing one iteration of margin sampling") img_indices = marginSampleAcquisition(pool_dataset, model) elif (args.acquisition_function == 'RANDOM'): print("Doing one iteration of random sampling") img_indices = randomSampleAcquisition(pool_dataset) elif (args.acquisition_function == 'ENTROPY' or args.acquisition_function == 'BALD' or args.acquisition_function == 'VAR_RATIO' or args.acquisition_function == 'MEAN_STD' or args.acquisition_function == 'MEAN_STD_WITH_BBOX'): print("Doing one iteration of ", args.acquisition_function) img_indices = dropoutAcquisition(pool_dataset, model, args.acquisition_function, dropout_iterations=10) elif (args.acquisition_function == 'LOCALIZATION_STABILITY'): img_indices = localizationAwareAcquisiton(pool_dataset, model) elif (args.acquisition_function == 'QBC'): img_indices = queryByCommittee(pool_dataset, model) else: print("UNKNOWN ACQUISITION FUNCTION") exit() # reset weights before training if args.reset_weight: # checkpoint = torch.load(checkpoint) print("Loading checkpoint model.") model = checkpoint['model'] optimizer = checkpoint['optimizer'] # use lr for param_group in optimizer.param_groups: param_group['lr'] = args.lr pool_dataset.removeFromPool(img_indices) train_dataset.addFromPool(img_indices) training_data.append(img_indices) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here # We can train on new data for certain number of iterations rather than epochs # XXXX iterations # epochs = int(80000 / len(train_dataset.indices)) # print("training_data len: ", len(train_dataset.indices)) # decay_epoch = int(60000 / len(train_dataset.indices)) for epoch in range(epochs): print('Epochs: ', epoch, ' / ', epochs) print('Learning rate is: ', optimizer.param_groups[1]['lr']) # if epoch == decay_epoch: # adjust_learning_rate(optimizer, 0.1) # decay by factor of 0.1 # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # check performance APs, mAP = evaluate(val_loader, model) mAP_list.append(mAP) APs_list.append(APs) if save_al_checkpoints: save_checkpoint_active_learning(args.acquisition_function, i, model, optimizer, mAP, training_data) # store accuracy print('Storing Accuracy Values over experiments') save_str = args.save_dir + args.acquisition_function + '_' + str(args.trial_number) + '_test_acc.npy' mAP_list = np.array(mAP_list) np.savez(save_str, mAP_list=mAP_list, training_data=training_data, APs_list=APs_list)
# make images mini batch if is_training: img = load_image('voc2007/' + train_keys[idx]) actual_data.append(data[train_keys[idx]]) else: img = load_image('voc2007/' + test_keys[idx]) actual_data.append(data[test_keys[idx]]) img = img.reshape((300, 300, 3)) mini_batch.append(img) return mini_batch, actual_data # tensorflow session with tf.Session() as sess: ssd = SSD300(sess) sess.run(tf.global_variables_initializer()) # parameter saver saver = tf.train.Saver() print('\nSTART LEARNING') print('==================== ' + str(datetime.datetime.now()) + ' ====================') for ep in range(EPOCH): BATCH_LOSSES = [] for ba in range(BATCH): minibatch, actual_data = next_batch(is_training=True) _, _, batch_loc, batch_conf, batch_loss = ssd.eval( minibatch, actual_data, True)
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at # Initialize model or load checkpoint if checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) #import active_vision_dataset_processing.data_loading import transforms, active_vision_dataset #Include all instances pick_trans = transforms.PickInstances(range(34)) TRAIN_PATH = "./google_drive/MyDrive/ColabNotebooks/Project/trainDataset" train_dataset = active_vision_dataset.AVD( root=TRAIN_PATH, train=True, target_transform=pick_trans, scene_list=[ 'Home_001_1', 'Home_002_1', 'Home_003_1', 'Home_004_1', 'Home_005_1', 'Home_006_1', 'Home_007_1', 'Home_008_1', 'Home_014_1', 'Home_011_1', 'Home_010_1', 'Office_001_1' ], fraction_of_no_box=-1) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, collate_fn=active_vision_dataset.collate) """ #I TRY TO USE THE DEFAULT DATASET LOADER:::::::::::::: # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here """ # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations epochs = iterations // (len(train_dataset) // 32) decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] # Epochs for epoch in range(start_epoch, epochs): # Decay learning rate at particular epochs if epoch in decay_lr_at: adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # Save checkpoint save_checkpoint(epoch, model, optimizer)
font=font) del draw model.train() return annotated_image if __name__ == '__main__': parser = make_parser() args = parser.parse_args() num_classes = 2 # text and another model = SSD300(num_classes) epoch = 14 save_path = os.path.join(args.model, f'epoch_{epoch}.pt') obj = torch.load(save_path) # model = obj['model'] model.load_state_dict(obj['model']) model.to(device) transform = MyTransform() root_folder = args.root if not os.path.exists(args.save): os.makedirs(args.save) # folder_list = os.listdir(root_folder)
def main(): print('Number of classes: ', n_classes) parser = argparse.ArgumentParser() parser.add_argument("--checkpoint", type=str, default=None) parser.add_argument("--batch_size", type=int, default=8) parser.add_argument("--size", type=int, default=300) parser.add_argument("--grad_clip", type=int, default=None) parser.add_argument("--data_folder", type=str, default='./') parser.add_argument("--save_cp", type=str, default='checkpoint300') opt = parser.parse_args() assert opt.size in [300, 512] # Initialize model or load checkpoint if opt.checkpoint is None: start_epoch = 0 if opt.size == 300: model = SSD300(n_classes=n_classes) else: model = SSD512(n_classes=n_classes) biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo else: checkpoint = torch.load(opt.checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # train_dataset = PascalVOCDataset(opt.data_folder, dim=(opt.size, opt.size)) train_dataset = COCODataset(opt.data_folder, dim=(opt.size, opt.size)) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=opt.batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # Calculate total number of epochs to train and decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations epochs = iterations // (len(train_dataset) // 32) decay_lr_at = [80000, 100000] decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] # Epochs for epoch in range(start_epoch, epochs): # Decay learning rate at particular epochs if epoch in decay_lr_at: adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch, grad_clip=opt.grad_clip) # Save checkpoint save_checkpoint(epoch, model, optimizer, opt.save_cp)
def main(): # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here test_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=batch_size, shuffle=True, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) """ Training. """ global start_epoch, label_map, epoch, checkpoint # Initialize model or load checkpoint if checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo lr = 0.01 optimizer = torch.optim.SGD([ { 'params': model.base.parameters(), 'lr': lr / 100 }, { 'params': model.aux_convs.parameters(), 'lr ': lr / 10 }, ], lr=0.01, momentum=0.8) scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=[0.0001, 0.001], max_lr=[0.001, 0.005], step_size_up=31, step_size_down=31) #print(model) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] scheduler = torch.optim.lr_scheduler.CyclicLR( optimizer, base_lr=[0.000001, 0.00001, 0.00001], max_lr=[0.000005, 0.00009, 0.00005], step_size_up=31, step_size_down=31) # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) print(model) #print(next(iter(test_loader))) # print(train_loader) # a=next(iter(train_loader)) # print(a) # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations #epochs = iterations // (len(train_dataset) // 8) #print(epochs) #decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] epochs = 125 # Epochs #scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer,div_factor=100.0, final_div_factor=100000.0, max_lr=0.001, total_steps=66) for epoch in range(start_epoch, epochs): # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, scheduler=scheduler, epoch=epoch) #print(scheduler.get_lr()) test( test_loader=test_loader, model=model, criterion=criterion, #optimizer=optimizer, epoch=epoch) # Save checkpoint save_checkpoint(epoch, model, optimizer)
def main(): wandb.init(project="re") use_cuda = not config.no_cuda and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 4, 'pin_memory': True} if use_cuda else {} torch.manual_seed(config.seed) # pytorch random seed # numpy.random.seed(config.seed) # numpy random seed torch.backends.cudnn.deterministic = True # Config is a variable that holds and saves hyperparameters and inputs #wandb.watch(model) #torch.manual_seed(args.seed) """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at #print(device) # Initialize model or load checkpoint if checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases: List[Any] = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(model.parameters(), lr=config.lr, momentum=config.momentum) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) #wandb.watch(model, log="all") wandb.watch(model, log="all") # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) # print(train_dataset) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=config.batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, **kwargs) # note that we're passing the collate function here test_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=config.batch_size, shuffle=True, collate_fn=test_dataset.collate_fn, **kwargs) #print(next(iter(test_loader))) # print(train_loader) # a=next(iter(train_loader)) # print(a) # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations # epochs = iterations // (len(train_dataset) // 8) #print(epochs) #decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] config.epochs = 50 #epochs = 10 # Epochs for epoch in range(start_epoch, config.epochs + 1): # # Decay learning rate at particular epochs # if epoch in decay_lr_at: # adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(config, train_loader=train_loader, device, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) test( config, test_loader=test_loader, device, model=model, criterion=criterion, #optimizer=optimizer, epoch=epoch) # Save checkpoint save_checkpoint(epoch, model, optimizer)
from PIL import ImageDraw, ImageFont import numpy as np import pickle from PIL import Image import cv2 import time from model import SSD300 from utils import * import os jt.flags.use_cuda = 1 # Load model checkpoint experiment_id = "pretrain_model" # set your experiment id model_path = os.path.join('tensorboard', experiment_id, 'model_best.pkl') params = pickle.load(open(model_path, "rb")) model = SSD300(21) model.load_parameters(params) print(f'[*] Load model {model_path} success') # Transforms def transform(image, size=300, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]): image = cv2.resize(image, (300, 300)) image /= 255. image = (image - mean) / std return image.transpose(2, 0, 1)
from torchvision import transforms from utils import * from PIL import Image, ImageDraw, ImageFont from datasets import PascalVOCDataset from collections import Counter import threading n_classes = len(label_map) from model import SSD300, MultiBoxLoss device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = SSD300(n_classes=n_classes) # Load model checkpoint model = model.to(device) checkpoint = torch.load('model.pt') model.load_state_dict(checkpoint) model.eval() # Transforms resize = transforms.Resize((300, 300)) to_tensor = transforms.ToTensor() normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) def detect(original_image, min_score, max_overlap, top_k, suppress=None): """ Detect objects in an image with a trained SSD300, and visualize the results. :param original_image: image, a PIL Image :param min_score: minimum threshold for a detected box to be considered a match for a certain class :param max_overlap: maximum overlap two boxes can have so that the one with the lower score is not suppressed via Non-Maximum Suppression (NMS) :param top_k: if there are a lot of resulting detection across all classes, keep only the top 'k'
def main(): # Prepare train dataset and dataloader train_ds = PascalVOCDataset('./data', 'TRAIN', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=train_ds.collate_fn, # note that we're passing the collate function here num_workers=num_workers, pin_memory=True) n_classes = len(train_ds.label_map()) start_epoch = 0 # Initialize model model = SSD300(n_classes=n_classes) # Load checkpoint if existed checkpoint = None if checkpoint_path is not None and os.path.exists(checkpoint_path): checkpoint = torch.load(checkpoint_path) start_epoch = checkpoint['epoch'] + 1 print('Load checkpoint from epoch %d.\n' % checkpoint['epoch']) if checkpoint is not None: model.load_state_dict(checkpoint['model_state_dict']) model.to(device) model.train() # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay) if checkpoint is not None: optimizer.load_state_dict(checkpoint['optimizer_state_dict']) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) epochs = iterations // (len(train_ds) // batch_size) decay_lr_at_epochs = [it // (len(train_ds) // batch_size) for it in decay_lr_at] # Epochs for epoch in range(start_epoch, epochs): # Decay learning rate at particular epochs if epoch in decay_lr_at_epochs: utils.adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(train_loader, model, criterion, optimizer, epoch) # Save checkpoint utils.save_checkpoint(checkpoint_path, model, optimizer, epoch)
IoU = interArea / (boxAArea + boxBArea - interArea) # print(IoU,'\n',in_class,'\n',gt_class,'\n',in_coor,'\n',gt_coor) # class_acc = 1 if gt_class.item() == in_class.item() else 0 class_acc = 1 if (gt_class.item() == in_class.item()) and IoU > theta else 0 # print(class_acc,mean_IoU) return class_acc, IoU device = torch.device("cuda" if torch.cuda.is_available() else "cpu") batch_size = 1 data_encoder = DataEncoder() print('Loading model..') net = SSD300() net.load_state_dict(torch.load('./checkpoint/ssd300_ckpt.pth')['net']) net.to(device) net.eval() print('Preparing dataset..') transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ]) testset = ListDataset(root='/home/pzl/Data/tiny_vid', list_file="/home/pzl/Data/tiny_vid/test_images.txt", train=False, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at # initialize model or load checkpoint if checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) # initialize the optimizer, with twice the default learning rate... # ...for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train') train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # using `collate_fn()` here # calculate total number of epochs to train and the epochs to decay... # ...learning rate at (i.e. convert iterations to epochs) # to convert iterations to epochs,... # ...divide iterations by the number of iterations per epoch epochs = iterations // (len(train_dataset) // batch_size) decay_lr_at = [it // (len(train_dataset) // batch_size) for it in decay_lr_at] print(f"Training for {iterations} iterations...") print(f"Training for {epochs} epochs...") print(f"Batch size is {batch_size}") print(f"Logging every {print_freq} batches...") # logging into train.txt with open(file='../logs/train_logs.txt', mode='a+') as f: f.writelines(f"Training for {iterations} iterations...\n") f.writelines(f"Training for {epochs} epochs...\n") f.writelines(f"Batch size is {batch_size}\n") f.writelines(f"Logging every {print_freq} batches...\n") # epochs for epoch in range(start_epoch, epochs): # decay learning rate at particular epochs if epoch in decay_lr_at: adjust_learning_rate(optimizer, decay_lr_to) # logging into train.txt with open(file='../logs/train_logs.txt', mode='a+') as f: f.writelines(f"DECAYING learning rate.\n The new LR is {(optimizer.param_groups[1]['lr'],)}\n") # one epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # save checkpoint after each epoch save_checkpoint(epoch, model, optimizer)
def main(): """ Training and validation. """ global epochs_since_improvement, start_epoch, label_map, best_loss, epoch, checkpoint # Initialize model or load checkpoint if checkpoint is None: model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.RMSprop( params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay ) # rmsprop optimizer used according to spherenet paper else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] best_loss = checkpoint['best_loss'] print( '\nLoaded checkpoint from epoch %d. Best loss so far is %.3f.\n' % (start_epoch, best_loss)) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Custom dataloaders train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) val_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=True, collate_fn=val_dataset.collate_fn, num_workers=workers, pin_memory=True) # Epochs for epoch in range(start_epoch, epochs): # Paper describes decaying the learning rate at the 80000th, 100000th, 120000th 'iteration', i.e. model update or batch # The paper uses a batch size of 32, which means there were about 517 iterations in an epoch # Therefore, to find the epochs to decay at, you could do, # if epoch in {80000 // 517, 100000 // 517, 120000 // 517}: # adjust_learning_rate(optimizer, 0.1) # In practice, I just decayed the learning rate when loss stopped improving for long periods, # and I would resume from the last best checkpoint with the new learning rate, # since there's no point in resuming at the most recent and significantly worse checkpoint. # So, when you're ready to decay the learning rate, just set checkpoint = 'BEST_checkpoint_ssd300.pth.tar' above # and have adjust_learning_rate(optimizer, 0.1) BEFORE this 'for' loop # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # One epoch's validation val_loss = validate(val_loader=val_loader, model=model, criterion=criterion) # Did validation loss improve? is_best = val_loss < best_loss best_loss = min(val_loss, best_loss) if not is_best: epochs_since_improvement += 1 print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement, )) else: epochs_since_improvement = 0 # Save checkpoint save_checkpoint(epoch, epochs_since_improvement, model, optimizer, val_loss, best_loss, is_best)
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint_path, decay_lr_at, log_file # Initialize model or load checkpoint now = datetime.datetime.now().strftime('%m-%d_%H-%M-%S') if not os.path.exists(checkpoint_path): # create log file log_file = f'../logs/{now}.txt' start_epoch = 0 model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint_path) start_epoch = checkpoint['epoch'] + 1 log_file = checkpoint['log_file'] if not os.path.exists(log_file): log_file = f'../logs/{now}.txt' log_and_print(log_file, '\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Custom dataloaders train_dataset = BDD100KDataset(IMAGE_DIR, JSON_DIR, split='train', valid_proportion=valid_proportion) train_loader, val_loader = get_train_valid_dataloaders( batch_size, valid_proportion=valid_proportion, image_dir=IMAGE_DIR, json_dir=JSON_DIR, num_workers=4, model='ssd') # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs) # To convert iterations to epochs, divide iterations by the number of iterations per epoch # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations epochs = iterations // (len(train_dataset) // 32) decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at] # Epochs for epoch in range(start_epoch, epochs + 10): # Decay learning rate at particular epochs if epoch in decay_lr_at: adjust_learning_rate(optimizer, decay_lr_to) # One epoch's training train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) evaluate(val_loader, model) # Save checkpoint save_checkpoint(epoch, model, optimizer, log_file)
def train(): set_seed(seed=10) os.makedirs(args.save_root, exist_ok=True) # create model, optimizer and criterion model = SSD300(n_classes=len(label_map), device=device) biases = [] not_biases = [] for name, param in model.named_parameters(): if param.requires_grad: if name.endswith('.bias'): biases.append(param) else: not_biases.append(param) model = model.to(device) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * args.lr }, { 'params': not_biases }], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.resume is None: start_epoch = 0 else: checkpoint = torch.load(args.resume, map_location=device) start_epoch = checkpoint['epoch'] + 1 model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) print(f'Training will start at epoch {start_epoch}.') criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy, device=device, alpha=args.alpha) criterion = criterion.to(device) ''' scheduler = StepLR(optimizer=optimizer, step_size=20, gamma=0.5, last_epoch=start_epoch - 1, verbose=True) ''' # load data transform = Transform(size=(300, 300), train=True) train_dataset = VOCDataset(root=args.data_root, image_set=args.image_set, transform=transform, keep_difficult=True) train_loader = DataLoader(dataset=train_dataset, collate_fn=collate_fn, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=True, pin_memory=True) losses = AverageMeter() for epoch in range(start_epoch, args.num_epochs): # decay learning rate at particular epochs if epoch in [120, 140, 160]: adjust_learning_rate(optimizer, 0.1) # train model model.train() losses.reset() bar = tqdm(train_loader, desc='Train the model') for i, (images, bboxes, labels, _) in enumerate(bar): images = images.to(device) bboxes = [b.to(device) for b in bboxes] labels = [l.to(device) for l in labels] predicted_bboxes, predicted_scores = model( images) # (N, 8732, 4), (N, 8732, num_classes) loss = criterion(predicted_bboxes, predicted_scores, bboxes, labels) optimizer.zero_grad() loss.backward() optimizer.step() losses.update(loss.item(), images.size(0)) if i % args.print_freq == args.print_freq - 1: bar.write(f'Average Loss: {losses.avg:.4f}') bar.write(f'Epoch: [{epoch + 1}|{args.num_epochs}] ' f'Average Loss: {losses.avg:.4f}') # adjust learning rate # scheduler.step() # save model state_dict = { 'epoch': epoch, 'model': model.state_dict(), 'optimizer': optimizer.state_dict() } save_path = os.path.join(args.save_root, 'ssd300.pth') torch.save(state_dict, save_path) if epoch % args.save_freq == args.save_freq - 1: shutil.copyfile( save_path, os.path.join(args.save_root, f'ssd300_epochs_{epoch + 1}.pth'))
def main(): """ Training and validation. """ global epochs_since_improvement, start_epoch, label_map, best_loss, epoch, checkpoint # Initialize model or load checkpoint if checkpoint is None: model = SSD300(n_classes=n_classes) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) # optimizer = torch.optim.Adam(model.parameters(), lr=lr, betas=(0.9, 0.99)) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Custom dataloaders train_dataset = ICDARDataset(data_folder, split='train') val_dataset = ICDARDataset(data_folder, split='test') train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=True, collate_fn=val_dataset.collate_fn, num_workers=workers, pin_memory=True) # Epochs for epoch in range(start_epoch, epochs): # One epoch's training train_loss = train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # One epoch's validation val_loss = validate(val_loader=val_loader, model=model, criterion=criterion) # Did validation loss improve? is_best = val_loss < best_loss best_loss = min(val_loss, best_loss) if not is_best: epochs_since_improvement += 1 print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement, )) else: epochs_since_improvement = 0 # Save checkpoint save_checkpoint(epoch, epochs_since_improvement, model, optimizer, val_loss, best_loss, is_best) with open('log.txt', 'a+') as f: f.write('epoch:' + str(epoch) + ' train loss:' + str(train_loss) + ' val loss:' + str(val_loss) + '\n')
def main(): global start_epoch, label_map, epoch, checkpoint, decay_lr_at # Инициализация модели или загрузка чекпоинта if checkpoint is None: start_epoch = 0 model = SSD300(n_classes=n_classes) biases = list() not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) else: not_biases.append(param) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model = checkpoint['model'] optimizer = checkpoint['optimizer'] model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Загрузчики данных train_dataset = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # Вычисление количесвта эпох epochs = iterations // (len(train_dataset) // batch_size) decay_lr_at = [ it // (len(train_dataset) // batch_size) for it in decay_lr_at ] # Эпохи for epoch in range(start_epoch, epochs): # Уменьшение скорости обучения if epoch in decay_lr_at: adjust_learning_rate(optimizer, decay_lr_to) # OОбучение в течении одной эпохи train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # Сохранение чекпоинта save_checkpoint(epoch, model, optimizer)
# Parameters keep_difficult = True # difficult ground truth objects must always be considered in mAP calculation, because these objects DO exist! workers = 4 device = torch.device( f"cuda:{args.gpu}" if torch.cuda.is_available() else "cpu") # Load model checkpoint that is to be evaluated if args.checkpoint == 'pretrained_ssd300.pth.tar': checkpoint = torch.load(args.checkpoint) model = checkpoint['model'] for m in model.modules(): if 'Conv' in str(type(m)): setattr(m, 'padding_mode', 'zeros') else: checkpoint = torch.load(args.checkpoint) model = SSD300(n_classes=len(label_map)) model.load_state_dict(checkpoint['model']) model = model.to(device) # Switch to eval mode model.eval() # Load test data test_dataset = PascalVOCDataset(args.data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=args.batch_size, shuffle=False, collate_fn=test_dataset.collate_fn,