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