def main_worker(rank, args): args.rank = rank args = setup(args) loaders = Data(args).get_loader() model = Model(args) optimizer = Optimizer(args, model) if args.amp: model = optimizer.set_amp(model) model.parallelize() criterion = Loss(args, model=model, optimizer=optimizer) trainer = Trainer(args, model, criterion, optimizer, loaders) if args.stay: interact(local=locals()) exit() if args.demo: trainer.evaluate(epoch=args.startEpoch, mode='demo') exit() for epoch in range(1, args.startEpoch): if args.do_validate: if epoch % args.validate_every == 0: trainer.fill_evaluation(epoch, 'val') if args.do_test: if epoch % args.test_every == 0: trainer.fill_evaluation(epoch, 'test') for epoch in range(args.startEpoch, args.endEpoch + 1): if args.do_train: trainer.train(epoch) if args.do_validate: if epoch % args.validate_every == 0: if trainer.epoch != epoch: trainer.load(epoch) trainer.validate(epoch) if args.do_test: if epoch % args.test_every == 0: if trainer.epoch != epoch: trainer.load(epoch) trainer.test(epoch) if args.rank == 0 or not args.launched: print('') trainer.imsaver.join_background() cleanup(args)
def main(): data_transformer = DataTransformer(config.dataset_path, use_cuda=config.use_cuda) vanilla_encoder = VanillaEncoder( vocab_size=data_transformer.vocab_size, embedding_size=config.encoder_embedding_size, output_size=config.encoder_output_size) vanilla_decoder = VanillaDecoder( hidden_size=config.decoder_hidden_size, output_size=data_transformer.vocab_size, max_length=data_transformer.max_length, teacher_forcing_ratio=config.teacher_forcing_ratio, sos_id=data_transformer.SOS_ID, use_cuda=config.use_cuda) if config.use_cuda: vanilla_encoder = vanilla_encoder.cuda() vanilla_decoder = vanilla_decoder.cuda() seq2seq = Seq2Seq(encoder=vanilla_encoder, decoder=vanilla_decoder) trainer = Trainer(seq2seq, data_transformer, config.learning_rate, config.use_cuda) trainer.load_model() while (True): testing_word = input('You say: ') if testing_word == "exit": break results = trainer.evaluate(testing_word) print("Model says: %s" % results[0])
def main(): parser = Parser() config = parser.config for param, value in config.__dict__.items(): print(param + '.' * (50 - len(param) - len(str(value))) + str(value)) print() # Load previous checkpoint if it exists checkpoint = load_latest(config) # Create model model = load_model(config, checkpoint) # print number of parameters in the model n_params = sum([param.view(-1).size()[0] for param in model.parameters()]) print('Total number of parameters: \33[91m{}\033[0m'.format(n_params)) # Load train and test data train_loader, valid_loader, test_loader = Loader(config) n_batches = int(len(train_loader.dataset.train_data) / config.batch_size) # save the configuration with open(os.path.join(config.save, 'log.txt'), 'w') as file: json.dump('json_stats: ' + str(config.__dict__), file) # Instantiate the criterion, optimizer and learning rate scheduler criterion = torch.nn.CrossEntropyLoss(size_average=True) optimizer = torch.optim.SGD(model.parameters(), lr=config.LR, momentum=config.momentum, weight_decay=config.weight_decay, nesterov=config.nesterov) start_time = 0 if checkpoint is not None: start_epoch = checkpoint['time'] + 1 optimizer.load_state_dict(checkpoint['optimizer']) if config.lr_shape == 'multistep': scheduler = MultiStepLR(optimizer, milestones=[81, 122], gamma=0.1) elif config.lr_shape == 'cosine': if checkpoint is not None: scheduler = checkpoint['scheduler'] else: scheduler = CosineAnnealingRestartsLR(optimizer, 1, config.T_e, T_mul=config.T_mul) # The trainer handles the training loop and evaluation on validation set trainer = Trainer(model, criterion, config, optimizer, scheduler) epoch = 1 while True: # Train for a single epoch train_top1, train_loss, stop_training = trainer.train( epoch, train_loader) # Run model on the validation and test set valid_top1 = trainer.evaluate(epoch, valid_loader, 'valid') test_top1 = trainer.evaluate(epoch, test_loader, 'test') current_time = time.time() results = { 'epoch': epoch, 'time': current_time, 'train_top1': train_top1, 'valid_top1': valid_top1, 'test_top1': test_top1, 'train_loss': float(train_loss.data), } with open(os.path.join(config.save, 'results.txt'), 'w') as file: json.dump(str(results), file) file.write('\n') print( '==> Finished epoch %d (budget %.3f): %7.3f (train) %7.3f (validation) %7.3f (test)' % (epoch, config.budget, train_top1, valid_top1, test_top1)) if stop_training: break epoch += 1 if start_time >= config.budget: trainer.evaluate(epoch, test_loader, 'test') else: save_checkpoint(int(config.budget), trainer.model, trainer.optimizer, trainer.scheduler, config)
cfg = Config() # create dataset train_dataset = DatasetTrain( cityscapes_data_path="/home/shen/Data/DataSet/Cityscape", cityscapes_meta_path="/home/shen/Data/DataSet/Cityscape/gtFine/") val_dataset = DatasetVal( cityscapes_data_path="/home/shen/Data/DataSet/Cityscape", cityscapes_meta_path="/home/shen/Data/DataSet/Cityscape/gtFine") train_loader = DataLoader( dataset=train_dataset, batch_size=10, shuffle=True, num_workers=8) val_loader = DataLoader( dataset=val_dataset, batch_size=10, shuffle=False, num_workers=8) net = dfanet(pretrained=True, num_classes=20) # load loss criterion = CrossEntropyLoss() optimizer = optim.SGD( net.parameters(), lr=0.1, momentum=0.9, weight_decay=0.00001) # select the optimizer lr_fc = lambda iteration: (1 - iteration / 400000)**0.9 exp_lr_scheduler = lr_scheduler.LambdaLR(optimizer, lr_fc, -1) trainer = Trainer('training', optimizer, exp_lr_scheduler, net, cfg, './log') trainer.load_weights(trainer.find_last()) trainer.train(train_loader, val_loader, criterion, 1500) trainer.evaluate(val_loader) print('Finished Training')
parser.add_argument('--dataset', type=str, default='Electronics') args = parser.parse_args() print(args) dataset = RecSysDataset(args.dataset) if args.algorithm == "vbpr": model = VBPR(dataset.n_users, dataset.n_items, dataset.corpus.image_features, args.k, args.k2) elif args.algorithm == "vbprc": model = VBPRC(dataset.n_users, dataset.n_items, dataset.n_categories, dataset.corpus.image_features, dataset.corpus.item_category, args.k, args.k2) elif args.algorithm == "deepstyle": model = DeepStyle(dataset.n_users, dataset.n_items, dataset.n_categories, dataset.corpus.image_features, dataset.corpus.item_category, args.k) elif args.algorithm == "bpr": model = BPR(dataset.n_users, dataset.n_items, args.k) model.load( f'../data/dataset/{args.dataset}/models/{args.algorithm}_resnet50.pth') tr = Trainer(model, dataset) print(tr.evaluate())
def main(args): if args.dataset == "cityscapes": train_dataset = DatasetTrain(cityscapes_data_path="/home/chenxiaoshuang/Cityscapes", cityscapes_meta_path="/home/chenxiaoshuang/Cityscapes/gtFine", only_encode=args.only_encode, extra_data=args.extra_data) val_dataset = DatasetVal(cityscapes_data_path="/home/chenxiaoshuang/Cityscapes", cityscapes_meta_path="/home/chenxiaoshuang/Cityscapes/gtFine", only_encode=args.only_encode) test_dataset = DatasetTest(cityscapes_data_path="/home/chenxiaoshuang/Cityscapes", cityscapes_meta_path="/home/chenxiaoshuang/Cityscapes/gtFine") train_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=8, drop_last=True) val_loader = DataLoader(dataset=val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=8) test_loader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=8) num_classes = 20 elif args.dataset == "camvid": train_dataset = DatasetCamVid(camvid_data_path="/home/chenxiaoshuang/CamVid", camvid_meta_path="/home/chenxiaoshuang/CamVid", only_encode=args.only_encode, mode="train") val_dataset = DatasetCamVid(camvid_data_path="/home/chenxiaoshuang/CamVid", camvid_meta_path="/home/chenxiaoshuang/CamVid", only_encode=args.only_encode, mode="val") test_dataset = DatasetCamVid(camvid_data_path="/home/chenxiaoshuang/CamVid", camvid_meta_path="/home/chenxiaoshuang/CamVid", only_encode=args.only_encode, mode="test") train_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=8, drop_last=True) val_loader = DataLoader(dataset=val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=8) test_loader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=8) num_classes = 12 else: print("Unsupported Dataset!") return device = torch.device("cuda:{}".format(args.cuda) if torch.cuda.is_available() else "cpu") device_ids = [args.cuda, args.cuda+1] cfg=Config(args.dataset, args.only_encode, args.extra_data) net = Net(num_classes=num_classes) if torch.cuda.is_available(): weight = cfg.weight.to(device) criterion1 = CrossEntropyLoss2d(weight) criterion2 = LovaszSoftmax(weight=weight) optimizer = optim.Adam(net.parameters(), 5e-4, (0.9, 0.999), eps=1e-08, weight_decay=1e-4) lambda1 = lambda epoch : (1 - epoch/300) ** 0.9 exp_lr_scheduler = lr_scheduler.LambdaLR(optimizer,lr_lambda=lambda1) trainer = Trainer('training', optimizer, exp_lr_scheduler, net, cfg, './log', device, device_ids, num_classes) trainer.load_weights(trainer.find_last(), encode=False, restart=False) #trainer.train(train_loader, val_loader, criterion1, criterion2, 300) trainer.evaluate(val_loader) trainer.test(test_loader) print('Finished Training')
max_seq_len = args.max_seq_len batch_size = args.batch_size num_epochs = args.num_epochs lr = args.lr lr_scheduler = args.lr_scheduler val_every = args.val_every num_workers = args.num_workers restore_checkpoint = args.restore_checkpoint if train == True and text is None: logging.info("***** Training process *****") training = Trainer(restore_checkpoint, data_from_server, num_workers, name, max_seq_len, batch_size, num_epochs, lr_scheduler, lr, val_every) training.train() # Evaluate and save results of the model for the training set in result folder training.evaluate(training.train_data_loader, "training") # Evaluate and save results of the model for the validation set in result folder training.evaluate(training.train_data_loader, "val") # Evaluate and save results of the model for the test set in result folder training.evaluate(training.train_data_loader, "test") elif train == False and text is not None: logging.info("***** Prediction process *****") predictor = Predictor(name) predictor.predict(text) else: raise ValueError( "You have to make a choice between train or predict arguments")
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.1) # create the train_dataset_loader and val_dataset_loader. train_tarnsformed_dataset = CloudDataset(img_dir='data/images224', labels_dir='data/masks224/', transform=transforms.Compose( [ToTensor()])) val_tarnsformed_dataset = CloudDataset(img_dir='data/images224', labels_dir='data/masks224/', val=True, transform=transforms.Compose( [ToTensor()])) train_dataloader = DataLoader(train_tarnsformed_dataset, batch_size=8, shuffle=True, num_workers=4) val_dataloader = DataLoader(val_tarnsformed_dataset, batch_size=8, shuffle=True, num_workers=4) trainer = Trainer('training', optimizer, exp_lr_scheduler, net, cfig, './log') trainer.load_weights(trainer.find_last()) trainer.train(train_dataloader, val_dataloader, criterion, 150) trainer.evaluate(val_dataloader) print('Finished Training')
drop_last=False, ) else: test_loader = None dataset = {'train': train_loader, 'val': val_loader, 'test': test_loader} gen = Generator(args.n_resblocks, args.n_features, args.kernel_size, args.n_scales).cuda() adv = Adversary(args.n_features, args.kernel_size).cuda() optim_adv = optim.Adam(adv.parameters(), lr=args.lr) scheduler_adv = lrs.MultiStepLR(optim_adv, milestones=args.milestones, gamma=args.gamma) optim_gen = optim.Adam(gen.parameters(), lr=args.lr) scheduler_gen = lrs.MultiStepLR(optim_gen, milestones=args.milestones, gamma=args.gamma) optimizer = {'adv': optim_adv, 'gen': optim_gen} scheduler = {'adv': scheduler_adv, 'gen': scheduler_gen} model = {'adv': adv, 'gen': gen} trainer = Trainer(args, model, optimizer, scheduler, dataset) if args.do_train: trainer.train() trainer.plot() if args.do_test: trainer.evaluate('test') trainer.save()