Пример #1
0
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
Пример #2
0
 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)
Пример #3
0
    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))
Пример #4
0
    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))
Пример #5
0
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)
Пример #6
0
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'))
Пример #9
0
    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))
Пример #10
0
    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
Пример #11
0
    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))
Пример #12
0
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
Пример #13
0
    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))
Пример #14
0
## 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')
Пример #15
0
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)
Пример #16
0
    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)
Пример #17
0
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
Пример #18
0
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')
Пример #19
0
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
Пример #20
0
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')