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