def load_models(model_filenames, device=None): models = [] for filename in model_filenames: model = M.ResNet34() modelfile = str(model_dir / filename) weight = torch.load(modelfile) model.load_state_dict(weight) model.to(device) model.eval() models.append(model) print(f'Loaded: {modelfile}') return models
def main(): args = parse_args() train_dataset, test_dataset = dataset.get_dataset(args.path, args.use_augmentation, args.use_fivecrop) train_loader = DataLoader(train_dataset, args.batch, True, num_workers=args.worker, pin_memory=True) test_loader = DataLoader(test_dataset, args.batch, False, num_workers=args.worker, pin_memory=True) if args.cuda: torch.cuda.set_device(0) device = torch.device('cuda') else: device = torch.device('cpu') if args.model == 'ResNet18': mymodel = model.ResNet18(args.frozen_layers).to(device) elif args.model == 'ResNet34': mymodel = model.ResNet34(args.frozen_layers).to(device) elif args.model == 'ResNet50': mymodel = model.ResNet50(args.frozen_layers).to(device) elif args.model == 'DenseNet': mymodel = model.DenseNet().to(device) else: pass op = optim.Adam(mymodel.parameters(), lr=args.lr) train_losses, test_mF1s, test_precisions, test_recalls = [], [], [], [] early = args.early for i in range(args.epoch): train_loss = train.train(mymodel, op, train_loader, i, device, args.log, utils.pos_weight) mF1, recall, presicion = test.test(mymodel, test_loader, device, args.use_fivecrop) train_losses.append(train_loss) test_mF1s.append(mF1) test_precisions.append(presicion) test_recalls.append(recall) early = utils.early_stop(test_mF1s, early) if early <= 0: break utils.save_log(mymodel, train_losses, test_mF1s, test_precisions, test_recalls)
batch_size=args.batch_size, shuffle=True, num_workers=20) NUM_CLASSES = DATASET.num_classes print('Data path: ' + args.data_path) print('Number of classes: %d' % NUM_CLASSES) print('Batch size: %d' % args.batch_size) print('Epoch size: %d' % args.epoch_size) num_batches = len(DATALOADER) batch_total = num_batches * args.epoch_size if args.model == 'ResNet18': MODEL = model.ResNet18(pseudo=args.pseudo) elif args.model == 'ResNet34': MODEL = model.ResNet34(pseudo=args.pseudo) elif args.model == 'ResNet50': MODEL = model.ResNet50(pseudo=args.pseudo) elif args.model == 'ResNet101': MODEL = model.ResNet101(pseudo=args.pseudo) ARCFACE = lossfunction.Arcface(512, NUM_CLASSES) if args.optim == 'Adam': OPTIMIZER = torch.optim.Adam([{ 'params': MODEL.parameters() }, { 'params': ARCFACE.parameters() }], lr=1e-4) SCHEDULER = torch.optim.lr_scheduler.MultiStepLR(OPTIMIZER,
from torch.optim.lr_scheduler import ReduceLROnPlateau from pre_process import transform_train, transform_test # whether use gpu use_cuda = torch.cuda.is_available() # default parameters DATA_ROOT = '../data/' num_epochs = 50 batch_size = 128 model_names = { 'dnn': model.DNN(3072, 4096, 10), 'cnn': model.CNN(), 'resnet18': model.ResNet18(), 'resnet34': model.ResNet34(), 'resnet50': model.ResNet50() } def get_args(): parser = argparse.ArgumentParser() parser.add_argument('--model_type', type=str, default='dnn', help="the type of model") parser.add_argument('--lr', type=float, default=0.1, help='the initial learning rate') parser.add_argument('--batch_size',
def main(args): #device configuration if args.cpu != None: device = torch.device('cpu') elif args.gpu != None: if not torch.cuda_is_available(): print("GPU / cuda reported as unavailable to torch") exit(0) device = torch.device('cuda') else: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Create model directory if not os.path.exists(args.model_save_dir): os.makedirs(args.model_save_dir) train_data = ld.get_data(labels_file=args.labels_file, root_dir=args.train_image_dir, mode="absolute") validation_data = ld.get_data(labels_file=args.labels_file, root_dir=args.validation_image_dir, mode="absolute") train_loader = DataLoader(dataset=train_data, batch_size=args.batch_size, shuffle=True) val_loader = DataLoader(dataset=validation_data, batch_size=args.validation_batch_size) # Build the models if args.num_layers != None and args.block_type != None: if args.block_type == "bottleneck": net = model.ResNet(model.Bottleneck, args.num_layers, dropout=args.dropout) else: net = model.ResNet(model.BasicBlock, args.num_layers, dropout=args.dropout) else: if args.resnet_model == 152: net = model.ResNet152(args.dropout) elif args.resnet_model == 101: net = model.ResNet101(args.dropout) elif args.resnet_model == 50: net = model.ResNet50(args.dropout) elif args.resnet_model == 34: net = model.ResNet34(args.dropout) else: net = model.ResNet101(args.dropout) #load the model to the appropriate device net = net.to(device) params = net.parameters() # Loss and optimizer criterion = nn.MSELoss() #best for regression if args.optim != None: if args.optim == "adadelta": optimizer = torch.optim.Adadelta(params, lr=args.learning_rate) if args.optim == "adagrad": optimizer = torch.optim.Adagrad(params, lr=args.learning_rate) if args.optim == "adam": optimizer = torch.optim.Adam(params, lr=args.learning_rate) if args.optim == "adamw": optimizer = torch.optim.AdamW(params, lr=args.learning_rate) if args.optim == "rmsprop": optimizer = torch.optim.RMSProp(params, lr=args.learning_rate) if args.optim == "sgd": optimizer = torch.optim.SGD(params, lr=args.learning_rate) else: optimizer = torch.optim.Adam(params, lr=args.learning_rate) val_acc_history = [] train_acc_history = [] failed_runs = 0 prev_loss = float("inf") for epoch in range(args.num_epochs): running_loss = 0.0 total_loss = 0.0 for i, (inputs, labels) in enumerate(train_loader, 0): net.train() #adjust to output image coordinates inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = net(inputs.float()) loss = criterion(outputs.float(), labels.float()) loss.backward() torch.nn.utils.clip_grad_norm_(net.parameters(), args.clipping_value) optimizer.step() running_loss += loss.item() total_loss += loss.item() if i % 2 == 0: #print every mini-batches print('[%d, %5d] loss: %.5f' % (epoch + 1, i + 1, running_loss / 2)) running_loss = 0.0 loss = 0.0 #compute validation loss at the end of the epoch for i, (inputs, labels) in enumerate(val_loader, 0): inputs, labels = inputs.to(device), labels.to(device) net.eval() with torch.no_grad(): outputs = net(inputs.float()) loss += criterion(outputs, labels.float()).item() print("------------------------------------------------------------") print("Epoch %5d" % (epoch + 1)) print("Training loss: {}, Avg Loss: {}".format( total_loss, total_loss / train_data.__len__())) print("Validation Loss: {}, Avg Loss: {}".format( loss, loss / validation_data.__len__())) print("------------------------------------------------------------") val_acc_history.append(loss) train_acc_history.append(total_loss) #save the model at the desired step if (epoch + 1) % args.save_step == 0: torch.save(net.state_dict(), args.model_save_dir + "resnet" + str(epoch + 1) + ".pt") ##stopping conditions if failed_runs > 5 and prev_loss < loss: break elif prev_loss < loss: failed_runs += 1 else: failed_runs = 0 prev_loss = loss #create a plot of the loss plt.title("Training vs Validation Accuracy") plt.xlabel("Training Epochs") plt.ylabel("Loss") plt.plot(range(1, len(val_acc_history) + 1), val_acc_history, label="Validation loss") plt.plot(range(1, len(train_acc_history) + 1), train_acc_history, label="Training loss") plt.xticks(np.arange(1, len(train_acc_history) + 1, 1.0)) plt.legend() plt.ylim((0, max([max(val_acc_history), max(train_acc_history)]))) if args.save_training_plot != None: plt.savefig(args.save_training_plot + "loss_plot.png") plt.show() print('Finished Training')