Python keras.backend.sign() Examples
The following are 8
code examples of keras.backend.sign().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
keras.backend
, or try the search function
.
.
Example #1
| Source File: fgs.py From blackbox-attacks with MIT License | 6 votes |
|
def symbolic_fgs(x, grad, eps=0.3, clipping=True):
"""
FGSM attack.
"""
# signed gradient
normed_grad = K.sign(grad)
# Multiply by constant epsilon
scaled_grad = eps * normed_grad
# Add perturbation to original example to obtain adversarial example
adv_x = K.stop_gradient(x + scaled_grad)
if clipping:
adv_x = K.clip(adv_x, 0, 1)
return adv_x
Example #2
| Source File: fgs.py From ensemble-adv-training with MIT License | 6 votes |
|
def symbolic_fgs(x, grad, eps=0.3, clipping=True):
"""
FGSM attack.
"""
# signed gradient
normed_grad = K.sign(grad)
# Multiply by constant epsilon
scaled_grad = eps * normed_grad
# Add perturbation to original example to obtain adversarial example
adv_x = K.stop_gradient(x + scaled_grad)
if clipping:
adv_x = K.clip(adv_x, 0, 1)
return adv_x
Example #3
| Source File: query_based_attack.py From blackbox-attacks with MIT License | 5 votes |
|
def overall_grad_est(j, logits, prediction, x, curr_sample, curr_target,
p_t, random_indices, num_groups, U=None):
basis_vec = np.zeros((BATCH_SIZE, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, FLAGS.NUM_CHANNELS))
if PCA_FLAG == False:
if j != num_groups-1:
curr_indices = random_indices[j*args.group_size:(j+1)*args.group_size]
elif j == num_groups-1:
curr_indices = random_indices[j*args.group_size:]
row = curr_indices/FLAGS.IMAGE_COLS
col = curr_indices % FLAGS.IMAGE_COLS
for i in range(len(curr_indices)):
basis_vec[:, row[i], col[i]] = 1.
elif PCA_FLAG == True:
basis_vec[:] = U[:,j].reshape((1, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, FLAGS.NUM_CHANNELS))
# basis_vec = np.sign(basis_vec)
x_plus_i = np.clip(curr_sample + args.delta * basis_vec, CLIP_MIN, CLIP_MAX)
x_minus_i = np.clip(curr_sample - args.delta * basis_vec, CLIP_MIN, CLIP_MAX)
if args.loss_type == 'cw':
logit_t_grad_est, logit_max_grad_est = CW_est(logits, x, x_plus_i,
x_minus_i, curr_sample, curr_target)
if '_un' in args.method:
single_grad_est = logit_t_grad_est - logit_max_grad_est
else:
single_grad_est = logit_max_grad_est - logit_t_grad_est
elif args.loss_type == 'xent':
single_grad_est = xent_est(prediction, x, x_plus_i, x_minus_i, curr_target)
return single_grad_est
Example #4
| Source File: yogi.py From keras-contrib with MIT License | 5 votes |
|
def get_updates(self, loss, params):
grads = self.get_gradients(loss, params)
self.updates = [K.update_add(self.iterations, 1)]
lr = self.lr
if self.initial_decay > 0:
lr = lr * (1. / (1. + self.decay * K.cast(self.iterations,
K.dtype(self.decay))))
t = K.cast(self.iterations, K.floatx()) + 1
lr_t = lr * (K.sqrt(1. - K.pow(self.beta_2, t)) /
(1. - K.pow(self.beta_1, t)))
ms = [K.zeros(K.int_shape(p), dtype=K.dtype(p)) for p in params]
vs = [K.zeros(K.int_shape(p), dtype=K.dtype(p)) for p in params]
vhats = [K.zeros(1) for _ in params]
self.weights = [self.iterations] + ms + vs + vhats
for p, g, m, v, vhat in zip(params, grads, ms, vs, vhats):
g2 = K.square(g)
m_t = (self.beta_1 * m) + (1. - self.beta_1) * g
v_t = v - (1. - self.beta_2) * K.sign(v - g2) * g2
p_t = p - lr_t * m_t / (K.sqrt(v_t) + self.epsilon)
self.updates.append(K.update(m, m_t))
self.updates.append(K.update(v, v_t))
new_p = p_t
# Apply constraints.
if getattr(p, 'constraint', None) is not None:
new_p = p.constraint(new_p)
self.updates.append(K.update(p, new_p))
return self.updates
Example #5
| Source File: DHNE.py From OpenHINE with MIT License | 5 votes |
|
def sparse_autoencoder_error(self, y_true, y_pred):
return K.mean(K.square(K.sign(y_true)*(y_true-y_pred)), axis=-1)
Example #6
| Source File: samplers.py From DeepIV with MIT License | 5 votes |
|
def random_laplace(shape, mu=0., b=1.):
'''
Draw random samples from a Laplace distriubtion.
See: https://en.wikipedia.org/wiki/Laplace_distribution#Generating_random_variables_according_to_the_Laplace_distribution
'''
U = K.random_uniform(shape, -0.5, 0.5)
return mu - b * K.sign(U) * K.log(1 - 2 * K.abs(U))
Example #7
| Source File: query_based_attack.py From blackbox-attacks with MIT License | 4 votes |
|
def white_box_fgsm(prediction, target_model, x, logits, y, X_test, X_test_ini, targets, targets_cat, eps, dim):
time1 = time.time()
#Get gradient from model
if args.loss_type == 'xent':
grad = gen_grad(x, logits, y)
elif args.loss_type == 'cw':
real = tf.reduce_sum(y*logits, 1)
other = tf.reduce_max((1-y)*logits - (y*10000), 1)
if '_un' in args.method:
loss = tf.maximum(0.0,real-other+args.conf)
else:
loss = tf.maximum(0.0,other-real+args.conf)
grad = K.gradients(loss, [x])[0]
# normalized gradient
if args.norm == 'linf':
normed_grad = K.sign(grad)
elif args.norm == 'l2':
normed_grad = K.l2_normalize(grad, axis = (1,2,3))
# Multiply by constant epsilon
scaled_grad = (eps - args.alpha) * normed_grad
# Add perturbation to original example to obtain adversarial example
if args.loss_type == 'xent':
if '_un' in args.method:
adv_x_t = K.stop_gradient(x + scaled_grad)
else:
adv_x_t = K.stop_gradient(x - scaled_grad)
elif args.loss_type == 'cw':
adv_x_t = K.stop_gradient(x - scaled_grad)
adv_x_t = K.clip(adv_x_t, CLIP_MIN, CLIP_MAX)
X_test_ini_slice = X_test_ini[:BATCH_SIZE*BATCH_EVAL_NUM]
targets_cat_mod = targets_cat[:BATCH_SIZE*BATCH_EVAL_NUM]
targets_mod = targets[:BATCH_SIZE*BATCH_EVAL_NUM]
X_adv_t = np.zeros_like(X_test_ini_slice)
for i in range(BATCH_EVAL_NUM):
X_test_slice = X_test[i*(BATCH_SIZE):(i+1)*(BATCH_SIZE)]
targets_cat_slice = targets_cat[i*(BATCH_SIZE):(i+1)*(BATCH_SIZE)]
X_adv_t[i*(BATCH_SIZE):(i+1)*(BATCH_SIZE)] = K.get_session().run([adv_x_t], feed_dict={x: X_test_slice, y: targets_cat_slice})[0]
adv_pred_np = K.get_session().run([prediction], feed_dict={x: X_adv_t})[0]
# _, _, white_box_error = tf_test_error_rate(target_model, x, X_adv_t, targets_cat_mod)
white_box_error = 100.0 * np.sum(np.argmax(adv_pred_np,1) != targets_mod) / adv_pred_np.shape[0]
if '_un' not in args.method:
white_box_error = 100.0 - white_box_error
wb_norm = np.mean(np.linalg.norm((X_adv_t-X_test_ini_slice).reshape(BATCH_SIZE*BATCH_EVAL_NUM, dim), axis=1))
print('Average white-box l2 perturbation: {}'.format(wb_norm))
time2= time.time()
print('Total time: {}, Average time: {}'.format(time2-time1, (time2 - time1)/(BATCH_SIZE*BATCH_EVAL_NUM)))
wb_write_out(eps, white_box_error, wb_norm)
return
Example #8
| Source File: ind_rnn.py From Keras-IndRNN with MIT License | 4 votes |
|
def build(self, input_shape):
input_dim = input_shape[-1]
if self.recurrent_clip_min == -1 or self.recurrent_clip_max == -1:
self.recurrent_clip_min = 0.0
if hasattr(self, 'timesteps') and self.timesteps is not None:
self.recurrent_clip_max = pow(2.0, 1. / self.timesteps)
else:
warnings.warn("IndRNNCell: Number of timesteps could not be determined. \n"
"Defaulting to max clipping range of 1.0. \n"
"If this model was trained using a specific timestep during training, "
"inference may be wrong due to this default setting.\n"
"Please ensure that you use the same number of timesteps during training "
"and evaluation")
self.recurrent_clip_max = 1.0
self.kernel = self.add_weight(shape=(input_dim, self.units),
name='input_kernel',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
if self.recurrent_initializer is None:
if self.recurrent_clip_min is not None and self.recurrent_clip_max is not None:
initialization_value = min(self.recurrent_clip_max, 1.0)
self.recurrent_initializer = initializers.uniform(-initialization_value,
initialization_value)
else:
self.recurrent_initializer = initializers.uniform(-1.0, 1.0)
self.recurrent_kernel = self.add_weight(shape=(self.units,),
name='recurrent_kernel',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
if self.recurrent_clip_min is not None and self.recurrent_clip_max is not None:
if abs(self.recurrent_clip_min):
abs_recurrent_kernel = K.abs(self.recurrent_kernel)
min_recurrent_kernel = K.maximum(abs_recurrent_kernel, abs(self.recurrent_clip_min))
self.recurrent_kernel = K.sign(self.recurrent_kernel) * min_recurrent_kernel
self.recurrent_kernel = K.clip(self.recurrent_kernel,
self.recurrent_clip_min,
self.recurrent_clip_max)
if self.use_bias:
bias_initializer = self.bias_initializer
self.bias = self.add_weight(shape=(self.units,),
name='bias',
initializer=bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
self.built = True
