def train(cfg): train_loader = construct_loader(cfg, train=True) val_loader = construct_loader(cfg, train=False) model = build_model(cfg) optimizer = construct_optimizer(model, cfg) for epoch in range(cfg.TRAIN.MAX_EPOCH): shuffle_dataset(train_loader, epoch) train_epoch(train_loader, model, optimizer, epoch, cfg) eval_epoch(val_loader, model, epoch, cfg) save_checkpoint(model, optimizer, epoch, cfg)
def main(fin, logdir): folders = list(Path(fin).glob("*/*")) ftrain, ftest = train_test_split(folders, random_state=SEED) train = RawDataset(ftrain, transform=transform(train=True)) test = RawDataset(ftest, transform=transform(train=False)) model = build_model( max_epochs=50, logdir=logdir, train_split=predefined_split(test), ) model.fit(train) th = np.arange(0.1, 0.9, 0.01) mean, std = model.thresholds(test, partial(dice, th=th)) plot(mean, thresholds=th)
def main(fin, logdir): with open(fin) as f: folders = json.load(f) train = RawDataset(folders["train"], transform=transform(train=True)) test = RawDataset(folders["test"], transform=transform(train=False)) model = build_model( max_epochs=50, logdir=logdir, train_split=predefined_split(test), ) model.fit(train) th = np.arange(0.1, 0.9, 0.01) mean, std = model.thresholds(test, partial(dice, th=th)) plot(mean, thresholds=th)
from models.model import build_naive_model, build_model, train_model from steps.load_data import batch_streamer_train, batch_streamer_test, NR_PRODUCTS import config if __name__ == '__main__': from argparse import ArgumentParser parser = ArgumentParser() parser.add_argument('-n', '--naive', dest='naive', action='store_true') parser.add_argument('fix_value', nargs='?', const=None, type=float) kwargs = parser.parse_args() if kwargs.naive: model = build_naive_model(fix_value=kwargs.fix_value) else: model = build_model(**config.model_parms, NR_PRODUCTS=NR_PRODUCTS) print(model.summary()) optimizer = Adam(learning_rate=config.LEARNING_RATE) loss_fn = BinaryCrossentropy(from_logits=False) model = train_model(model=model, optimizer=optimizer, loss_fn=loss_fn, batch_streamer_train=batch_streamer_train, batch_streamer_test=batch_streamer_test, epochs=1 if kwargs.naive else config.NR_EPOCHS) if not kwargs.naive: model.save_weights(config.MODEL_WEIGHTS_PATH)
import sys sys.path.append('.') import numpy as np import pandas as pd from tqdm import tqdm from models.coupon_assignment import CouponOptimizer from models.model import build_model from steps.load_data import batch_streamer_90 import config if __name__ == '__main__': model = build_model(**config.model_parms) _ = model.load_weights(config.MODEL_WEIGHTS_PATH) prices: np.ndarray = pd.read_csv(config.PRICES_PATH).price.to_numpy() assert prices.shape[0] == batch_streamer_90.nr_products # make predictions for week 90 coupon_optimizer = CouponOptimizer( model=model, prices=prices, **config.coupon_parms, generate_random=False ) coupon_randomizer = CouponOptimizer( model=model,
def train_weighted(args, data_loaders): best_prec1 = 0 # create model train_loaders, train_meta_loader, test_loader = data_loaders model = build_model(args) optimizer_a = torch.optim.SGD(model.params(), args.lr, momentum=args.momentum, nesterov=args.nesterov, weight_decay=args.weight_decay) vnet = VNet(1, 100, 1).cuda() optimizer_c = torch.optim.SGD(vnet.params(), 1e-3, momentum=args.momentum, nesterov=args.nesterov, weight_decay=args.weight_decay) cudnn.benchmark = True # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() model_loss = [] meta_model_loss = [] smoothing_alpha = 0.9 meta_l = 0 net_l = 0 accuracy_log = [] train_acc = [] for train_loader in train_loaders: for iters in range(args.iters): adjust_learning_rate(args, optimizer_a, iters + 1) # adjust_learning_rate(optimizer_c, iters + 1) model.train() input, target = next(iter(train_loader)) input_var = to_var(input, requires_grad=False) target_var = to_var(target, requires_grad=False) meta_model = build_model(args) # Why meta_model loads state dict of model? meta_model.load_state_dict(model.state_dict()) y_f_hat = meta_model(input_var) cost = F.cross_entropy(y_f_hat, target_var, reduce=False) cost_v = torch.reshape(cost, (len(cost), 1)) v_lambda = vnet(cost_v.data) norm_c = torch.sum(v_lambda) if norm_c != 0: v_lambda_norm = v_lambda / norm_c else: v_lambda_norm = v_lambda l_f_meta = torch.sum(cost_v * v_lambda_norm) meta_model.zero_grad() grads = torch.autograd.grad(l_f_meta, (meta_model.params()), create_graph=True) meta_lr = args.lr * ((0.1**int(iters >= 18000)) * (0.1**int(iters >= 19000))) # For WRN-28-10 #meta_lr = args.lr * ((0.1 ** int(iters >= 20000)) * (0.1 ** int(iters >= 25000))) # For ResNet32 meta_model.update_params(lr_inner=meta_lr, source_params=grads) del grads input_validation, target_validation = next(iter(train_meta_loader)) input_validation_var = to_var(input_validation, requires_grad=False) target_validation_var = to_var(target_validation.type( torch.LongTensor), requires_grad=False) y_g_hat = meta_model(input_validation_var) l_g_meta = F.cross_entropy(y_g_hat, target_validation_var) prec_meta = accuracy(y_g_hat.data, target_validation_var.data, topk=(1, ))[0] optimizer_c.zero_grad() l_g_meta.backward() optimizer_c.step() y_f = model(input_var) cost_w = F.cross_entropy(y_f, target_var, reduce=False) cost_v = torch.reshape(cost_w, (len(cost_w), 1)) prec_train = accuracy(y_f.data, target_var.data, topk=(1, ))[0] with torch.no_grad(): w_new = vnet(cost_v) norm_v = torch.sum(w_new) if norm_v != 0: w_v = w_new / norm_v else: w_v = w_new l_f = torch.sum(cost_v * w_v) optimizer_a.zero_grad() l_f.backward() optimizer_a.step() meta_l = smoothing_alpha * meta_l + ( 1 - smoothing_alpha) * l_g_meta.item() meta_model_loss.append(meta_l / (1 - smoothing_alpha**(iters + 1))) net_l = smoothing_alpha * net_l + (1 - smoothing_alpha) * l_f.item() model_loss.append(net_l / (1 - smoothing_alpha**(iters + 1))) if (iters + 1) % 100 == 0: print('Epoch: [%d/%d]\t' 'Iters: [%d/%d]\t' 'Loss: %.4f\t' 'MetaLoss:%.4f\t' 'Prec@1 %.2f\t' 'Prec_meta@1 %.2f' % ((iters + 1) // 500 + 1, args.epochs, iters + 1, args.iters, model_loss[iters], meta_model_loss[iters], prec_train, prec_meta)) losses_test = AverageMeter() top1_test = AverageMeter() model.eval() for i, (input_test, target_test) in enumerate(test_loader): input_test_var = to_var(input_test, requires_grad=False) target_test_var = to_var(target_test, requires_grad=False) # compute output with torch.no_grad(): output_test = model(input_test_var) loss_test = criterion(output_test, target_test_var) prec_test = accuracy(output_test.data, target_test_var.data, topk=(1, ))[0] losses_test.update(loss_test.data.item(), input_test_var.size(0)) top1_test.update(prec_test.item(), input_test_var.size(0)) print(' * Prec@1 {top1.avg:.3f}'.format(top1=top1_test)) accuracy_log.append(np.array([iters, top1_test.avg])[None]) train_acc.append(np.array([iters, prec_train])[None]) best_prec1 = max(top1_test.avg, best_prec1) return meta_model_loss, model_loss, accuracy_log, train_acc
def train_plain(args, data_loaders): best_prec1 = 0 # create model train_loaders, train_meta_loader, test_loader = data_loaders model = build_model(args) optimizer_a = torch.optim.SGD(model.params(), args.lr, momentum=args.momentum, nesterov=args.nesterov, weight_decay=args.weight_decay) cudnn.benchmark = True # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() model_loss = [] # meta_model_loss = [] smoothing_alpha = 0.9 meta_l = 0 net_l = 0 accuracy_log = [] train_acc = [] for train_loader in train_loaders: for iters in range(args.iters): adjust_learning_rate(args, optimizer_a, iters + 1) model.train() input, target = next(iter(train_loader)) input_var = to_var(input, requires_grad=False) target_var = to_var(target, requires_grad=False) y_f = model(input_var) cost_w = F.cross_entropy(y_f, target_var, reduce=False) cost_v = torch.reshape(cost_w, (len(cost_w), 1)) prec_train = accuracy(y_f.data, target_var.data, topk=(1, ))[0] l_f = torch.sum(cost_v) optimizer_a.zero_grad() l_f.backward() optimizer_a.step() # meta_l = smoothing_alpha * meta_l + (1 - smoothing_alpha) * l_g_meta.item() # meta_model_loss.append(meta_l / (1 - smoothing_alpha ** (iters + 1))) net_l = smoothing_alpha * net_l + (1 - smoothing_alpha) * l_f.item() model_loss.append(net_l / (1 - smoothing_alpha**(iters + 1))) if (iters + 1) % 100 == 0: print('Epoch: [%d/%d]\t' 'Iters: [%d/%d]\t' 'Loss: %.4f\t' 'Prec@1 %.2f\t' % ((iters + 1) // 500 + 1, args.epochs, iters + 1, args.iters, model_loss[iters], prec_train)) losses_test = AverageMeter() top1_test = AverageMeter() model.eval() for i, (input_test, target_test) in enumerate(test_loader): input_test_var = to_var(input_test, requires_grad=False) target_test_var = to_var(target_test, requires_grad=False) # compute output with torch.no_grad(): output_test = model(input_test_var) loss_test = criterion(output_test, target_test_var) prec_test = accuracy(output_test.data, target_test_var.data, topk=(1, ))[0] losses_test.update(loss_test.data.item(), input_test_var.size(0)) top1_test.update(prec_test.item(), input_test_var.size(0)) print(' * Prec@1 {top1.avg:.3f}'.format(top1=top1_test)) accuracy_log.append(np.array([iters, top1_test.avg])[None]) train_acc.append(np.array([iters, prec_train])[None]) best_prec1 = max(top1_test.avg, best_prec1) return None, model_loss, accuracy_log, train_acc
def test_model(fake_dataset): dataset = RawDataset(list(fake_dataset.glob("*/")), transform=transform()) model = build_model(train_split=predefined_split(dataset)) model.fit(dataset) model.thresholds(dataset)
) parser.add_argument( '--img-input', default='', help='input image index, eg: 00001-1', ) args = parser.parse_args() np.random.seed(int(time.time())) options = Options() options.arch = args.arch if args.arch != '' else options.arch options.data_path = args.data_path if args.data_path != '' else options.data_path options.model_path = args.checkpoint ## get model model = build_model(args.arch, options) model.eval() model.to(options.device) ## get model weight checkpoint = torch.load(options.model_path) model.load_state_dict(checkpoint['model_state_dict']) ## get random or user selected image input sample_list = open(os.path.join(options.data_path, 'test-split.txt')).read().splitlines() input_file = np.random.choice( sample_list, 1)[0] if args.img_input == '' else args.img_input rgb_in = Image.open( os.path.join(options.data_path, 'color-input', input_file + '.png')) rgb_bg = Image.open(
char_ignore_case=False) if not training: yield word_input, batch_taggings continue sentence_len = word_input.shape[1] for j in range(len(batch_taggings)): batch_taggings[j] = batch_taggings[j] + [0] * ( sentence_len - len(batch_taggings[j])) batch_taggings[j] = [[tag] for tag in batch_taggings[j]] batch_taggings = numpy.asarray(batch_taggings) yield word_input, batch_taggings if not training: break model = build_model(token_num=len(word_dict), tag_num=len(TAGS)) model.summary(line_length=80) if not (config["NEW_TRAINING"]): model.load_weights(config["GLOVE_MODEL"], by_name=True) else: print('Fitting...') for lr in [1e-3, 1e-4, 1e-5]: model.fit_generator( generator=batch_generator(train_sentences, train_taggings, train_steps), steps_per_epoch=train_steps, epochs=config["EPOCHS"], validation_data=batch_generator(valid_sentences, valid_taggings, valid_steps), validation_steps=valid_steps,
def main(args): utils.init_distributed_mode(args) # fix the seed for reproducibility seed = args.seed + utils.get_rank() torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) # model args.device = 'cuda:{}'.format(args.gpu) device = torch.device(args.device) model = build_model(args) model.to(device) criterion = CECriterion(args.num_classes, weights_valid=1., eps=1e-6) criterion.to(device) model_without_ddp = model if args.distributed: model = nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu], find_unused_parameters=True) model_without_ddp = model.module else: raise NotImplementedError param_dicts = [ { "params": [ p for n, p in model_without_ddp.named_parameters() if p.requires_grad ] }, ] optimizer = torch.optim.SGD(param_dicts, lr=args.lr, momentum=args.momentum, weight_decay=args.wd, nesterov=False) lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[150, 245], gamma=0.1, last_epoch=-1) # dataset seq_paths, seq_names = get_mot_dataset_info() print('args.shuffle_in_frame: ', args.shuffle_in_frame) dataset = ReIDDataset(seq_paths, seq_names, feat_path='reid_posenc_feat_merge_dim512_normalized', train=True, shuffle_in_frame=args.shuffle_in_frame, shuffle_prob=args.shuffle_prob) # dataloader rank, world_size = utils.get_dist_info() assert args.rank == rank sampler_train = DistributedSampler(dataset, num_replicas=world_size, rank=args.rank, shuffle=True) init_fn = partial(worker_init_fn, num_workers=args.workers_per_gpu, rank=args.rank, seed=seed) if seed is not None else None data_loader = DataLoader( dataset, batch_size=args.batch_size, # images_per_gpu sampler=sampler_train, num_workers=args.workers_per_gpu, collate_fn=partial(default_collate), pin_memory=False, worker_init_fn=init_fn) print('len data_loader: ', len(data_loader)) # logging: if utils.is_main_process(): log_format = '%(asctime)s %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%m/%d %I:%M:%S %p') if not os.path.exists(args.out_dir): os.mkdir(args.out_dir) fh = logging.FileHandler( os.path.join( args.out_dir, 'log_embdim{}_feedforwarddim{}_nhead{}e{}_lr{}_nbclass{}_shuffleprob{}.txt' .format(args.embed_dim, args.dim_feedforward, args.num_heads, args.epochs, args.lr, args.num_classes, args.shuffle_prob))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) # training time_start = time.time() for epoch in range(args.epochs): sampler_train.set_epoch(epoch) train_celoss, MAXV = train_one_epoch(model, criterion, data_loader, optimizer, device, epoch, args) if utils.is_main_process(): logging.info( '[INFO] Train: epoch={}, lr={:.4f}, ce_loss={:.4f}'.format( epoch, optimizer.param_groups[0]["lr"], train_celoss)) lr_scheduler.step() if utils.is_main_process(): print('finished train_one_epoch at epoch={} MAXV={}'.format( epoch, MAXV)) if epoch == 0 or epoch == args.epochs - 1 or epoch % 10 == 0: checkpoint_path = os.path.join(args.out_dir, 'checkpoint') if not os.path.exists(checkpoint_path): os.mkdir(checkpoint_path) save_paths = [ os.path.join(checkpoint_path, 'epoch{}.pth'.format(epoch)), os.path.join(checkpoint_path, 'checkpoint.pth') ] for save_path in save_paths: utils.save_on_master( { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch, }, save_path) print('finished save checkpoints at epoch={}'.format(epoch)) total_time = (time.time() - time_start) / 3600 print('Train finished, total_train_time={}h'.format(total_time))