class OWLQN: def __init__(self, f, g, penalty, x0, **kwargs): self.f = f self.g = g self.penalty = penalty self.x = x0.copy() self.optimizer = LBFGS() self.optimizer.orthantwise_c = self.penalty self.optimizer.linesearch = 'wolfe' self.optimizer.max_iterations = kwargs.get('max_iterations', 100) self.optimizer.delta = kwargs.get('delta', 1e-4) self.optimizer.past = 1 def minimize(self): def objective(x, g): y = self.f(x) g[:] = self.g(x) return y def progress(x, g, f_x, xnorm, gnorm, step, k, ls): self.x[:] = x try: self.optimizer.minimize(objective, self.x, progress) except KeyError as e: pass except LBFGSError as e: pass return self
def __init__(self, oracle: BaseConditionalGenerationOracle, x: torch.Tensor, lr: float = 1e-1, memory_size: int = 5, line_search='Wolfe', lr_algo='None', *args, **kwargs): super().__init__(oracle, x, *args, **kwargs) self._line_search = line_search self._lr = lr self._alpha_k = None self._lr_algo = lr_algo # None, grad, dim if not (lr_algo in ["None", "Grad", "Dim"]): ValueError("lr_algo is not right") if self._x_step: self._optimizer = LBFGS(params=[self._x], lr=self._x_step / 10., line_search=line_search, history_size=memory_size) else: self._optimizer = LBFGS(params=[self._x], lr=self._lr, line_search=line_search, history_size=memory_size)
def fit(self, X_train, Y_train, user_playlist_indices=None, batch_size=256, w0=None, njobs=1, verbose=0, fnpy='_'): assert X_train.shape[0] == Y_train.shape[0] N, D = X_train.shape K = Y_train.shape[1] if verbose > 1: t0 = time.time() if verbose > 0: if user_playlist_indices is None: print('\nC: %g, p: %g' % (self.C1, self.p)) else: print('\nC1: %g, C3: %g, p: %g' % (self.C1, self.C3, self.p)) if w0 is not None: assert w0.shape[0] == K * (D + 1) else: if fnpy is not None: try: w0 = np.load(fnpy, allow_pickle=False) assert w0.shape[0] == K * (D + 1) print('Restore from %s' % fnpy) except (IOError, ValueError): w0 = np.zeros(K * (D + 1)) data_helper = DataHelper(Y_train, ax=1, batch_size=batch_size) try: # f: callable(x, g, *args) # LBFGS().minimize(f, x0, progress=progress, args=args) optim = LBFGS() optim.linesearch = 'wolfe' res = optim.minimize(objective, w0, progress, args=(X_train, Y_train, self.C1, self.C3, self.p, user_playlist_indices, data_helper, njobs, verbose, fnpy)) self.b = res[:K].reshape(1, K) self.W = res[K:].reshape(K, D) self.trained = True except (LBFGSError, MemoryError) as err: self.trained = False sys.stderr.write('LBFGS failed: {0}\n'.format(err)) sys.stderr.flush() if verbose > 1: print('Training finished in %.1f seconds' % (time.time() - t0))
def fit(self, X_train, Y_train, user_playlist_indices=None, batch_size=256, verbose=0, w0=None, fnpy=None): assert X_train.shape[0] == Y_train.shape[0] N, D = X_train.shape K = Y_train.shape[1] VERBOSE = verbose # set verbose output, use a global variable in this case if VERBOSE > 0: t0 = time.time() if w0 is None: if fnpy is not None: try: w0 = np.load(fnpy, allow_pickle=False) assert w0.shape[0] == K * D + 1 print('Restore from %s' % fnpy) except (IOError, ValueError): w0 = np.zeros(K * D + 1) else: assert w0.shape[0] == K * D + 1 data_helper_example = None if self.loss_type == 'label' else DataHelper( Y_train, ax=0, batch_size=batch_size) data_helper_label = None if self.loss_type == 'example' else DataHelper( Y_train, ax=1, batch_size=batch_size) try: # f: callable(x, g, *args) # LBFGS().minimize(f, x0, progress=progress, args=args) optim = LBFGS() optim.linesearch = 'wolfe' res = optim.minimize( objective, w0, progress, args=(X_train, Y_train, self.C1, self.C2, self.C3, self.p, self.loss_type, user_playlist_indices, data_helper_example, data_helper_label, fnpy)) self.b = res[0] self.W = res[1:].reshape(K, D) self.trained = True except (LBFGSError, MemoryError) as err: self.trained = False sys.stderr.write('LBFGS failed: {0}\n'.format(err)) sys.stderr.flush() if VERBOSE > 0: print('Training finished in %.1f seconds' % (time.time() - t0))
def test_class_interface(): def f(x, g, *args): g[:] = 4 * x return x ** 4 + 1 opt = LBFGS() opt.max_iterations = 3 assert_array_equal(opt.minimize(f, 1e6), [0]) opt.max_iterations = 1 assert_raises(LBFGSError, opt.minimize, f, 1e7)
def test_class_interface(): def f(x, g, *args): g[:] = 4 * x return x**4 + 1 opt = LBFGS() opt.max_iterations = 3 assert_array_equal(opt.minimize(f, 1e6), [1]) opt.max_iterations = 1 assert_raises(LBFGSError, opt.minimize, f, 1e7)
def minimize_lbfgs(self, objective): w = torch.rand(self.dim_w, 1,dtype=dtype, requires_grad=True) optimizer_w = LBFGS([w], lr=1, max_iter=10000, max_eval=15000, tolerance_grad=1e-09, tolerance_change=1e-11, history_size=100, line_search_fn='strong_wolfe') n_iterations = 10 L_min = 1e10; i_min=0; trailing_grad_norm = 0 trailing_objective = 0 if objective == 'bias_td_var_opt_cf' or objective == 'bias_td_var': trajectory_reward_feature = ((self.discount*self.rho[self.s,self.a]*self.r)[:,:,None]*self.phi_w(self.s)).sum(dim=1).t() trajectory_reward_feature_hat = ((self.discount*self.rho_hat[self.s,self.a]*self.r)[:,:,None]*self.phi_w(self.s)).sum(dim=1).t() #* creating bootstrap samples k=5000#self.n_trajectories average_reward_feature = torch.zeros(self.dim_w,k, dtype=dtype) for i in range(k): idx = torch.multinomial(torch.ones(self.n_trajectories)/self.n_trajectories,self.n_trajectories, replacement = True) # average_reward_feature[:,i] = torch.mean(trajectory_reward_feature[:,idx]/self.horizon_normalization, dim=1) average_reward_feature[:,i] = torch.mean(trajectory_reward_feature[:,idx], dim=1) def closure(): optimizer_w.zero_grad() f_w = torch.mm(w.t(), self.X_bias)+ self.y_bias.t() if objective == 'bias_opt_cf' or objective == 'bias': loss = torch.mm(f_w, f_w.t()) elif objective == 'bias_td_opt_cf' or objective == 'bias_td': loss = (torch.abs(torch.mm(f_w, self.v0))+math.sqrt(self.reg*torch.mm(torch.mm(f_w, self.M_inv), f_w.t())))**2 elif objective == 'bias_td_var_opt_cf' or objective == 'bias_td_var': bias = (torch.abs(torch.mm(f_w, self.v0))+math.sqrt(self.reg*torch.mm(torch.mm(f_w, self.M_inv), f_w.t())))**2 variance = 1/2*torch.var(torch.mm(w.t(), average_reward_feature)) #/ self.horizon_normalization**2 # variance = 1.0/k*((torch.mm(w.t(), average_reward_feature) - torch.mean(torch.mm(w.t(), trajectory_reward_feature)))**2).sum() loss = bias + variance loss.backward() return loss # pdb.set_trace() for i in range(n_iterations): L = optimizer_w.step(closure) trailing_objective = 1/(i+1)*L + i / (i+1)*trailing_objective if L<L_min: L_min = L; w_min = w.clone().detach(); i_min=i trailing_grad_norm = 1/(i+1)*torch.norm(w.grad) + i/(i+1)*trailing_grad_norm w_estimator = self.w_estimator(w) if i%100 ==0 and self.config.print_progress: print('\n') print('opt objective', objective) print('iteration ', i) print('trailing objective:', trailing_objective) print('current w estimator: ', w_estimator) print('reg:', self.reg) print('current objective:', L) print('min objective:', L_min) print('min iteration:', i_min) print('w min estimator:', self.w_estimator(w_min)) return self.w_estimator(w_min)
def run(args): if args.out_dir != None: if not os.path.exists(args.out_dir): try: os.mkdir(args.out_dir) except: print 'cannot make directory {}'.format(args.out_dir) exit() elif not os.path.isdir(args.out_dir): print 'file path {} exists but is not directory'.format(args.out_dir) exit() if args.type == 'vgg19': vgg = VGG19() else: vgg = VGG() content_image = open_and_resize_image(args.content, args.width, vgg) print 'loading content image completed' style_image = open_and_resize_image(args.style, args.width, vgg) if args.match_color_histogram: style_image = util.match_color_histogram(style_image, content_image) if args.luminance_only: content_image, content_iq = util.split_bgr_to_yiq(content_image) style_image, style_iq = util.split_bgr_to_yiq(style_image) content_mean = np.mean(content_image, axis=(1,2,3), keepdims=True) content_std = np.std(content_image, axis=(1,2,3), keepdims=True) style_mean = np.mean(style_image, axis=(1,2,3), keepdims=True) style_std = np.std(style_image, axis=(1,2,3), keepdims=True) style_image = (style_image - style_mean) / style_std * content_std + content_mean print 'loading style image completed' serializers.load_hdf5(args.model, vgg) print 'loading neural network model completed' optimizer = LBFGS(args.lr) content_layers = args.content_layers.split(',') style_layers = args.style_layers.split(',') def on_epoch_done(epoch, x, losses): if (epoch + 1) % args.save_iter == 0: image = cuda.to_cpu(x.data) if args.luminance_only: image = util.join_yiq_to_bgr(image, content_iq) image = vgg.postprocess(image[0], output_type='RGB').clip(0, 255).astype(np.uint8) Image.fromarray(image).save(os.path.join(args.out_dir, 'out_{0:04d}.png'.format(epoch + 1))) print 'epoch {} done'.format(epoch + 1) print 'losses:' label_width = max(map(lambda (name, loss): len(name), losses)) for name, loss in losses: print ' {0:{width}s}: {1:f}'.format(name, loss, width=label_width) if args.method == 'mrf': model = MRF(vgg, optimizer, args.content_weight, args.style_weight, args.tv_weight, content_layers, style_layers, args.resolution_num, args.gpu, initial_image=args.initial_image, keep_color=args.keep_color) else: model = NeuralStyle(vgg, optimizer, args.content_weight, args.style_weight, args.tv_weight, content_layers, style_layers, args.resolution_num, args.gpu, initial_image=args.initial_image, keep_color=args.keep_color) out_image = model.fit(content_image, style_image, args.iter, on_epoch_done) out_image = cuda.to_cpu(out_image.data) if args.luminance_only: out_image = util.join_yiq_to_bgr(out_image, content_iq) image = vgg.postprocess(out_image[0], output_type='RGB').clip(0, 255).astype(np.uint8) Image.fromarray(image).save(os.path.join(args.out_dir, 'out.png'))
def fit(self, w0=None, verbose=0, fnpy=None): N, U, D = self.N, self.U, self.D if verbose > 0: t0 = time.time() print('\nC: %g, %g, %g' % (self.C1, self.C2, self.C3)) num_vars = (U + N + 1) * D if w0 is None: if fnpy is None: w0 = self._init_vars() else: try: assert type(fnpy) == str assert fnpy.endswith('.npy') w0 = np.load(fnpy, allow_pickle=False) print('Restore from %s' % fnpy) except (IOError, ValueError): w0 = self._init_vars() assert w0.shape == (num_vars, ) try: # f: callable(x, g, *args) # LBFGS().minimize(f, x0, progress=progress, args=args) optim = LBFGS() optim.linesearch = 'wolfe' optim.max_linesearch = 100 param_dict = {'N': self.N, 'C': (self.C1, self.C2, self.C3)} res = optim.minimize(objective, w0, progress, args=(self.X, self.cliques, self.data_helper, param_dict, verbose, fnpy)) self.mu = res[:D] self.V = res[D:(U + 1) * D].reshape(U, D) self.W = res[(U + 1) * D:].reshape(N, D) self.trained = True except (LBFGSError, MemoryError) as err: self.trained = False sys.stderr.write('LBFGS failed: {0}\n'.format(err)) sys.stderr.flush() if verbose > 0: print('Training finished in %.1f seconds' % (time.time() - t0))
def __init__(self, f, g, penalty, x0, **kwargs): self.f = f self.g = g self.penalty = penalty self.x = x0.copy() self.optimizer = LBFGS() self.optimizer.orthantwise_c = self.penalty self.optimizer.linesearch = 'wolfe' self.optimizer.max_iterations = kwargs.get('max_iterations', 100) self.optimizer.delta = kwargs.get('delta', 1e-4) self.optimizer.past = 1
def fit(self, w0=None, verbose=0, fnpy='_'): N, U, D = self.N, self.U, self.D if verbose > 0: t0 = time.time() if verbose > 0: print('\nC: %g, %g, p: %g' % (self.C1, self.C2, self.p)) num_vars = (U + N + 1) * D if w0 is None: np.random.seed(0) if fnpy is not None: try: w0 = np.load(fnpy, allow_pickle=False) print('Restore from %s' % fnpy) except (IOError, ValueError): w0 = 1e-3 * np.random.randn(num_vars) else: w0 = 1e-3 * np.random.randn(num_vars) if w0.shape != (num_vars, ): raise ValueError('ERROR: incorrect dimention for initial weights.') try: # f: callable(x, g, *args) # LBFGS().minimize(f, x0, progress=progress, args=args) optim = LBFGS() optim.linesearch = 'wolfe' optim.orthantwise_c = self.C2 optim.orthantwise_start = U * D # start index to compute L1 regularisation (included) optim.orthantwise_end = w0.shape[ 0] # end index to compute L1 regularisation (not included) res = optim.minimize(objective, w0, progress, args=(self.X, self.Y, self.C1, self.p, self.cliques, self.data_helper, verbose, fnpy)) self.V = res[:U * D].reshape(U, D) self.W = res[U * D:(U + N) * D].reshape(N, D) self.mu = res[(U + N) * D:] assert self.mu.shape == (D, ) self.trained = True except (LBFGSError, MemoryError) as err: self.trained = False sys.stderr.write('LBFGS failed: {0}\n'.format(err)) sys.stderr.flush() if verbose > 0: print('Training finished in %.1f seconds' % (time.time() - t0))
def train_loglin(trainX, trainY, reg_const): D, V = trainX.shape K = 2 #two classes #print 'K={0}, D={1}, V={2}'.format(K, D, V) assert trainX.shape[0] == len(trainY) beta = loglinmm.get_beta(trainX) gamma0 = np.random.rand(K, V) #PYLBFGS stuff bb = LBFGS() bb.orthantwise_c = 2.0**reg_const bb.linesearch = 'wolfe' bb.epsilon = 1e-01 bb.delta = 1e-01 #find optimum gamma_opt = bb.minimize(loglinmm.negll, gamma0, None, [beta, trainX, trainY]) w_given_class = loglinmm.prob_w_given_k(beta, gamma_opt) return w_given_class
def fit(self, w0=None, verbose=0, fnpy='_'): N, U, D = self.N, self.U, self.D if verbose > 0: t0 = time.time() if verbose > 0: print('\nC: %g, p: %g' % (self.C, self.p)) if w0 is not None: assert w0.shape[0] == (U + N + 1) * D else: if fnpy is not None: try: w0 = np.load(fnpy, allow_pickle=False) assert w0.shape[0] == (U + N + 1) * D print('Restore from %s' % fnpy) except (IOError, ValueError): w0 = np.zeros((U + N + 1) * D) try: # f: callable(x, g, *args) # LBFGS().minimize(f, x0, progress=progress, args=args) optim = LBFGS() optim.linesearch = 'wolfe' optim.orthantwise_c = self.C optim.orthantwise_start = (U + 1) * D # start index to compute L1 regularisation (included) optim.orthantwise_end = w0.shape[0] # end index to compute L1 regularisation (not included) res = optim.minimize(objective_L1, w0, progress, args=(self.X, self.Y, self.C, self.p, self.cliques, self.data_helper, verbose, fnpy)) self.mu = res[:D] self.V = res[D:(U + 1) * D].reshape(U, D) self.W = res[(U + 1) * D:].reshape(N, D) self.trained = True except (LBFGSError, MemoryError) as err: self.trained = False sys.stderr.write('LBFGS failed: {0}\n'.format(err)) sys.stderr.flush() if verbose > 0: print('Training finished in %.1f seconds' % (time.time() - t0))
## Set Targetå yy = datasets.MNIST('deeprobust/image/data', download=False).targets[8888] yy = yy.float() predict0 = model(xx) predict0 = predict0.argmax(dim=1, keepdim=True) attack_param = { 'epsilon': 2e-1, 'maxiter': 20, 'clip_max': 1, 'clip_min': 0, 'class_num': 10 } attack = LBFGS(model, device='cpu') AdvExArray = attack.generate(xx, yy, target_label=2, **attack_param) #AdvExArray = torch.from_numpy(AdvExArray) predict1 = model(AdvExArray) predict1 = predict1.argmax(dim=1, keepdim=True) print(predict0) print(predict1) import matplotlib.pyplot as plt plt.imshow(AdvExArray[0, 0] * 255, cmap='gray', vmin=0, vmax=255) plt.savefig('advexample.png')
class LBFGSNoisyOptimizer(BaseOptimizer): def __init__(self, oracle: BaseConditionalGenerationOracle, x: torch.Tensor, lr: float = 1e-1, memory_size: int = 5, line_search='Wolfe', lr_algo='None', *args, **kwargs): super().__init__(oracle, x, *args, **kwargs) self._line_search = line_search self._lr = lr self._alpha_k = None self._lr_algo = lr_algo # None, grad, dim if not (lr_algo in ["None", "Grad", "Dim"]): ValueError("lr_algo is not right") if self._x_step: self._optimizer = LBFGS(params=[self._x], lr=self._x_step / 10., line_search=line_search, history_size=memory_size) else: self._optimizer = LBFGS(params=[self._x], lr=self._lr, line_search=line_search, history_size=memory_size) def _step(self): x_k = self._x.detach().clone() x_k.requires_grad_(True) self._optimizer.param_groups[0]['params'][0] = x_k init_time = time.time() f_k = self._oracle.func(x_k, num_repetitions=self._num_repetitions) g_k = self._oracle.grad(x_k, num_repetitions=self._num_repetitions) grad_normed = g_k # (g_k / g_k.norm()) self._state_dict = copy.deepcopy(self._optimizer.state_dict()) if self._lr_algo == "None": self._optimizer.param_groups[0]['lr'] = self._x_step elif self._lr_algo == "Grad": self._optimizer.param_groups[0]['lr'] = self._x_step / g_k.norm( ).item() elif self._lr_algo == "Dim": self._optimizer.param_groups[0]['lr'] = self._x_step / np.sqrt( chi2.ppf(0.95, df=len(g_k))) # define closure for line search def closure(): self._optimizer.zero_grad() loss = self._oracle.func(x_k, num_repetitions=self._num_repetitions) return loss # two-loop recursion to compute search direction p = self._optimizer.two_loop_recursion(-grad_normed) options = { 'closure': closure, 'current_loss': f_k, 'interpolate': False } if self._line_search == 'Wolfe': lbfg_opt = self._optimizer.step(p, grad_normed, options=options) f_k, d_k, lr = lbfg_opt[0], lbfg_opt[1], lbfg_opt[2] elif self._line_search == 'Armijo': lbfg_opt = self._optimizer.step(p, grad_normed, options=options) f_k, lr = lbfg_opt[0], lbfg_opt[1] d_k = -g_k elif self._line_search == 'None': # self._optimizer.param_groups[0]['lr'] = 1. d_k = -g_k lbfg_opt = self._optimizer.step(p, grad_normed, options=options) lr = lbfg_opt g_k = self._oracle.grad(x_k, num_repetitions=self._num_repetitions) grad_normed = g_k # (g_k / g_k.norm()) self._optimizer.curvature_update(grad_normed, eps=0.2, damping=False) self._lbfg_opt = lbfg_opt grad_norm = d_k.norm().item() self._x = x_k super()._post_step(init_time=init_time) if grad_norm < self._tolerance: return SUCCESS if not (torch.isfinite(x_k).all() and torch.isfinite(f_k).all() and torch.isfinite(d_k).all()): return COMP_ERROR def reverse_optimizer(self, **kwargs): self._optimizer.load_state_dict(self._state_dict)
lr = 1.0 content_weight = 5 style_weight = 100 tv_weight = 1e-3 width = 500 content_layers = '3_3,4_3' style_layers = '1_2,2_2,3_3,4_3' initial_image = 'random' resolution_num = 1 keep_color = False vgg = VGG() serializers.load_hdf5(args.model, vgg) print 'loading neural network model completed' optimizer = LBFGS(args.lr) def open_and_resize_image(path, target_width, model): image = Image.open(path).convert('RGB') width, height = image.size target_height = int(round(float(height * target_width) / width)) image = image.resize((target_width, target_height), Image.BILINEAR) return np.expand_dims( model.preprocess(np.asarray(image, dtype=np.float32), input_type='RGB'), 0) def run(arg): content_image = open_and_resize_image('php/upload/' + arg.f + '.jpg', args.width, vgg)
def optimize(net, link, target_layers, iteration): optimizer = LBFGS(size=10) optimizer.setup(link) for i in six.moves.range(iteration): update(net, optimizer, link, target_layers) return link.x.data
def main(): args = parse_arg() iteration = args.iter batch_size = args.batch_size device_id = args.gpu lr = args.lr tv_weight = args.tv_weight max_image = args.max_image near_image_num = args.near_image net = VGG19() serializers.load_npz(args.model, net) if device_id >= 0: net.to_gpu(device_id) xp = net.xp image = load_image(args.input_image, input_image_size) x = xp.asarray(image) org_layers = feature(net, x) org_layers = [layer.data for layer in org_layers] print('Calculating source feature') source_image_files = list_dir_image(args.source_dir, max_image) if len(source_image_files) > near_image_num: source_image_files = rank_image(net, source_image_files, input_image_size, image, near_image_num) source_feature = mean_feature(net, source_image_files, input_image_size, org_layers[-1], near_image_num, batch_size) print('Calculating target feature') target_image_files = list_dir_image(args.target_dir, max_image) if len(target_image_files) > near_image_num: target_image_files = rank_image(net, target_image_files, input_image_size, image, near_image_num) target_feature = mean_feature(net, target_image_files, input_image_size, org_layers[-1], near_image_num, batch_size) attribute_vector = [ feature_diff(s, t) for s, t in zip(source_feature, target_feature) ] base, ext = os.path.splitext(args.output_image) for i in six.moves.range(1, 11): w = i * 0.2 print('Generating image for weight: {0:.2f}'.format(w)) link = chainer.Link(x=x.shape) if device_id >= 0: link.to_gpu(device_id) link.x.data[...] = xp.random.uniform(-10, 10, x.shape).astype(np.float32) target_layers = [ layer + w * a for layer, a in zip(org_layers, attribute_vector) ] optimizer = LBFGS(lr, size=5) optimizer.setup(link) for j in six.moves.range(iteration): losses = update(net, optimizer, link, target_layers, tv_weight) print(losses) if (j + 1) % 500 == 0: print('iter {} done loss:'.format(j + 1)) save_image( '{0}_{1:02d}_{2:04d}{3}'.format(base, i, j + 1, ext), cuda.to_cpu(link.x.data)) save_image('{0}_{1:02d}{2}'.format(base, i, ext), cuda.to_cpu(link.x.data)) print('Completed')
xx = xx.unsqueeze_(0).float() / 255 xx = xx.unsqueeze_(0).float() ## Set Targetå yy = datasets.MNIST('../data').targets[8888] yy = yy.float() lbfgs_params = { 'epsilon': 1e-4, 'maxiter': 20, 'clip_max': 1, 'clip_min': 0, 'class_num': 10 } attack = LBFGS(model, 8, device='cpu') AdvExArray, dis, loss, valueofc = attack.generate(xx, yy, **lbfgs_params) AdvExArray = AdvExArray.unsqueeze_(0).float() #test the result predict0 = model(xx) predict0 = predict0.argmax(dim=1, keepdim=True) #AdvExArray = torch.from_numpy(AdvExArray) predict1 = model(AdvExArray) predict1 = predict1.argmax(dim=1, keepdim=True) print(predict0) print(predict1, 'distance:', dis, 'target func:', loss, 'c:', valueofc) import matplotlib.pyplot as plt
def train(args, image_path, source_image_paths, target_image_paths, input_clip_rect=None, clip_rect=None): iteration = args.iter batch_size = args.batch_size device_id = args.gpu lr = args.lr tv_weight = args.tv_weight near_image_num = args.near_image make_dir(os.path.split(args.output_image)[0]) net = VGG19() serializers.load_npz(args.model, net) if device_id >= 0: net.to_gpu(device_id) xp = net.xp original_image = Image.open(image_path).convert('RGB') if input_clip_rect is not None: original_image = original_image.crop(input_clip_rect) image = preprocess_image(original_image, input_image_size) image_mean = np.mean(image, axis=(2, 3), keepdims=True) image_std = np.std(image, axis=(2, 3), keepdims=True) x = xp.asarray(image) org_layers = feature(net, x) org_layers = [layer.data for layer in org_layers] org_layer_norms = [ xp.asarray(np.linalg.norm(cuda.to_cpu(layer), axis=1, keepdims=True)) for layer in org_layers ] print('Calculating source feature') if len(source_image_paths) > near_image_num: source_image_paths = rank_image(net, source_image_paths, input_image_size, image, near_image_num, clip_rect) source_feature = mean_feature(net, source_image_paths, input_image_size, org_layers[-1], near_image_num, batch_size, clip_rect) print('Calculating target feature') if len(target_image_paths) > near_image_num: target_image_paths = rank_image(net, target_image_paths, input_image_size, image, near_image_num, clip_rect) target_feature = mean_feature(net, target_image_paths, input_image_size, org_layers[-1], near_image_num, batch_size, clip_rect) attribute_vectors = [ normalized_diff(s, t) for s, t in zip(source_feature, target_feature) ] base, ext = os.path.splitext(args.output_image) residuals = [] initial_x = xp.random.uniform(-10, 10, x.shape).astype(np.float32) print('Calculating residuals') link = chainer.Link(x=x.shape) if device_id >= 0: link.to_gpu(device_id) link.x.data[...] = initial_x optimizer = LBFGS(lr, stack_size=5) optimizer.setup(link) for j in six.moves.range(600): losses = update(net, optimizer, link, org_layers, tv_weight) if (j + 1) % 20 == 0: z = cuda.to_cpu(link.x.data) z = adjust_color_distribution(z, image_mean, image_std) residuals.append(z - image) for i in six.moves.range(1, 6): w = i * 0.1 print('Generating image for weight: {0:.2f}'.format(w)) link = chainer.Link(x=x.shape) if device_id >= 0: link.to_gpu(device_id) link.x.data[...] = initial_x target_layers = [ layer + w * n * a for layer, n, a in zip( org_layers, org_layer_norms, attribute_vectors) ] optimizer = LBFGS(lr, stack_size=5) optimizer.setup(link) for j in six.moves.range(iteration): losses = update(net, optimizer, link, target_layers, tv_weight) if (j + 1) % 100 == 0: print('iter {} done loss:'.format(j + 1)) print(losses) if (j + 1) % 500 == 0: z = cuda.to_cpu(link.x.data) z = adjust_color_distribution(z, image_mean, image_std) z -= find_nearest(residuals, z - image) file_name = '{0}_{1:02d}_{2:04d}{3}'.format( base, i, j + 1, ext) postprocess_image(original_image, z - image).save(file_name) z = cuda.to_cpu(link.x.data) z = adjust_color_distribution(z, image_mean, image_std) z -= find_nearest(residuals, z - image) file_name = '{0}_{1:02d}{2}'.format(base, i, ext) postprocess_image(original_image, z - image).save(file_name) print('Completed')