from darts.operations import *
import sys
sys.path.append('../cnn')
from model import NetworkCIFAR as Network
from chainer.datasets import get_cifar10
c_model = NetworkCIFAR(DARTS)
chainer.serializers.load_npz('model.npz', c_model)
chainer.global_config.train = False
t_model = Network(36, 10, 20, True, DARTS)
t_model.drop_path_prob = 0.2
t_model.load_state_dict(torch.load('cifar10_model.pt'))
t_model.eval()
train, val = get_cifar10()
img, _ = train[0]
x = img[None]
t_x = torch.autograd.Variable(torch.FloatTensor(x))
c_y = c_model(x)
t_y = t_model(t_x)
np.testing.assert_almost_equal(c_y[0].data,
t_y[0].detach().data.numpy(),
decimal=5)
#####################
# c_prev_s = c_model.stem(x)
# c_prev_prev_s = c_prev_s
# for i in range(7):
def main(args):
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)
models_folder = args.models_folder
if not os.path.isdir(models_folder):
logging.error("The models_folder argument %s is not a directory", models_folder)
sys.exit(1)
models = dict()
for dir in os.listdir(models_folder):
if dir.startswith("eval"):
weights_file = os.path.join(models_folder, dir, "weights.pt")
if os.path.exists(weights_file):
arch = dir.split("-")[1]
genotype = genotypes.__dict__.get(arch, None)
if genotype is not None:
model = Network(args.init_channels, CIFAR_CLASSES, args.layers, args.auxiliary, genotype)
model = model.cuda()
utils.load(model, weights_file)
model.drop_path_prob = args.drop_path_prob
model.eval()
models[arch] = model
logging.info("%s param size = %fMB", dir, utils.count_parameters_in_MB(model))
else:
logging.info("Ignoring %s because there is no genotype %s on genotype.py", dir, arch)
if len(models) == 0:
logging.error("No model was found on %s", models_folder)
sys.exit(1)
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
train_transform, test_transform = utils._data_transforms_cifar10(args)
if args.set == 'cifar100':
train_data = dset.CIFAR100(root=args.data, train=True, download=True, transform=train_transform)
valid_data = dset.CIFAR100(root=args.data, train=True, download=True, transform=test_transform)
test_data = dset.CIFAR100(root=args.data, train=False, download=True, transform=test_transform)
else:
train_data = dset.CIFAR10(root=args.data, train=True, download=True, transform=train_transform)
valid_data = dset.CIFAR10(root=args.data, train=True, download=True, transform=test_transform)
test_data = dset.CIFAR10(root=args.data, train=False, download=True, transform=test_transform)
num_train = len(train_data)
indices = list(range(num_train))
split = int(np.floor(args.train_portion * num_train))
train_queue = DataLoader(
train_data, batch_size=args.batch_size,
sampler=torch.utils.data.sampler.SubsetRandomSampler(indices[:split]),
pin_memory=True, num_workers=4)
valid_queue = torch.utils.data.DataLoader(
valid_data, batch_size=args.batch_size,
sampler=torch.utils.data.sampler.SubsetRandomSampler(indices[split:num_train]),
pin_memory=True, num_workers=4)
test_queue = DataLoader(
test_data, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=4)
if args.calculate:
# return n_models x n_classes matrix of weights
if args.per_class:
weights = calc_ensemble(valid_queue, models, len(valid_data.classes))
else:
weights = calc_ensemble(valid_queue, models)
else:
weights = torch.ones(len(models), device='cuda')
logging.info('train final weights = %s', weights)
# scale weights per maximum value per class
test_acc, top5_acc, test_obj = infer(test_queue, models, criterion, weights / weights.amax(dim=0))
logging.info('test loss %e, acc top1: %.2f, acc top5 %.2f', test_obj, test_acc, top5_acc)
train_acc, top5_acc, train_obj = infer(train_queue, models, criterion)
logging.info('train loss %e, acc top1: %f, acc top5 %f', train_obj, train_acc, top5_acc)
model = Network(36, 10, 20, 0.4, genotype, args.parse_method)
flops, params = profile(model, inputs=(torch.randn(1, 3, 32, 32),), verbose=False)
print('flops = %fM' % (flops / 1e6))
print('param size = %fM' %( params / 1e6))
model = model.cuda()
if args.model_path and os.path.isfile(args.model_path):
checkpoint = torch.load(args.model_path)
model.load_state_dict(checkpoint['state_dict'])
else:
print('The Pre-Trained Model Is InValid!')
sys.exit(-1)
top1 = dutils.AvgrageMeter()
top5 = dutils.AvgrageMeter()
model.eval()
with torch.no_grad():
for step, (input, target) in enumerate(valid_queue):
input = input.cuda(non_blocking=True)
target = target.cuda(non_blocking=True)
logits, _ = model(input)
prec1, prec5 = dutils.accuracy(logits, target, topk=(1, 5))
n = input.size(0)
top1.update(prec1.item(), n)
top5.update(prec5.item(), n)
if step % args.report_freq == 0:
print('valid %03d %f %f' % (step, top1.avg, top5.avg))
print("Final Mean Top1: {}, Top5: {}".format(top1.avg, top5.avg))
