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()
