def test_get_logits(self): # Define empty model model = Model('model', 10, {}) x = [] # Exception is thrown when `get_logits` not implemented with self.assertRaises(Exception) as context: model.get_logits(x) self.assertTrue(context.exception)
def __init__(self, scope, nb_classes, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) # Do a dummy run of fprop to make sure the variables are created from # the start self.fprop(tf.placeholder(tf.float32, [128, 32, 32, 3])) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def test_fprop(self): # Define empty model model = Model('model', 10, {}) x = [] # Exception is thrown when `fprop` not implemented with self.assertRaises(Exception) as context: model.fprop(x) self.assertTrue(context.exception)
def test_get_layer(self): # Define empty model model = Model() x = [] # Exception is thrown when `get_layer` not implemented with self.assertRaises(Exception) as context: model.get_layer(x, layer='') self.assertTrue(context.exception)
def test_fprop(self): # Define empty model model = Model() x = [] # Exception is thrown when `fprop` not implemented with self.assertRaises(Exception) as context: model.fprop(x) self.assertTrue(context.exception)
def __init__(self, scope, nb_classes, input_shape, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.input_shape = input_shape # Do a dummy run of fprop to create the variables from the start self.is_training = False self.fprop(tf.placeholder(tf.float32, [100] + input_shape)) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def __init__(self, scope, **kwargs): del kwargs Model.__init__(self, scope, locals()) self.n_units = 100 # Do a dummy run of fprop to make sure the variables are created from # the start self.fprop(tf.placeholder(tf.float32, shape=(128, 28, 28, 1))) #self.fprop(tf.placeholder(tf.float32, shape = (128, 100, 1))) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def __init__(self, scope, **kwargs): del kwargs Model.__init__(self, scope, locals()) #self.n_fcc = n_fcc self.latent_dim = 20 #self.batch_size= batch_size # Do a dummy run of fprop to make sure the variables are created from # the start self.fprop(tf.placeholder(tf.float32, shape = (90, 32, 32, 3)))
def __init__(self, scope, nb_classes, n, input_shape, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.n = n self.net = OrderedDict() # Do a dummy run of fprop to create the variables from the start self.fprop(tf.placeholder(tf.float32, [32] + input_shape)) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def __init__(self, scope, nb_classes, hparams, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_classes = nb_classes self.dataset = hparams['dataset'] self.secret_seed = hparams['secret_seed'] if self.dataset == 'mnist': self.fprop(tf.placeholder(tf.float32, [128, 28, 28, 1])) elif self.dataset == 'cifar' or self.dataset == 'cifar10': self.fprop(tf.placeholder(tf.float32, [128, 32, 32, 3]))
def __init__(self, scope, nb_classes, num_dims, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = 64 self.num_neurons = num_dims * 4 self.num_dims = num_dims # Do a dummy run of fprop to make sure the variables are created from # the start self.fprop(tf.placeholder(tf.float32, [32, 1, 1, self.num_dims])) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def __init__(self, nb_classes=10): # NOTE: for compatibility with Madry Lab downloadable checkpoints, # we cannot use scopes, give these variables names, etc. self.W_conv1 = self._weight_variable([5, 5, 1, 32]) self.b_conv1 = self._bias_variable([32]) self.W_conv2 = self._weight_variable([5, 5, 32, 64]) self.b_conv2 = self._bias_variable([64]) self.W_fc1 = self._weight_variable([7 * 7 * 64, 1024]) self.b_fc1 = self._bias_variable([1024]) self.W_fc2 = self._weight_variable([1024, nb_classes]) self.b_fc2 = self._bias_variable([nb_classes]) Model.__init__(self, '', nb_classes, {})
def __init__(self, scope, nb_classes, nb_filters, input_shape, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = nb_filters self.input_shape = input_shape # [32, 32, 3] self.dummpy_input = tf.placeholder(tf.float32, [FLAGS.batch_size] + input_shape) # Do a dummy run of fprop to create the variables from the start # BATCH_SIZE, img_rows, img_cols, nchannels self.fprop(self.dummpy_input) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def __init__(self, scope, nb_classes, nb_filters, input_shape, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = nb_filters self.input_shape = input_shape # Do a dummy run of fprop to create the variables from the start self.fprop(tf.placeholder(tf.float32, [32] + input_shape)) # Put a reference to the params in self so that the params get pickled self.params = self.get_params() self.d1 = tf.layers.Dense(128, activation='relu') self.d2 = tf.layers.Dense(2, activation='softmax')
def __init__(self, scope, nb_classes, nb_filters, weights, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = 32 self.weights = weights self.layer_info = np_weights(self.weights) print(self.layer_info[0][0].shape, self.layer_info[0][1].shape) print(self.layer_info[1][0].shape, self.layer_info[1][1].shape) print(self.layer_info[2][0].shape, self.layer_info[2][1].shape) # Do a dummy run of fprop to make sure the variables are created from # the start self.fprop(tf.placeholder(tf.float32, [1, 28, 28, 1])) # Put a reference to the params in self so that the params get pickled self.params = self.get_params()
def test_back(self): model = Model() # Exception is thrown when back is not tf or th with self.assertRaises(Exception) as context: Attack(model, back='test', sess=None) self.assertTrue(context.exception)
def test_cache(): # Test that _CorrectFactory can be cached model = Model() factory_1 = _CorrectFactory(model) factory_2 = _CorrectFactory(model) cache = {} cache[factory_1] = True assert factory_2 in cache
def test_cache(self): """test_cache: Test that _CorrectFactory can be cached""" model = Model() factory_1 = _CorrectFactory(model) factory_2 = _CorrectFactory(model) cache = {} cache[factory_1] = True self.assertTrue(factory_2 in cache)
def __init__( self, nb_classes=10, nb_filters=64, dummy_input=tf.zeros((32, 28, 28, 1)) ): Model.__init__(self, nb_classes=nb_classes) # Parametes # number of filters, number of classes. self.nb_filters = nb_filters self.nb_classes = nb_classes # Lists for layers attributes. # layer names , layers, layer activations self.layer_names = ["input", "conv_1", "conv_2", "conv_3", "flatten", "logits"] self.layers = {} self.layer_acts = {} # layer definitions self.layers["conv_1"] = tf.layers.Conv2D( filters=self.nb_filters, kernel_size=8, strides=2, padding="same", activation=tf.nn.relu, ) self.layers["conv_2"] = tf.layers.Conv2D( filters=self.nb_filters * 2, kernel_size=6, strides=2, padding="valid", activation=tf.nn.relu, ) self.layers["conv_3"] = tf.layers.Conv2D( filters=self.nb_filters * 2, kernel_size=5, strides=1, padding="valid", activation=tf.nn.relu, ) self.layers["flatten"] = tf.layers.Flatten() self.layers["logits"] = tf.layers.Dense(self.nb_classes, activation=None) # Dummy fprop to activate the network. self.fprop(dummy_input)
def test_sess_generate_np(self): model = Model('model', 10, {}) class DummyAttack(Attack): def generate(self, x, **kwargs): return x attack = DummyAttack(model, back='tf', sess=None) with self.assertRaises(Exception) as context: attack.generate_np(0.) self.assertTrue(context.exception)
def __init__(self, nb_classes=10, nb_filters=64, dummy_input=tf.zeros((32, 28, 28, 1))): Model.__init__(self, nb_classes=nb_classes) # Parametes # number of filters, number of classes. self.nb_filters = nb_filters self.nb_classes = nb_classes # Lists for layers attributes. # layer names , layers, layer activations self.layer_names = [ 'input', 'conv_1', 'conv_2', 'conv_3', 'flatten', 'logits' ] self.layers = {} self.layer_acts = {} # layer definitions self.layers['conv_1'] = tf.layers.Conv2D(filters=self.nb_filters, kernel_size=8, strides=2, padding='same', activation=tf.nn.relu) self.layers['conv_2'] = tf.layers.Conv2D(filters=self.nb_filters * 2, kernel_size=6, strides=2, padding='valid', activation=tf.nn.relu) self.layers['conv_3'] = tf.layers.Conv2D(filters=self.nb_filters * 2, kernel_size=5, strides=1, padding='valid', activation=tf.nn.relu) self.layers['flatten'] = tf.layers.Flatten() self.layers['logits'] = tf.layers.Dense(self.nb_classes, activation=None) # Dummy fprop to activate the network. output = self.fprop(dummy_input)
def __init__(self, scope, img_size, nb_classes, in_channels=3, dim_hidden=64, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.img_size = img_size self.dim_output = nb_classes self.dim_hidden = dim_hidden self.in_channels = in_channels self.max_pool = True self.is_training = False # self.weight = self.construct_conv_weights(dim_output=nb_classes, channels=in_channels, dim_hidden=dim_hidden) # Do a dummy run of fprop to create the variables from the start self.dummpy_input = tf.placeholder( tf.float32, [FLAGS.batch_size, img_size, img_size, in_channels]) self.fprop(self.dummpy_input) self.params = self.get_params()
def __init__(self, scope, nb_classes, nb_filters, **kwargs): # self.fprop(tf.placeholder(tf.float32, [128, 28, 28, 1])) # # Put a reference to the params in self so that the params get pickled # self.params = self.get_params() # print(self.params) del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = nb_filters self.nb_classes = nb_classes self.s = scope print("hello") x = tf.placeholder(tf.float32, shape=(None, 28, 28, 1)) # Do a dummy run of fprop to make sure the variables are created from # the start self.fprop(x) # Put areference to the params in self so that the params get pickled self.params = self.get_params()
def __init__(self, nb_classes=10): # we cannot use scopes, give these variables names, etc. self.W_conv1 = self._weight_variable([5, 5, 1, 32], name='classifier/conv1/weights') self.b_conv1 = self._bias_variable([32], name='classifier/conv1/biases') self.W_conv2 = self._weight_variable([5, 5, 32, 64], name='classifier/conv2/weights') self.b_conv2 = self._bias_variable([64], name='classifier/conv2/biases') self.W_fc1 = self._weight_variable([1600, 1024], name='classifier/fc1/weights') self.b_fc1 = self._bias_variable([1024], name='classifier/fc1/biases') self.W_fc2 = self._weight_variable([1024, nb_classes], name='classifier/fc2/weights') self.b_fc2 = self._bias_variable([nb_classes], name='classifier/fc2/biases') self.all_variables = [ self.W_conv1, self.b_conv1, self.W_conv2, self.b_conv2, self.W_fc1, self.b_fc1, self.W_fc2, self.b_fc2 ] #self.xent = tf.Variable(tf.zeros([16,10])) Model.__init__(self, '', nb_classes, {})
def test_sess_generate_np(self): model = Model('model', 10, {}) class DummyAttack(Attack): def generate(self, x, **kwargs): return x # Test that generate_np is NOT permitted without a session. # The session still needs to be created prior to running the attack. with tf.Session() as sess: attack = DummyAttack(model, sess=None) with self.assertRaises(Exception) as context: attack.generate_np(0.) self.assertTrue(context.exception)
def __init__(self, model, max_l2_distortion=4, label_to_examples={}): self.max_l2_distortion = max_l2_distortion class Model: def bounds(self): return [0, 1] def predictions(self, img): return model(img[np.newaxis, :, :, :])[0] def batch_predictions(self, img): return model(img) self.label_to_examples = label_to_examples self.attack = FoolboxBoundaryAttack(model=Model())
def __init__(self, model, image_shape_hwc, max_l2_distortion=4, label_to_examples=None): if label_to_examples is None: label_to_examples = {} self.max_l2_distortion = max_l2_distortion class Model: def bounds(self): return [0, 1] def predictions(self, img): return model(img[np.newaxis, :, :, :])[0] def batch_predictions(self, img): return model(img) self.label_to_examples = label_to_examples h, w, c = image_shape_hwc mse_threshold = max_l2_distortion**2 / (h * w * c) try: # Foolbox 1.5 allows us to use a threshold the attack will abort after # reaching. Because we only care about a distortion of less than 4, as soon # as we reach it, we can just abort and move on to the next image. self.attack = FoolboxBoundaryAttack(model=Model(), threshold=mse_threshold) except: # Fall back to the original implementation. print("WARNING: Using foolbox version < 1.5 will cuase the " "boundary attack to perform more work than is required. " "Please upgrade to version 1.5") self.attack = FoolboxBoundaryAttack(model=Model())
def __init__(self, nb_classes=10): # NOTE: for compatibility with Madry Lab downloadable checkpoints, # we cannot use scopes, give these variables names, etc. """ self.conv1 = tf.layers.Conv2D(32, (5, 5), activation='relu', padding='same', name='conv1') self.pool1 = tf.layers.MaxPooling2D((2, 2), (2, 2), padding='same') self.conv2 = tf.layers.Conv2D(64, (5, 5), activation='relu', padding='same', name='conv2') self.pool2 = tf.layers.MaxPooling2D((2, 2), (2, 2), padding='same') self.fc1 = tf.layers.Dense(1024, activation='relu', name='fc1') self.fc2 = tf.layers.Dense(10, name='fc2') """ keras_model = tf.keras.Sequential() keras_model.add( tf.keras.layers.Conv2D(32, (5, 5), activation='relu', padding='same', name='conv1', input_shape=(28, 28, 1))) keras_model.add( tf.keras.layers.MaxPooling2D((2, 2), (2, 2), padding='same')) keras_model.add( tf.keras.layers.Conv2D(64, (5, 5), activation='relu', padding='same', name='conv2')) keras_model.add( tf.keras.layers.MaxPooling2D((2, 2), (2, 2), padding='same')) keras_model.add(tf.keras.layers.Flatten()) keras_model.add( tf.keras.layers.Dense(1024, activation='relu', name='fc1')) keras_model.add(tf.keras.layers.Dense(10, name='fc2')) self.keras_model = keras_model Model.__init__(self, '', nb_classes, {}) self.dataset_factory = Factory(MNIST, {"center": False})
def __init__(self, f): dummy_model = Model() super(Wrapper, self).__init__(model=dummy_model) self.f = f
def __init__(self, scope, nb_classes, nb_filters=200, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = nb_filters
def __init__(self, scope, nb_classes=1000, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals())
def __init__(self, scope='dummy_model', nb_classes=10, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals())
def __init__(self, scope='trivial', nb_classes=2, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals())
def __init__(self, scope, nb_classes, nb_filters, **kwargs): del kwargs Model.__init__(self, scope, nb_classes, locals()) self.nb_filters = nb_filters