def main():
if not torch.cuda.is_available():
logging.info('no gpu device available')
sys.exit(1)
if args.gpu == -1:
device = torch.device('cpu')
else:
device = torch.device('cuda:{}'.format(args.gpu))
np.random.seed(args.seed)
cudnn.benchmark = True
torch.manual_seed(args.seed)
cudnn.enabled = True
torch.cuda.manual_seed(args.seed)
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
genotype = eval("genotypes.%s" % args.arch)
#model = Network(args.init_channels, dataset_classes, args.layers, args.auxiliary, genotype)
model = Network(args)
model = model.to(device)
util.load(model, args.model_path)
logging.info("param size = %fMB", util.count_parameters_in_MB(model))
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
test_data = MyDataset(args=args, subset='test')
test_queue = torch.utils.data.DataLoader(test_data,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
num_workers=2)
model.drop_path_prob = args.drop_path_prob
test_acc, test_obj, test_fscores, test_MIoU = infer(
test_queue, model, criterion)
logging.info('test_acc %f _fscores %f _MIoU %f', test_acc, test_fscores,
test_MIoU)
def main():
'''
if not torch.cuda.is_avaitargetsle():
logging.info('no gpu device avaitargetsle')
sys.exit(1)'''
np.random.seed(args.seed)
if args.gpu == -1:
device = torch.device('cpu')
else:
device = torch.device('cuda:{}'.format(args.gpu))
cudnn.benchmark = True
# 为CPU设置种子用于生成随机数，以使得结果是确定的
torch.manual_seed(args.seed)
cudnn.enabled=True
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
criterion = nn.CrossEntropyLoss()#损失函数，交叉熵
criterion = criterion.to(device)
model = Network(args.gpu,args.init_channels, dataset_classes, args.layers, criterion)
model = model.to(device)
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_data = MyDataset(args=args, subset='train')
valid_data = MyDataset(args=args, subset='valid')
train_queue = torch.utils.data.DataLoader(
train_data, batch_size=args.batch_size, shuffle=True, pin_memory=True, num_workers=2)
valid_queue = torch.utils.data.DataLoader(
valid_data, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=2)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, float(args.epochs), eta_min=args.learning_rate_min)
architect = Architect(model, args)
f_arch = open(os.path.join(args.save, 'arch.txt'),'a')
for epoch in range(args.epochs):
scheduler.step()
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
train_acc, train_obj, train_fscores, train_MIoU = train(train_queue, valid_queue, model, architect, criterion, optimizer, lr)
logging.info('train_acc %f _fscores %f _MIoU %f', train_acc, train_fscores, train_MIoU)
# validation
valid_acc, valid_obj, valid_fscores, valid_MIoU = infer(valid_queue, model, criterion)
logging.info('valid_acc %f _fcores %f _MIoU %f', valid_acc, valid_fscores, valid_MIoU)
utils.save(model, os.path.join(args.save, 'weights.pt'))
f_arch.write(str(F.softmax(model.arch_parameters()[0],-1)))
f_arch.close()
def main(arg):
##################################
for key in arg:
parse[key] = arg[key]
global args
args = SimpleNamespace(**parse)
'''
print('seed:{:}'.format(args.seed))
print('dataset:{:}'.format(args.dataset))
print('hidden_layers:{:}'.format(args.hidden_layers))
print('first_neurons:{:}'.format(args.first_neurons))
print('cross_link:{:}'.format(args.cross_link))
print('fully_cross:{:}'.format(args.fully_cross))
print()
exit(0)
'''
##################################
seed = util.prepare(args)
if not cuda.is_available():
logging.info('no gpu device available')
sys.exit(1)
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
cuda.manual_seed(seed)
cuda.set_device(args.gpu)
cudnn.benchmark = False
cudnn.deterministic = True
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
logging.info('hidden_layers:{:}'.format(args.hidden_layers))
logging.info('first_neurons:{:}'.format(args.first_neurons))
logging.info('change:{:}'.format(args.change))
logging.info('activate_func:{:}'.format(args.activate_func))
logging.info('opt:{:}'.format(args.opt))
logging.info('cross_link:{:}'.format(args.cross_link))
logging.info('fully_cross:{:}'.format(args.fully_cross))
model = Network(args)
model = model.cuda()
logging.info("param size = %fMB", util.count_parameters_in_MB(model))
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
# scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, args.epochs)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=30,
gamma=0.7)
train_data, valid_data = dataset.get_dataset(args.data, args.dataset)
train_queue, valid_queue = dataset.get_data_loader(train_data, valid_data,
2)
early_stop = util.EarlyStop(patience=10,
delta=0.0001,
save_path=args.save + '/best.pt')
for epoch in range(args.epochs):
logging.info('epoch %d lr %.6f', epoch, scheduler.get_lr()[0])
epoch_str = '[{:03d}/{:03d}]'.format(epoch, args.epochs)
train_acc, train_obj = train(train_queue, model, criterion, optimizer,
epoch_str)
logging.info('train_acc %.2f', train_acc)
valid_acc, valid_obj = infer(valid_queue, model, criterion, epoch_str)
logging.info('valid_acc %.2f', valid_acc)
if early_stop.check(train_obj, valid_acc, model):
logging.info('Early stopping at {:}'.format(epoch))
break
scheduler.step()
device = torch.device('cpu')
else:
device = torch.device('cuda:{}'.format(args.gpu))
cudnn.benchmark = True
# 为CPU设置种子用于生成随机数，以使得结果是确定的
torch.manual_seed(args.seed)
cudnn.enabled=True
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
criterion = nn.CrossEntropyLoss()#损失函数，交叉熵
criterion = criterion.to(device)
model = Network(args.gpu,args.init_channels, dataset_classes, args.layers, criterion)
model = model.to(device)
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_data = MyDataset(args=args, subset='train')
valid_data = MyDataset(args=args, subset='valid')
train_queue = torch.utils.data.DataLoader(
train_data, batch_size=args.batch_size, shuffle=True, pin_memory=True, num_workers=2)
valid_queue = torch.utils.data.DataLoader(
valid_data, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=2)
def main():
if not torch.cuda.is_available():
logging.info('no gpu device available')
sys.exit(1)
np.random.seed(args.seed)
torch.cuda.set_device(args.gpu)
cudnn.benchmark = True
torch.manual_seed(args.seed)
cudnn.enabled = True
torch.cuda.manual_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)
model = model.cuda()
logging.info("param size = %fMB", count_parameters_in_MB(model))
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
train_transform, valid_transform = get_data_transforms_cifar10(args)
train_data = dset.CIFAR10(root=args.data,
train=True,
download=True,
transform=train_transform)
num_train = len(train_data)
indices = list(range(num_train))
split = int(np.floor(args.train_portion * num_train))
train_queue = torch.utils.data.DataLoader(
train_data,
batch_size=2,
sampler=torch.utils.data.sampler.SubsetRandomSampler(indices[:split]),
pin_memory=True,
num_workers=1)
valid_queue = torch.utils.data.DataLoader(
train_data,
batch_size=2,
sampler=torch.utils.data.sampler.SubsetRandomSampler(
indices[split:num_train]),
pin_memory=True,
num_workers=1)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, int(args.epochs), eta_min=args.learning_rate_min)
architect = Architect(model, args)
for epoch in range(args.epochs):
scheduler.step()
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
train_acc, train_obj = train(train_queue, valid_queue, model,
architect, criterion, optimizer, lr)
logging.info('train_acc %f', train_acc)
# validation
valid_acc, valid_obj = infer(valid_queue, model, criterion)
logging.info('valid_acc %f', valid_acc)
save(model, os.path.join(args.save, 'weights.pt'))
def main(args, log_dir):
##############################################################################
#
# Dataset Config
#
##############################################################################
if args.data_search_space == 'ENAS':
data_config_path = 'configs/data_configs/ENAS_configspace.json'
elif args.data_search_space == 'NB101':
data_config_path = 'configs/data_configs/NB101_configspace.json'
elif args.data_search_space == 'NB201':
data_config_path = 'configs/data_configs/NB201_configspace.json'
else:
raise TypeError("Unknow Seach Space : {:}".format(
args.data_search_space))
data_config = json.load(open(data_config_path, 'r'))
##############################################################################
#
# Model Config
#
##############################################################################
model_config_path = 'configs/model_configs/svge_configspace.json'
model_configspace = config_space_json_r_w.read(
open(model_config_path, 'r').read())
model_config = model_configspace.get_default_configuration(
).get_dictionary()
##############################################################################
#
# Dataset
#
##############################################################################
print("Creating Dataset.")
if args.data_search_space == 'NB201':
from datasets.NASBench201 import Dataset as Dataset201
dataset = Dataset201(batch_size=data_config['batch_size'])
elif args.data_search_space == 'NB101':
from datasets.NASBench101 import Dataset as Dataset101
dataset = Dataset101(batch_size=data_config['batch_size'])
elif args.data_search_space == 'ENAS':
from datasets.ENAS import Dataset as DatasetENAS
dataset = DatasetENAS(batch_size=data_config['batch_size'])
else:
raise TypeError("Unknow Dataset: {:}".format(args.data_search_space))
print(f"Dataset size: {dataset.length}")
##############################################################################
#
# Model
#
##############################################################################
model = eval(args.model)(model_config=model_config,
data_config=data_config).to(args.device)
optimizer = torch.optim.Adam(model.parameters(),
lr=model_config['learning_rate'])
scheduler = ReduceLROnPlateau(optimizer,
'min',
factor=0.1,
patience=10,
verbose=True)
logging.info("param size = %fMB", util.count_parameters_in_MB(model))
if not args.only_test_mode:
##############################################################################
#
# Training
#
##############################################################################
budget = model_config['epochs']
for epoch in range(1, int(budget) + 1):
logging.info('epoch: %s', epoch)
# training
train_obj = train(dataset, model, optimizer, epoch, args.device,
log_dir)
scheduler.step(train_obj)
# Save the model
if epoch % args.save_interval == 0:
logger.info('save model checkpoint {} '.format(epoch))
model_name = os.path.join(
log_dir, 'model_checkpoint{}.obj'.format(epoch))
torch.save(model.state_dict(), model_name)
optimizer_name = os.path.join(
log_dir, 'optimizer_checkpoint{}.obj'.format(epoch))
torch.save(optimizer.state_dict(), optimizer_name)
scheduler_name = os.path.join(
log_dir, 'scheduler_checkpoint{}.obj'.format(epoch))
torch.save(scheduler.state_dict(), scheduler_name)
config_dict = {
'epochs': epoch,
'loss': train_obj,
}
with open(os.path.join(log_dir, 'results.txt'), 'a') as file:
json.dump(str(config_dict), file)
file.write('\n')
##############################################################################
#
# Test
#
##############################################################################
if epoch % args.save_interval == 0:
if args.data_search_space == 'ENAS':
test(dataset,
model,
epoch,
args.device,
log_dir,
data_config,
DatasetENAS,
ENAS=True)
elif args.data_search_space == 'NB101':
test(dataset,
model,
epoch,
args.device,
log_dir,
data_config,
Dataset101,
NB101=True)
elif args.data_search_space == 'NB201':
test(dataset,
model,
epoch,
args.device,
log_dir,
data_config,
Dataset201,
NB201=True)
else:
raise TypeError("Unknow Seach Space : {:}".format(
args.data_search_space))
else:
##############################################################################
#
# Only Test
#
##############################################################################
log_dir = os.path.join(args.log_dir,
args.model + '_' + args.data_search_space)
epoch = args.test_epoch
m = torch.load(os.path.join(log_dir, f"model_checkpoint{epoch}.obj"),
map_location=args.device)
model.load_state_dict(m)
if args.data_search_space == 'ENAS':
test(dataset,
model,
epoch,
args.device,
log_dir,
data_config,
DatasetENAS,
ENAS=True,
pretrained=True)
elif args.data_search_space == 'NB101':
test(dataset,
model,
epoch,
args.device,
log_dir,
data_config,
Dataset101,
NB101=True,
pretrained=True)
elif args.data_search_space == 'NB201':
test(dataset,
model,
epoch,
args.device,
log_dir,
data_config,
Dataset201,
NB201=True,
pretrained=True)
else:
raise TypeError("Unknow Seach Space : {:}".format(
args.data_search_space))
def main():
seed = util.prepare(args)
if not cuda.is_available():
logging.info('no gpu device available')
sys.exit(1)
CIFAR_CLASSES = 10
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
cuda.manual_seed(seed)
cuda.set_device(args.gpu)
cudnn.benchmark = False
cudnn.deterministic = True
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
logging.info('hidden_layers:{:}'.format(args.hidden_layers))
logging.info('first_neurons:{:}'.format(args.first_neurons))
logging.info('change:{:}'.format(args.change))
logging.info('activate_func:{:}'.format(args.activate_func))
logging.info('opt:{:}'.format(args.opt))
logging.info('cross_link:{:}'.format(args.cross_link))
genotype = eval("genotypes.%s" % args.arch)
model = Network(args.init_channels, CIFAR_CLASSES, args.layers,
args.auxiliary, genotype, args)
model = model.cuda()
logging.info("param size = %fMB", util.count_parameters_in_MB(model))
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
train_transform, valid_transform = util.get_data_transforms_cifar10(args)
train_data = datasets.CIFAR10(root=args.data,
train=True,
download=False,
transform=train_transform)
valid_data = datasets.CIFAR10(root=args.data,
train=False,
download=False,
transform=valid_transform)
train_queue = DataLoader(train_data,
batch_size=args.batch_size,
shuffle=True,
pin_memory=True,
num_workers=1)
valid_queue = DataLoader(valid_data,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
num_workers=1)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, args.epochs)
best_acc = 0
for epoch in range(args.epochs):
logging.info('epoch %d lr %.6f', epoch, scheduler.get_lr()[0])
model.drop_path_prob = args.drop_path_prob * epoch / args.epochs
epoch_str = '[{:03d}/{:03d}]'.format(epoch, args.epochs)
train_acc, train_obj = train(train_queue, model, criterion, optimizer,
epoch_str)
logging.info('train_acc %.2f', train_acc)
valid_acc, valid_obj = infer(valid_queue, model, criterion, epoch_str)
logging.info('valid_acc %.2f', valid_acc)
if valid_acc > best_acc:
logging.info(
'find the best model. Save it to {:}'.format(args.save +
'best.pt'))
util.save(model, os.path.join(args.save, 'best.pt'))
best_acc = valid_acc
scheduler.step()
logging.info('best acc is {:}'.format(best_acc))
