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 load(checkpoint): # Load model checkpoint that is to be evaluated checkpoint = torch.load(checkpoint) model = checkpoint['model'] model = model.to(device) # Switch to eval mode model.eval() # Load test data test_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) return test_loader, model
def main(): """ Training. """ # Initialize model and optimizer model = tiny_detector(n_classes=n_classes) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy) optimizer = torch.optim.SGD(params=model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay) # Move to default device model = model.to(device) criterion = criterion.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 # Epochs for epoch in range(total_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(): 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)
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)
from model import SSD300 from datasets import PascalVOCDataset import utils from tqdm import tqdm device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Parameters keep_difficult = True # difficult ground truth objects must always be considered in mAP calculation, because these objects DO exist! batch_size = 64 workers = 4 checkpoint_path = 'ssd300.pt' # Load test data test_dataset = PascalVOCDataset('./data', split='TEST', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) n_classes = len(test_dataset.label_map()) # Load model checkpoint that is to be evaluated checkpoint = torch.load(checkpoint_path) model = SSD300(n_classes) model.load_state_dict(checkpoint['model_state_dict']) model = model.to(device) # Switch to eval mode model.eval() def evaluate(test_loader, model):
momentum=momentum, weight_decay=weight_decay) if args.checkpoint: checkpoint = torch.load(args.checkpoint) start_epoch = checkpoint['epoch'] + 1 print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) # Move to default device model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device) # Custom dataloaders train_dataset = PascalVOCDataset(args.data_folder, split='train', keep_difficult=keep_difficult) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.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) # Epochs
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)
print('\nMean Average Precision (mAP): %.3f' % mAP) return mAP if __name__ == '__main__': data_folder = './data' batch_size = 64 workers = 4 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") checkpoint = './combine_checkpoint_ssd352.pth.tar' # Load model checkpoint that is to be evaluated checkpoint = torch.load(checkpoint) model = checkpoint['model'] model = model.to(device) # Switch to eval mode model.eval() # Load test data test_dataset = PascalVOCDataset(data_folder, split='test') test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) evaluate(test_loader, model)
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at, best_mAP # 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(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=internal_batchsize, shuffle=True, collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True) # note that we're passing the collate function here # Load test data test_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=internal_batchsize, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) # 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) // internal_batchsize) # print('Length of dataset:', len(train_dataset), epochs) decay_lr_at = [ it // (len(train_dataset) // internal_batchsize) for it in decay_lr_at ] print('total train epochs: ', epochs, ' training starts ......') # Epochs best_mAP = -1. # criterion.increase_threshold() # print('current threshold: ', criterion.threshold) 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) # _, current_mAP = evaluate(test_loader, model) train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch) # Save checkpoint if epoch >= 30 and epoch % 30 == 0 or epoch == 5: _, current_mAP = evaluate(test_loader, model) if current_mAP > best_mAP: save_checkpoint( epoch, model, optimizer, name='checkpoints/my_checkpoint_topo_anchor_b32.pth.tar') best_mAP = current_mAP # criterion.increase_threshold(0.05) # elif epoch == 50: # save_checkpoint(epoch, model, optimizer, name='checkpoints/my_checkpoint_rep300_b32.pth.tar') _, current_mAP = evaluate(test_loader, model) if current_mAP > best_mAP: save_checkpoint( epoch, model, optimizer, name='checkpoints/my_checkpoint_topo_anchor_b32.pth.tar') best_mAP = current_mAP
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 evaluate(checkpoint, run_colab, batch_size, set, subset): """ Evaluate. :param test_loader: DataLoader for test data :param model: model """ data_folder = create_data_lists(run_colab) test_dataset = PascalVOCDataset(data_folder, split=set, keep_difficult=keep_difficult) if subset > 0: test_dataset.images = test_dataset.images[:subset] test_dataset.objects = test_dataset.objects[:subset] test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) # Load model checkpoint that is to be evaluated checkpoint = torch.load(checkpoint, map_location=device) model = checkpoint['model'] print(f"Number of epoch trained: {checkpoint['epoch']}") model = model.to(device) # Switch to eval mode model.eval() # Make sure it's in eval mode model.eval() # Lists to store detected and true boxes, labels, scores det_boxes = list() det_labels = list() det_scores = list() true_boxes = list() true_labels = list() true_difficulties = list( ) # it is necessary to know which objects are 'difficult', see 'calculate_mAP' in utils.py with torch.no_grad(): # Batches for i, (images, boxes, labels, difficulties) in enumerate(tqdm(test_loader, desc='Evaluating')): images = images.to(device) # (N, 3, 300, 300) # Forward prop. predicted_locs, predicted_scores = model(images) # Detect objects in SSD output det_boxes_batch, det_labels_batch, det_scores_batch = model.detect_objects( predicted_locs, predicted_scores, min_score=0.01, max_overlap=0.45, top_k=200) # Evaluation MUST be at min_score=0.01, max_overlap=0.45, top_k=200 for fair comparision with the paper's results and other repos # Store this batch's results for mAP calculation boxes = [b.cpu() for b in boxes] labels = [l.cpu() for l in labels] difficulties = [d.cpu() for d in difficulties] det_boxes.extend([box.cpu() for box in det_boxes_batch]) det_labels.extend([label.cpu() for label in det_labels_batch]) det_scores.extend([score.cpu() for score in det_scores_batch]) true_boxes.extend(boxes) true_labels.extend(labels) true_difficulties.extend(difficulties) # Calculate mAP APs, mAP = calculate_mAP(det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties) # Print AP for each class pp.pprint(APs) print('\nMean Average Precision (mAP): %.3f' % mAP) model.train()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") checkpoint = './checkpoint_ssd300.pth.tar' # Load model checkpoint that is to be evaluated checkpoint = torch.load(checkpoint) model = checkpoint['model'] model = model.to(device) # Switch to eval mode model.eval() # Load test data create_data_lists('/content/data', '/content/data') test_dataset = PascalVOCDataset('/content/data', split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) def evaluate(test_loader, model): """ Evaluate. :param test_loader: DataLoader for test data :param model: model
def main(batch_size, continue_training, exp_name, learning_rate, num_epochs, print_freq, run_colab): # Data data_folder = create_data_lists(run_colab) train_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 # Networks checkpoint = torch.load(exp_name / "checkpoint_ssd300.pth.tar", map_location=device) print(f"Number of training epochs for detection network: {checkpoint['epoch']}") detection_network = checkpoint['model'] if continue_training: adversarial_checkpoint = torch.load(exp_name / checkpoint, map_location=device) discriminator = adversarial_checkpoint['adversarial_model'] optimizer = adversarial_checkpoint['optimizer'] start_epoch = adversarial_checkpoint['epoch'] print(f"Continue training of adversarial network from epoch {start_epoch}") else: start_epoch = 0 image_encoder = VGGBase() discriminator = Discriminator(num_classes) optimizer = torch.optim.Adam(list(discriminator.parameters()) + list(image_encoder.parameters()), lr=learning_rate, weight_decay=1e-5) discriminator, image_encoder = discriminator.to(device), image_encoder.to(device) loss_function = GANLoss('vanilla').to(device) losses = AverageMeter() # loss for epoch in range(start_epoch, num_epochs): for j, (images, boxes, labels, _) in enumerate(train_loader): images = images.to(device) _, image_embedding = image_encoder(images) random_box_indices = [np.random.randint(len(box)) for box in boxes] random_boxes = torch.stack([box[random_box_indices[i]] for i, box in enumerate(boxes)]).to(device) random_labels = torch.stack([one_hot_embedding(label[random_box_indices[i]], num_classes) for i, label in enumerate(labels)]).to(device) pred_real = discriminator(random_boxes, random_labels, image_embedding) loss_real = loss_function(pred_real, 1) with torch.no_grad(): predicted_locs, predicted_scores = detection_network.forward(images) pred_boxes, pred_labels, _ = detection_network.detect_objects(predicted_locs, predicted_scores, min_score=0.2, max_overlap=0.45, top_k=200) random_box_indices = [np.random.randint(len(box)) for box in pred_boxes] random_fake_boxes = torch.stack([box[random_box_indices[i]] for i, box in enumerate(pred_boxes)]).to(device) random_fake_labels = torch.stack([one_hot_embedding(label[random_box_indices[i]], num_classes) for i, label in enumerate(pred_labels)]).to(device) pred_fake = discriminator(random_fake_boxes, random_fake_labels, image_embedding) loss_fake = loss_function(pred_fake, 0) total_loss = loss_fake + loss_real optimizer.zero_grad() total_loss.backward() optimizer.step() losses.update(total_loss.item(), images.size(0)) if j % print_freq == 0: print('Epoch: [{0}][{1}/{2}]\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(epoch, j, len(train_loader), loss=losses)) save_adversarial_checkpoint(epoch, discriminator, image_encoder, optimizer, exp_name)
def evaluate(args): """ Evaluation scripts for exdark data. Refer to argparse arguments at teh end of the script """ # Load model checkpoint that is to be evaluated checkpoint = torch.load(args.checkpoint, map_location=device) model = checkpoint['model'] model = model.to(device) # Load test data test_dataset = PascalVOCDataset(args.data_folder, split='test', keep_difficult=keep_difficult) with open(args.exdark_metadata, "r") as fp: image_metadata = fp.read().splitlines() lighting_states = ['Low', 'Ambient', 'Object', 'Single', 'Weak', 'Strong', 'Screen', 'Window', 'Shadow', 'Twilight'] lighting_indices = [[] for i in range(10)] indoor_outdoor = ['Indoor', 'Outdoor'] location_indices = [[] for i in range(2)] for dataset_idx, _image in enumerate(test_dataset.images): for _metadata in image_metadata: metadata = _metadata.split(" ") if metadata[0].split(".")[0] == _image.split("/")[-1].split(".")[0]: lighting_indices[int(metadata[2]) - 1].append(dataset_idx) AP_dict = {} for state_idx, sets in enumerate(lighting_indices): print("\n \n Lighting State: ", lighting_states[state_idx]) subset = torch.utils.data.Subset(test_dataset, sets) test_loader = torch.utils.data.DataLoader(subset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) # Make sure it's in eval mode model.eval() # Lists to store detected and true boxes, labels, scores det_boxes = list() det_labels = list() det_scores = list() true_boxes = list() true_labels = list() true_difficulties = list() # it is necessary to know which objects are 'difficult', see 'calculate_mAP' in utils.py with torch.no_grad(): # Batches for i, (images, boxes, labels, difficulties) in enumerate(test_loader): images = images.to(device) # (N, 3, 300, 300) # Forward prop. predicted_locs, predicted_scores = model(images) # Detect objects in SSD output det_boxes_batch, det_labels_batch, det_scores_batch = model.detect_objects(predicted_locs, predicted_scores, min_score=args.min_score, max_overlap=0.45, top_k=200) # Evaluation MUST be at min_score=0.01, max_overlap=0.45, top_k=200 for fair comparision with the paper's results and other repos # Store this batch's results for mAP calculation boxes = [b.to(device) for b in boxes] labels = [l.to(device) for l in labels] difficulties = [d.to(device) for d in difficulties] det_boxes.extend(det_boxes_batch) det_labels.extend(det_labels_batch) det_scores.extend(det_scores_batch) true_boxes.extend(boxes) true_labels.extend(labels) true_difficulties.extend(difficulties) # Calculate aP for exdark and add to dictionary with lighting condition. APs = calculate_mAP_exdark(det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties) APs["lighting"] = lighting_states[state_idx] # Print AP for each class pp.pprint(APs) if AP_dict: for key in AP_dict: AP_dict[key].append(APs[key]) else: AP_dict = {} for key in APs: AP_dict[key] = [APs[key]] df = pd.DataFrame.from_dict(AP_dict) df.to_csv("{}_{}_results.csv".format(args.data_folder.split("/")[-1], args.min_score))
def main(args): # Model parameters # Not too many here since the SSD300 has a very specific structure with open(args.config_file_path, "r") as fp: config = json.load(fp) n_classes = len(label_map) # number of different types of objects device = torch.device("cuda" if torch.cuda.is_available() else "cpu") #Mobilenetv2 #normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) # Learning parameters checkpoint = None # path to model checkpoint, None if none batch_size = config['batch_size'] # batch size start_epoch = 0 # start at this epoch epochs = config[ 'n_epochs'] # number of epochs to run without early-stopping epochs_since_improvement = 0 # number of epochs since there was an improvement in the validation metric best_loss = 100. # assume a high loss at first workers = 2 # number of workers for loading data in the DataLoader lr = config['lr'] # learning rate momentum = 0.9 # momentum weight_decay = config['weight_decay'] # weight decay grad_clip = None # clip if g backbone_network = config['backbone_network'] model = SSD(num_classes=n_classes, backbone_network=backbone_network) # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo biases = list() not_biases = list() param_names_biases = list() param_names_not_biases = list() for param_name, param in model.named_parameters(): if param.requires_grad: if param_name.endswith('.bias'): biases.append(param) param_names_biases.append(param_name) else: not_biases.append(param) param_names_not_biases.append(param_name) optimizer = torch.optim.SGD(params=[{ 'params': biases, 'lr': 2 * lr }, { 'params': not_biases }], lr=lr, momentum=momentum, weight_decay=weight_decay) model = model.to(device) criterion = MultiBoxLoss(priors_cxcy=model.priors).to(device) #voc07_path = 'VOCdevkit/VOC2007' voc07_path = config['voc07_path'] #voc12_path = 'VOCdevkit/VOC2012' # voc12_path = config['voc12_path'] #from utils import create_data_lists create_data_lists(voc07_path, output_folder=config['data_folder']) #data_folder = 'VOC/VOCdevkit/' data_folder = config['data_folder'] 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) print(start_epoch) 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, grad_clip=grad_clip) # 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 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)
keep_difficult = True # 是否保留那些比较难检测的物体 n_classes = len(label_map) # Learning parameters batch_size = 8 # batch大小 iterations = 120000 # 一共要训的轮数 decay_lr_at = [80000, 100000] # 在这些轮的时候学习率乘以0.1 start_epoch = 0 # 开始epoch print_freq = 50 # train的时候,多少个iter打印一次信息 lr = 1e-3 # 学习率 momentum = 0.9 # SGD的momentum weight_decay = 5e-4 # SGD的weight_decay grad_clip = None # 设置是否要把梯度clamp到[-grad_clip, grad_clip],如果是None则不clip best_mAP = 0. # 记录当前最高mAP train_loader = PascalVOCDataset(data_folder, split='train', keep_difficult=keep_difficult, batch_size=batch_size, shuffle=True, data_argu=False) length = len(train_loader) // batch_size # 一个batch的iters epochs = iterations // (len(train_loader) // 32) # 原论文batch_size为32跑了120000个iters,由此计算出epoches decay_lr_at = [it // (len(train_loader) // 32) for it in decay_lr_at] # 并计算出需要降lr的epochs集合 val_loader = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult, batch_size=batch_size, shuffle=False) model = SSD300(n_classes=n_classes) biases = list() not_biases = list() for param in model.parameters(): if param.requires_grad: if param.name().endswith('.bias'):
data_folder = 'dataset/' keep_difficult = True batch_size = 47 pp = PrettyPrinter() # Define model & Load parameters experiment_id = "pretrain_model" 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') # Load test data test_loader = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult, batch_size=batch_size, shuffle=False) length = len(test_loader) // batch_size def evaluate(test_loader, model): """ Evaluate. Args: test_loader: DataLoader for test data model: model """ model.eval() det_boxes = list() det_labels = list() det_scores = list() true_boxes = list()
def main(): 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.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'] # 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): 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(): 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)
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(): # 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)
batch_size = 64 workers = 4 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") checkpoint = './data/checkpoint_ssd300.pth.tar' # Load model checkpoint that is to be evaluated checkpoint = torch.load(checkpoint) model = checkpoint['model'] model = model.to(device) # Switch to eval mode model.eval() # Load test data test_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) def evaluate(test_loader, model): """ Evaluate. :param test_loader: DataLoader for test data :param model: model """ # Make sure it's in eval mode
def evaluate(data_folder, model_checkpoint): """ Evaluate. :param test_loader: DataLoader for test data :param model: model """ if torch.cuda.is_available() == True: checkpoint = torch.load(model_checkpoint, map_location=torch.device('cpu')) else: checkpoint = torch.load(model_checkpoint) model = checkpoint['model'] model = model.to(device) # Make sure it's in eval mode model.eval() # Load test data test_dataset = PascalVOCDataset(data_folder, split='test', keep_difficult=keep_difficult) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) # Lists to store detected and true boxes, labels, scores det_boxes = list() det_labels = list() det_scores = list() true_boxes = list() true_labels = list() true_difficulties = list( ) # it is necessary to know which objects are 'difficult', see 'calculate_mAP' in utils.py with torch.no_grad(): # Batches for i, (images, boxes, labels, difficulties) in enumerate(tqdm(test_loader, desc='Evaluating')): images = images.to(device) # (N, 3, 300, 300) # Forward prop. predicted_locs, predicted_scores = model(images) # Detect objects in SSD output det_boxes_batch, det_labels_batch, det_scores_batch = model.detect_objects( predicted_locs, predicted_scores, min_score=0.01, max_overlap=0.45, top_k=200) # Evaluation MUST be at min_score=0.01, max_overlap=0.45, top_k=200 for fair comparision with the paper's results and other repos # Store this batch's results for mAP calculation boxes = [b.to(device) for b in boxes] labels = [l.to(device) for l in labels] difficulties = [d.to(device) for d in difficulties] det_boxes.extend(det_boxes_batch) det_labels.extend(det_labels_batch) det_scores.extend(det_scores_batch) true_boxes.extend(boxes) true_labels.extend(labels) true_difficulties.extend(difficulties) # Calculate mAP APs, mAP = calculate_mAP(det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties) # Print AP for each class pp.pprint(APs) print('\nMean Average Precision (mAP): %.3f' % mAP)
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)
def main(): """ Training. """ global start_epoch, label_map, epoch, checkpoint, decay_lr_at, rev_label_map # 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) # Load test data #create_data_lists('/content/data', '/content/data') train_dataset = PascalVOCDataset('/content/data/images', '/content/data/output.json', split='train', keep_difficult=keep_difficult) test_dataset = PascalVOCDataset('/content/data/images', '/content/data/output.json', split='test', keep_difficult=keep_difficult) # half = int(len(train_dataset)/2) # # split the dataset in train and test set # torch.manual_seed(1) # indices = torch.randperm(len(train_dataset)).tolist() # #print(indices) # train_dataset = torch.utils.data.Subset(train_dataset, indices[:-half]) # test_dataset = torch.utils.data.Subset(test_dataset, indices[-half:]) 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_loader = torch.utils.data.DataLoader( test_dataset, batch_size=batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=workers, pin_memory=True) # Custom train dataloaders #create_data_lists('/content/data', '/content/data') # train_dataset = PascalVOCDataset('/content/data', # split='train', # keep_difficult=keep_difficult) #print(train_dataset[0]) # 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) // 2) epochs = 1 decay_lr_at = [it // (len(train_dataset) // 2) for it in decay_lr_at] prev_mAP = 0.0 # 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, device=device) _, mAP = evaluate(test_loader, model, device) # Save checkpoint save_checkpoint(epoch, model, optimizer) # save best checkpoint, having best mean average precision if prev_mAP < mAP: prev_mAP = mAP save_best_checkpoint(epoch, model, optimizer)