attack_params = self.attack_params
if attack_params is None:
attack_params = {}
if self.pass_y:
x_adv = self.attack.generate(x_batch, y=y_batch, **attack_params)
else:
# Some code checks the keys of kwargs, rather than checking if
# y is None, so we need to truly not pass y at all, rather than
# just passing a None value for it.
x_adv = self.attack.generate(x_batch, **attack_params)
return (x_batch, y_batch), tuple([x_adv])
_logger = create_logger("cleverhans.evaluation")
# Cache for storing output of `batch_eval_multi_worker`'s calls to
# `graph_factory`, to avoid making the tf graph too big
_batch_eval_multi_worker_cache = {}
def _check_x(x):
"""
Makes sure an `x` argument is a valid numpy dataset.
"""
if not isinstance(x, np.ndarray):
raise TypeError("x must be a numpy array. Typically x contains "
"the entire test set inputs.")
"""The LBFGS attack
"""
import numpy as np
import tensorflow as tf
from cleverhansl2l.attacks.attack import Attack
from cleverhansl2l.compat import reduce_sum, softmax_cross_entropy_with_logits
from cleverhansl2l.model import CallableModelWrapper, Model, wrapper_warning
from cleverhansl2l import utils
from cleverhansl2l import utils_tf
_logger = utils.create_logger("cleverhans.attacks.lbfgs")
tf_dtype = tf.as_dtype('float32')
class LBFGS(Attack):
"""
LBFGS is the first adversarial attack for convolutional neural networks,
and is a target & iterative attack.
Paper link: "https://arxiv.org/pdf/1312.6199.pdf"
:param model: cleverhans.model.Model
:param sess: tf.Session
:param dtypestr: dtype of the data
:param kwargs: passed through to super constructor
"""
def __init__(self, model, sess, dtypestr='float32', **kwargs):
"""
Note: the model parameter should be an instance of the
cleverhans.model.Model abstraction provided by CleverHans.
import os
import time
import warnings
import math
import numpy as np
from six.moves import xrange
import tensorflow as tf
from cleverhansl2l import canary
from cleverhansl2l.utils import _ArgsWrapper, create_logger
from cleverhansl2l.utils import safe_zip
from cleverhansl2l.utils_tf import infer_devices
from cleverhansl2l.utils_tf import initialize_uninitialized_global_variables
_logger = create_logger("train")
_logger.setLevel(logging.INFO)
def train(sess,
loss,
x_train,
y_train,
init_all=False,
evaluate=None,
feed=None,
args=None,
rng=None,
var_list=None,
fprop_args=None,
optimizer=None,
import os
import time
import warnings
import numpy as np
import six
from six.moves import xrange
import tensorflow as tf
from cleverhansl2l.compat import device_lib
from cleverhansl2l.compat import reduce_sum, reduce_mean
from cleverhansl2l.compat import reduce_max
from cleverhansl2l.compat import softmax_cross_entropy_with_logits
from cleverhansl2l.utils import batch_indices, _ArgsWrapper, create_logger
_logger = create_logger("cleverhans.utils.tf")
_logger.setLevel(logging.INFO)
def model_loss(y, model, mean=True):
"""
Define loss of TF graph
:param y: correct labels
:param model: output of the model
:param mean: boolean indicating whether should return mean of loss
or vector of losses for each input of the batch
:return: return mean of loss if True, otherwise return vector with per
sample loss
"""
warnings.warn("This function is deprecated and will be removed on or after"
" 2019-04-05. Switch to cleverhans.train.train.")
"""
Attacks for TensorFlow Eager
"""
from distutils.version import LooseVersion
import numpy as np
import tensorflow as tf
from cleverhansl2l import attacks
from cleverhansl2l import utils
from cleverhansl2l.model import CallableModelWrapper, wrapper_warning
from cleverhansl2l.model import Model
from cleverhansl2l.loss import LossCrossEntropy
_logger = utils.create_logger("cleverhans.attacks_tfe")
if LooseVersion(tf.__version__) < LooseVersion('1.8.0'):
error_msg = ('For eager execution',
'use Tensorflow version greather than 1.8.0.')
raise ValueError(error_msg)
class Attack(attacks.Attack):
"""
Abstract base class for all eager attack classes.
:param model: An instance of the cleverhans.model.Model class.
:param back: The backend to use. Inherited from AttackBase class.
:param dtypestr: datatype of the input data samples and crafted
adversarial attacks.
"""
def __init__(self, model, dtypestr='float32'):