def main():
args = _parse_args()
with open(args.src_structure) as f:
src_output_sizes = json.load(f)
src_net = net.VGG(src_output_sizes)
serializers.load_npz(args.src_model, src_net)
mask_dict = _prune(src_net, args.prune_ratio)
dest_output_sizes = {k: np.sum(v) for k, v in mask_dict.items()}
dest_net = net.VGG(dest_output_sizes)
_convert(src_net, dest_net, mask_dict)
with open(args.dest_structure, 'w') as f:
json.dump(dest_output_sizes, f)
serializers.save_npz(args.dest_model, dest_net)
# print parameter size
print('Source model')
total_size = 0
for name in net.VGG_LAYERS:
size = _layer_size(getattr(src_net, name))
total_size += size
print(' {}: {}'.format(name, size))
print(' Total: {}'.format(total_size))
print('Destination model')
total_size = 0
for name in net.VGG_LAYERS:
size = _layer_size(getattr(dest_net, name))
total_size += size
print(' {}: {}'.format(name, size))
print(' Total: {}'.format(total_size))
def build_model(self):
# Define generators and discriminators
if self.whichG == 'normal':
self.G = net.Generator_makeup(self.g_conv_dim, self.g_repeat_num)
if self.whichG == 'branch':
self.G = net.Generator_branch(self.g_conv_dim, self.g_repeat_num)
for i in self.cls:
setattr(
self, "D_" + i,
net.Discriminator(self.img_size, self.d_conv_dim,
self.d_repeat_num, self.norm))
self.criterionL1 = torch.nn.L1Loss()
self.criterionL2 = torch.nn.MSELoss()
self.criterionGAN = GANLoss(use_lsgan=True,
tensor=torch.cuda.FloatTensor)
self.vgg = net.VGG()
self.vgg.load_state_dict(torch.load('addings/vgg_conv.pth'))
# self.vgg = models.vgg19_bn(pretrained=True)
# Optimizers
self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr,
[self.beta1, self.beta2])
for i in self.cls:
setattr(self, "d_" + i + "_optimizer", \
torch.optim.Adam(filter(lambda p: p.requires_grad, getattr(self, "D_" + i).parameters()), \
self.d_lr, [self.beta1, self.beta2]))
# Weights initialization
self.G.apply(self.weights_init_xavier)
for i in self.cls:
getattr(self, "D_" + i).apply(self.weights_init_xavier)
# Print networks
self.print_network(self.G, 'G')
for i in self.cls:
self.print_network(getattr(self, "D_" + i), "D_" + i)
"""
if torch.cuda.device_count() > 1:
self.G = torch.nn.DataParallel(self.G)
self.vgg = torch.nn.DataParallel(self.vgg)
for i in self.cls:
setattr(self, "D_" + i, torch.nn.DataParallel(getattr(self, "D_" + i)))
self.G.to(self.device)
self.vgg.to(self.device)
for i in self.cls:
getattr(self, "D_" + i).to(self.device)
"""
if torch.cuda.is_available():
self.G.cuda()
self.vgg.cuda()
for i in self.cls:
getattr(self, "D_" + i).cuda()
def build_model(self):
# Define generators and discriminators
self.E = network.Encoder(self.e_conv_dim)
self.G = network.Generator(self.g_conv_dim)
for i in self.cls:
setattr(
self, "D_" + i,
net.Discriminator(self.img_size, self.d_conv_dim,
self.d_repeat_num, self.norm))
# Define vgg for perceptual loss
self.vgg = net.VGG()
self.vgg.load_state_dict(torch.load('addings/vgg_conv.pth'))
# Define loss
self.criterionL1 = torch.nn.L1Loss()
self.criterionL2 = torch.nn.MSELoss()
self.criterionGAN = GANLoss(use_lsgan=True,
tensor=torch.cuda.FloatTensor)
# Optimizers
self.e_optimizer = torch.optim.Adam(self.E.parameters(), self.e_lr,
[self.beta1, self.beta2])
self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr,
[self.beta1, self.beta2])
for i in self.cls:
setattr(self, "d_" + i + "_optimizer", \
torch.optim.Adam(filter(lambda p: p.requires_grad, getattr(self, "D_" + i).parameters()), \
self.d_lr, [self.beta1, self.beta2]))
# Weights initialization
self.E.apply(self.weights_init_xavier)
self.G.apply(self.weights_init_xavier)
for i in self.cls:
getattr(self, "D_" + i).apply(self.weights_init_xavier)
# Print networks
self.print_network(self.E, 'E')
self.print_network(self.G, 'G')
for i in self.cls:
self.print_network(getattr(self, "D_" + i), "D_" + i)
if torch.cuda.is_available():
self.E.cuda()
self.G.cuda()
self.vgg.cuda()
for i in self.cls:
getattr(self, "D_" + i).cuda()
def __init__(self, option):
# Parameters
self.image_dir = option.image_dir
self.model_dir = option.model_dir
self.result_dir = option.result_dir
self.content_img = option.content_img
self.style_img = option.style_img
self.lr_img_size = option.lr_img_size
self.max_iter = option.max_iter
self.show_iter = option.show_iter
# load images, ordered as [style_image, content_image]
img_dirs = [self.image_dir, self.image_dir]
img_names = [self.style_img, self.content_img]
self.imgs = [
Image.open(img_dirs[i] + name) for i, name in enumerate(img_names)
]
# get network
self.vgg = net.VGG()
self.vgg.load_state_dict(torch.load(self.model_dir + 'vgg_conv.pth'))
for param in self.vgg.parameters():
param.requires_grad = False
if torch.cuda.is_available():
self.vgg.cuda()
# define layers, loss functions, weights and compute optimization targets
self.style_layers = ['r11', 'r21', 'r31', 'r41', 'r51']
self.content_layers = ['r42']
self.loss_layers = self.style_layers + self.content_layers
self.loss_fns = [GramMSELoss()] * len(
self.style_layers) + [nn.MSELoss()] * len(self.content_layers)
if torch.cuda.is_available():
self.loss_fns = [loss_fn.cuda() for loss_fn in self.loss_fns]
# these are good weights settings:
style_weights = [1e3 / n**2 for n in [64, 128, 256, 512, 512]]
content_weights = [1e0]
self.weights = style_weights + content_weights
def model_fn(model_dir):
"""
This function is called by the Chainer container during hosting when running on SageMaker with
values populated by the hosting environment.
This function loads models written during training into `model_dir`.
Args:
model_dir (str): path to the directory containing the saved model artifacts
Returns:
a loaded Chainer model
For more on `model_fn`, please visit the sagemaker-python-sdk repository:
https://github.com/aws/sagemaker-python-sdk
For more on the Chainer container, please visit the sagemaker-chainer-containers repository:
https://github.com/aws/sagemaker-chainer-containers
"""
chainer.config.train = False
model = L.Classifier(net.VGG(10))
serializers.load_npz(os.path.join(model_dir, 'model.npz'), model)
return model.predictor
for i in range(size):
n_d[i][0] = data[i]
return n_d
x_train = reshape(x_train)
x_test = reshape(x_test)
"""
x_train = pca.transform(x_train)
x_test = pca.transform(x_test)
"""
batchsize = 1
n_epoch = 20
model = L.Classifier(net.VGG())
serializers.load_npz("./cnn.model", model)
#serializers.load_npz("./cnn.state", optimizer)
batchsize = 1
sum_accuracy = 0.0
for i in range(0, N_test, batchsize):
#print "batch first index : {}".format(i)
x = chainer.Variable(xp.asarray(x_test[i:i + batchsize]), volatile='on')
t = chainer.Variable(xp.asarray(y_test[i:i + batchsize]), volatile='on')
model.predictor.train = False
#print "{} : {}".format(i, model.predictor(x).data.reshape(len(t.data),-1))
#print t.data
elif args.model == 'identity_mapping':
cifar_net = net.IdentityMapping(args.res_depth, swapout=args.swapout, skip=args.skip_depth)
elif args.model == 'vgg_no_fc':
cifar_net = net.VGGNoFC()
elif args.model == 'vgg_wide':
cifar_net = net.VGGWide()
elif args.model == 'vgg_crelu':
cifar_net = net.VGGCReLU()
elif args.model == 'inception':
cifar_net = net.Inception()
elif args.model == 'pyramid':
cifar_net = net.PyramidNet(args.res_depth, skip=args.skip_depth)
elif args.model == 'shake_residual':
cifar_net = net.ShakeShakeResidualNet(args.res_depth, args.res_width)
else:
cifar_net = net.VGG()
if args.optimizer == 'sgd':
optimizer = optimizers.MomentumSGD(lr=args.lr)
else:
optimizer = optimizers.Adam(alpha=args.alpha)
optimizer.setup(cifar_net)
if args.weight_decay > 0:
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
cifar_trainer = trainer.CifarTrainer(cifar_net, optimizer, args.iter, args.batch_size, args.gpu, lr_shape=args.lr_shape, lr_decay=lr_decay_iter)
if args.prefix is None:
model_prefix = '{}_{}'.format(args.model, args.optimizer)
else:
model_prefix = args.prefix
state = {'best_valid_error': 100, 'best_test_error': 100, 'clock': time.clock()}
def main():
args = _parse_args()
np.random.seed(args.seed)
if args.prefix is None:
model_prefix = os.path.basename(args.structure_path)
model_prefix = os.path.splitext(model_prefix)[0]
else:
model_prefix = args.prefix
log_file_path = os.path.join('model', '{}_log.csv'.format(model_prefix))
lr_decay_epoch = map(int, args.lr_decay_epoch.split(','))
print('loading dataset...')
train_data, test_data = chainer.datasets.get_cifar10()
if args.no_valid_data:
valid_data = None
else:
train_data, valid_data = chainer.datasets.split_dataset_random(
train_data, 45000)
train_data = chainer.datasets.TransformDataset(train_data, _transform)
test_data = chainer.datasets.TransformDataset(test_data, _subtract_mean)
if valid_data is not None:
valid_data = chainer.datasets.TransformDataset(valid_data,
_subtract_mean)
print('start training')
with open(args.structure_path) as f:
output_sizes = json.load(f)
cifar_net = net.VGG(output_sizes)
if args.model is not None:
serializers.load_npz(args.model, cifar_net)
if args.optimizer == 'sgd':
optimizer = optimizers.MomentumSGD(lr=args.lr)
else:
optimizer = optimizers.Adam(alpha=args.alpha)
optimizer.setup(cifar_net)
if args.lambda_value > 0:
_add_hook_to_gamma(cifar_net,
chainer.optimizer.Lasso(args.lambda_value))
if args.weight_decay > 0:
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
cifar_trainer = trainer.CifarTrainer(cifar_net,
optimizer,
args.epoch,
args.batch_size,
args.gpu,
lr_shape=args.lr_shape,
lr_decay=lr_decay_epoch)
state = {
'best_valid_error': 100,
'best_test_error': 100,
'clock': time.clock()
}
def on_epoch_done(epoch, n, o, loss, acc, valid_loss, valid_acc, test_loss,
test_acc, test_time):
error = 100 * (1 - acc)
print('epoch {} done'.format(epoch))
print('train loss: {} error: {}'.format(loss, error))
if valid_loss is not None:
valid_error = 100 * (1 - valid_acc)
print('valid loss: {} error: {}'.format(valid_loss, valid_error))
else:
valid_error = None
if test_loss is not None:
test_error = 100 * (1 - test_acc)
print('test loss: {} error: {}'.format(test_loss, test_error))
print('test time: {}s'.format(test_time))
else:
test_error = None
if valid_loss is not None and valid_error < state['best_valid_error']:
save_path = os.path.join('model', '{}.model'.format(model_prefix))
serializers.save_npz(save_path, n)
save_path = os.path.join('model', '{}.state'.format(model_prefix))
serializers.save_npz(save_path, o)
state['best_valid_error'] = valid_error
state['best_test_error'] = test_error
elif valid_loss is None:
save_path = os.path.join('model', '{}.model'.format(model_prefix))
serializers.save_npz(save_path, n)
save_path = os.path.join('model', '{}.state'.format(model_prefix))
serializers.save_npz(save_path, o)
state['best_test_error'] = test_error
if args.save_epoch > 0 and (epoch + 1) % args.save_epoch == 0:
save_path = os.path.join(
'model', '{}_{}.model'.format(model_prefix, epoch + 1))
serializers.save_npz(save_path, n)
save_path = os.path.join(
'model', '{}_{}.state'.format(model_prefix, epoch + 1))
serializers.save_npz(save_path, o)
clock = time.clock()
print('elapsed time: {}'.format(clock - state['clock']))
state['clock'] = clock
with open(log_file_path, 'a') as f:
f.write('{},{},{},{},{},{},{}\n'.format(epoch, loss, error,
valid_loss, valid_error,
test_loss, test_error))
with open(log_file_path, 'w') as f:
f.write(
'epoch,train loss,train acc,valid loss,valid acc,test loss,test acc\n'
)
cifar_trainer.fit(train_data, valid_data, test_data, on_epoch_done)
print('best test error: {}'.format(state['best_test_error']))
train_loss, train_acc, test_loss, test_acc = np.loadtxt(
log_file_path,
delimiter=',',
skiprows=1,
usecols=[1, 2, 5, 6],
unpack=True)
epoch = len(train_loss)
xs = np.arange(epoch, dtype=np.int32) + 1
plt.clf()
fig, ax = plt.subplots()
ax.plot(xs, train_loss, label='train loss', c='blue')
ax.plot(xs, test_loss, label='test loss', c='red')
ax.set_xlim((1, epoch))
ax.set_xlabel('epoch')
ax.set_ylabel('loss')
ax.legend(loc='upper right')
save_path = os.path.join('model', '{}_loss.png'.format(model_prefix))
plt.savefig(save_path, bbox_inches='tight')
plt.clf()
fig, ax = plt.subplots()
ax.plot(xs, train_acc, label='train error', c='blue')
ax.plot(xs, test_acc, label='test error', c='red')
ax.set_xlim([1, epoch])
ax.set_xlabel('epoch')
ax.set_ylabel('error')
ax.legend(loc='upper right')
save_path = os.path.join('model', '{}_error'.format(model_prefix))
plt.savefig(save_path, bbox_inches='tight')
