def main():
if not torch.cuda.is_available():
logging.info('no gpu device available')
sys.exit(1)
fix_seed(args.seed)
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
model = Network(args.init_channels,
CIFAR_CLASSES,
args.layers,
criterion,
space=args.search_space)
model = model.cuda()
logging.info("param size = %fMB", utils.count_parameters_in_MB(model))
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
train_queue, train_sampler, valid_queue = utils.get_train_validation_loader(
args)
test_queue = utils.get_test_loader(args)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, float(args.epochs), eta_min=args.learning_rate_min)
architect = Architect(model, args)
best_acc = 0
total_train_time, total_valid_time, total_test_time = 0, 0, 0
for epoch in range(args.epochs):
lr = scheduler.get_lr()[0]
logging.info('epoch %d lr %e', epoch, lr)
genotype = model.genotype()
logging.info('genotype = %s', genotype)
#print(F.softmax(model.alphas_normal, dim=-1))
#print(F.softmax(model.alphas_reduce, dim=-1))
# training
architect.alpha_forward = 0
architect.alpha_backward = 0
start_time = time.time()
train_acc, train_obj, alphas_time, forward_time, backward_time = \
train(train_queue, valid_queue, model, architect, criterion, optimizer, lr,epoch)
logging.info('train_acc %f', train_acc)
end_time = time.time()
search_time = end_time - start_time
total_train_time += search_time
logging.info("train time %f", end_time - start_time)
logging.info("alphas_time %f ", alphas_time)
logging.info("forward_time %f", forward_time)
logging.info("backward_time %f", backward_time)
logging.info("alpha_forward %f", architect.alpha_forward)
logging.info("alpha_backward %f", architect.alpha_backward)
logging.info('train_acc %f', train_acc)
# validation
# if args.epochs-epoch<=1:
# valid_acc, valid_obj = infer(valid_queue, model, criterion)
# logging.info('valid_acc %f', valid_acc)
# utils.save(model, os.path.join(args.save, 'weights.pt'))
start_time2 = time.time()
valid_acc, valid_obj = infer(valid_queue, model, criterion)
end_time2 = time.time()
valid_time = end_time2 - start_time2
total_valid_time += valid_time
logging.info("inference time %f", end_time2 - start_time2)
logging.info('valid_acc %f', valid_acc)
# test
start = time.time()
test_acc, test_obj = infer(test_queue, model, criterion)
end = time.time()
test_time = end - start
total_test_time += test_time
logging.info("inference time %f", end - start)
logging.info('test_acc %f, test_obj %f', test_acc, test_obj)
# update learning rate
scheduler.step()
is_best = valid_acc > best_acc
best_acc = max(valid_acc, best_acc)
if is_best:
logging.info(
'best valid_acc: {} at epoch: {}, test_acc: {}'.format(
best_acc, epoch, test_acc))
logging.info('Current best genotype = {}'.format(model.genotype()))
return total_train_time, total_valid_time, total_test_time
def main():
root = logging.getLogger()
if not torch.cuda.is_available():
root.info('no gpu device available')
sys.exit(1)
# Fix seed
utils.fix_seed(args.seed)
root.info('gpu device = %d' % args.gpu)
root.info("args = %s", args)
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
model = Network(args.init_channels, CIFAR_CLASSES, args.layers, criterion,
args.greedy, args.l2)
model = model.cuda()
root.info("param size = %fMB", utils.count_parameters_in_MB(model))
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
# Data loading code
train_queue, train_sampler, valid_queue = utils.get_train_validation_loader(
args)
test_queue = utils.get_test_loader(args)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, float(args.epochs), eta_min=args.learning_rate_min)
architect = Architect(model, args)
best_acc = 0
for epoch in range(args.epochs):
lr = scheduler.get_lr()[0]
log_value("lr", lr, epoch)
root.info('epoch %d lr %e', epoch, lr)
genotype = model.genotype()
root.info('genotype = %s', genotype)
# training
architect.alpha_forward = 0
architect.alpha_backward = 0
start_time = time.time()
train_acc, train_obj, alphas_time, forward_time, backward_time = \
train(train_queue, valid_queue, model, architect, criterion, optimizer, lr, epoch)
end_time = time.time()
root.info("train time %f", end_time - start_time)
root.info("alphas_time %f ", alphas_time)
root.info("forward_time %f", forward_time)
root.info("backward_time %f", backward_time)
root.info("alpha_forward %f", architect.alpha_forward)
root.info("alpha_backward %f", architect.alpha_backward)
log_value('train_acc', train_acc, epoch)
root.info('train_acc %f', train_acc)
# validation
start_time2 = time.time()
valid_acc, valid_obj = infer(valid_queue, model, criterion)
end_time2 = time.time()
root.info("inference time %f", end_time2 - start_time2)
log_value('valid_acc', valid_acc, epoch)
root.info('valid_acc %f', valid_acc)
# test
start = time.time()
test_acc, test_obj = infer(test_queue, model, criterion)
end = time.time()
root.info("inference time %f", end - start)
log_value('test_acc', test_acc, epoch)
root.info('test_acc %f, test_obj %f', test_acc, test_obj)
# update learning rate
scheduler.step()
is_best = valid_acc > best_acc
best_acc = max(valid_acc, best_acc)
if is_best:
root.info('best valid_acc: {} at epoch: {}, test_acc: {}'.format(
best_acc, epoch, test_acc))
root.info('Current best genotype = {}'.format(model.genotype()))
utils.save(model, os.path.join(args.save, 'best_weights.pt'))
