def trainning(): (X, Y), (X_test, Y_test) = cifar10.load_data() Y = cifar10.to_categorical(Y, 10) Y_test = cifar10.to_categorical(Y_test, 10) data_set = cifar10.read_data_sets(X, Y, X_test, Y_test) # mnist = input_data.read_data_sets("tmp/mnist", one_hot=True) # batch_x, batch_y = data_set.train.next_batch(96) x_placeholder = tf.placeholder("float", [None, 32 * 32 * 3]) y_placeholder = tf.placeholder("float", [None, 10]) logits = cifar10.inference(x_placeholder) loss = cifar10.loss(logits, y_placeholder) train_op = cifar10.train_op(loss=loss, learning_rate=0.001) accuracy = cifar10.accuracy(logits, y_placeholder) init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) for step in range(MAX_STEPS): # print('step = {:d}'.format(step + 1)) batch_x, batch_y = data_set.train.next_batch(96) # print(batch_x.shape) # print(batch_y.shape) _, Loss, acc = sess.run([train_op, loss, accuracy], feed_dict={ x_placeholder: batch_x, y_placeholder: batch_y }) if (step + 1) % 100 == 0: print("step: {:d} loss: {:f} acc: {:f}".format( step + 1, Loss, acc))
def train(): cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv)) train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) cucumber = cifar10.load_data() session.run(tf.global_variables_initializer()) for i in range(20000): batch = cucumber.train.next_batch(50) if i % 100 == 0: train_accuracy = accuracy.eval(session=session, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 1.0 }) print('step %d, training accuracy %g' % (i, train_accuracy)) train_step.run(session=session, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 }) print('test accuracy %g' % accuracy.eval(session=session, feed_dict={ x: cucumber.test.images, y_: cucumber.test.labels, keep_prob: 1.0 })) saver.save(sess=session, save_path=save_path)
def load_data(dataset=10, is_tune=False, is_crop_filp=False): if dataset == 10: (train_data, train_labels), (test_data, test_labels) = cifar10.load_data() if is_tune: test_data = train_data[-10000:] test_labels = train_labels[-10000:] train_data = train_data[:-10000] train_labels = train_labels[:-10000] # (N, 1) --> (N,) train_labels = np.squeeze(train_labels) test_labels = np.squeeze(test_labels) # per image standarizartion test_data = per_image_standardization(test_data) # use the below line only when online setting if is_crop_filp: train_data = padding(train_data) train_data = random_crop_and_flip(train_data, padding_size=2) else: train_data = train_data train_data = per_image_standardization(train_data) print( 'Loading dataset: [CIFAR%d], is_tune: [%s], is_preprocessed: [%s], is_crop_filp:[%s]' % (dataset, is_tune, 'True', str(is_crop_filp))) print('Train_data: {}, Test_data: {}'.format(train_data.shape, test_data.shape)) return (train_data, train_labels), (test_data, test_labels)
def __init__(self, dataset): num_classes = 10 (train_data, train_labels), (test_data, test_labels) = cifar10.load_data() img_rows, img_cols = 32, 32 if backend.image_data_format() == 'channels_first': train_images = train_data.reshape(train_data.shape[0], 3, img_rows, img_cols) test_images = test_data.reshape(test_data.shape[0], 3, img_rows, img_cols) input_shape = (3, img_rows, img_cols) else: train_images = train_data.reshape(train_data.shape[0], img_rows, img_cols, 3) test_images = test_data.reshape(test_data.shape[0], img_rows, img_cols, 3) input_shape = (img_rows, img_cols, 3) train_images = train_images.astype('float32') / 255 train_labels = to_categorical(train_labels, num_classes) test_images = test_images.astype('float32') / 255 test_labels = to_categorical(test_labels, num_classes) self.input_shape = input_shape self.num_classes = num_classes self.train_images, self.train_labels = train_images, train_labels self.test_images, self.test_labels = test_images, test_labels
def load_data(dataset=10, is_tune=False): if dataset == 10: (train_data, train_labels), (test_data, test_labels) = cifar10.load_data() if dataset == 100: (train_data, train_labels), (test_data, test_labels) = cifar100.load_data() if is_tune: test_data = train_data[:5000] test_labels = train_labels[:5000] train_data = train_data[5000:] train_labels = train_labels[5000:] # (N, 1) --> (N,) train_labels = np.squeeze(train_labels) test_labels = np.squeeze(test_labels) # per image standarizartion test_data = per_image_standardization(test_data) train_data = per_image_standardization(train_data) print('Load dataset: [CIFAR%d], is_tune: [%s], is_preprocessed: [%s]' % (dataset, is_tune, 'True')) print('Train_data: {}, Test_data: {}'.format(train_data.shape, test_data.shape)) return (train_data, train_labels), (test_data, test_labels)
def get_dataset(dataset, batch_size, supervised=False, noise_size=(128, )): from cifar10 import load_data (X, y), (X_test, y_test) = load_data() return LabeledArrayDataset(X=X, y=y if supervised else None, X_test=X_test, y_test=y_test, batch_size=batch_size, noise_size=noise_size)
def load_graph(): saver.restore(sess=session, save_path=save_path) print('weights loaded!') cucumber = cifar10.load_data() print('test accuracy %g' % accuracy.eval(session=session, feed_dict={ x: cucumber.test.images, y_: cucumber.test.labels, keep_prob: 1.0 }))
def get_dataset(dataset, batch_size, supervised=False, noise_size=(128, )): if dataset == 'mnist': from keras.datasets import mnist (X, y), (X_test, y_test) = mnist.load_data() X = X.reshape((X.shape[0], X.shape[1], X.shape[2], 1)) X_test = X_test.reshape( (X_test.shape[0], X_test.shape[1], X_test.shape[2], 1)) elif dataset == 'cifar10': from cifar10 import load_data (X, y), (X_test, y_test) = load_data() elif dataset == 'cifar100': from cifar100 import load_data (X, y), (X_test, y_test) = load_data() elif dataset == 'fashion-mnist': from fashion_mnist import load_data (X, y), (X_test, y_test) = load_data() X = X.reshape((X.shape[0], X.shape[1], X.shape[2], 1)) X_test = X_test.reshape( (X_test.shape[0], X_test.shape[1], X_test.shape[2], 1)) elif dataset == 'stl10': from stl10 import load_data (X, y), (X_test, y_test) = load_data() assert not supervised elif dataset == 'tiny-imagenet': from tiny_imagenet import load_data (X, y), (X_test, y_test) = load_data() elif dataset == 'imagenet': from imagenet import ImageNetdataset return ImageNetdataset('../imagenet-resized', '../imagenet-resized-val/val', batch_size=batch_size, noise_size=noise_size, conditional=supervised) return LabeledArrayDataset(X=X, y=y if supervised else None, X_test=X_test, y_test=y_test, batch_size=batch_size, noise_size=noise_size)
def main(src_model_name, eps): np.random.seed(0) tf.set_random_seed(0) config = tf.ConfigProto() config.gpu_options.allow_growth = True K.set_session(tf.Session(config=config)) if args.dataset == "mnist": K.set_image_data_format('channels_last') set_mnist_flags() x = K.placeholder( (None, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, FLAGS.NUM_CHANNELS)) y = K.placeholder((None, FLAGS.NUM_CLASSES)) _, _, X_test, Y_test = data_mnist() # source model for crafting adversarial examples src_model = load_model_mnist(src_model_name) elif args.dataset == "cifar10": set_flags(20) K.set_image_data_format('channels_first') x = K.placeholder( (None, FLAGS.NUM_CHANNELS, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS)) y = K.placeholder((None, FLAGS.NUM_CLASSES)) _, _, X_test, Y_test = load_data() # source model for crafting adversarial examples src_model = load_model(src_model_name) logits = src_model(x) for sd in [0.4, 0.5, 0.6]: one_hot = np.zeros(shape=(len(Y_test), 10)) for i in range(100): logits_np = batch_eval([x, y], [logits], [ X_test + np.random.normal(scale=sd, size=X_test.shape), Y_test ])[0] one_hot[np.arange(len(Y_test)), logits_np.argmax(axis=1)] += 1 robust = np.apply_along_axis(func1d=isRobust, axis=1, arr=one_hot, sd=sd, epsilon=eps) total_robust = np.sum( np.logical_and(robust[:, 0] == True, one_hot.argmax(axis=1) == Y_test.argmax(axis=1))) / 100. accuracy = np.sum(one_hot.argmax(axis=1) == Y_test.argmax( axis=1)) / 100. with open('bound_' + src_model_name + '_bound.txt', 'a') as log: log.write("Ave bound is {} at sigma = {}\n".format( np.mean(robust[:, 1]), sd)) log.write("Accuracy: {}, Robust accuracy: {}, l={}\n".format( accuracy, total_robust, eps))
def get_dataset(data_dir, preprocess_fcn=None): """ train dataset has shape [50000, 32, 32, 3], test dataset has shape [10000, 32, 32, 3]. """ (X_train, Y_train), (X_test, Y_test) = cifar.load_data(data_dir) if preprocess_fcn is not None: X_train, Y_train = preprocess_fcn(X_train, Y_train) X_test, Y_test = preprocess_fcn(X_test, Y_test) train = DataSet(X_train, Y_train) test = DataSet(X_test, Y_test) height, width, channels = X_train.shape[1], X_train.shape[ 2], X_train.shape[3] return Datasets(train, test, height, width, channels)
import numpy import os import keras from keras.preprocessing.image import ImageDataGenerator from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Conv2D, MaxPooling2D import cifar10 batch_size = 32 num_classes = 10 epochs = 50 data_augmentation = False (x_train, y_train), (x_test, y_test) = cifar10.load_data() y_train, y_test = [np_utils.to_categorical(x) for x in (y_train, y_test)] print('x_train shape:', x_train.shape) print('y_train shape:', y_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # load json and create model json_file = open("model.json", "r") loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model.hdf5") print("Loaded model from disk")
import os from cifar10 import load_data import PIL.Image as Image if __name__ == '__main__' : outDir = './CIFAR-10/' train, test, labels = load_data() labels = labels['label_names'] def writeData (outDir, dir, data, labels) : # setup the train directories subDir = os.path.join(outDir, dir) if not os.path.exists(subDir) : os.makedirs(subDir) # write the label directories counts = [0] * len(labels) for im, ii in zip(data[0], data[1]) : # create the directory labelDir = os.path.join(subDir, str(labels[ii])) if not os.path.exists(labelDir) : os.makedirs(labelDir) # write the image to the directory imPath = os.path.join(labelDir, str(counts[ii]) + '.tif') Image.merge('RGB', (Image.fromarray(im[0]), Image.fromarray(im[1]), Image.fromarray(im[2]))).save(imPath) counts[ii] += 1 # setup the train directories
from keras.optimizers import SGD fro keras.datasets import cifar10 from keras.utils import np_utils import argparse ap = argparse.ArgumentParser() ap.add_argument("-n", "--network", required = True, help = "name of the network to build") ap.add_argument("-m" "--model", required = True, help = "path to output model file") ap.add_argument("-d", "--dropout", type = int, default=-1, help="weather or not dropout should be used") ap.add_argument("-f", "--activation", type="str", default="tanh", help = "Activation function to use (LeNet only)") ap.add_argument("-e", "--epochs", type = int, default = 20, help = "# of epochs") ap.add_argument("-b", "--batch-size", type = int, default = 32, help="size of mini-batches passed to network") ap.add_argument("-v", "--verbose", type = int, default=1, help ="verbosity level") args = vars(ap.parse_args()) ((trainData, trainLabels), (testData, testLabels)) = cifar10.load_data() trainData = trainData.astype("float")/255.0 testData = testData.astype("float")/255.0 trainLabels = np_utils.to_categorical(trainLabels, 10) testLabels = np_utils.to_categorical(testLabels, 10) kargs = {"dropout": args["dropout"]>0, "activation":args["activation"]} #train the model using SGD print ("[INFO] compiling model...") model = ConvnetFactory.build(args["network"], 3, 32, 32, 10, **kargs) sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov= True) model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"]) # start the training process
def main(attack, src_model_name, target_model_names): np.random.seed(0) tf.set_random_seed(0) config = tf.ConfigProto() config.gpu_options.allow_growth = True K.set_session(tf.Session(config=config)) if args.dataset == "mnist": K.set_image_data_format('channels_last') set_mnist_flags() x = K.placeholder( (None, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS, FLAGS.NUM_CHANNELS)) y = K.placeholder((None, FLAGS.NUM_CLASSES)) _, _, X_test, Y_test = data_mnist() # source model for crafting adversarial examples src_model = load_model_mnist(src_model_name) sd = 0.7 elif args.dataset == "cifar10": set_flags(20) K.set_image_data_format('channels_first') x = K.placeholder( (None, FLAGS.NUM_CHANNELS, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS)) y = K.placeholder((None, FLAGS.NUM_CLASSES)) _, _, X_test, Y_test = load_data() # source model for crafting adversarial examples src_model = load_model(src_model_name) sd = 100. / 255. # model(s) to target target_models = [None] * len(target_model_names) for i in range(len(target_model_names)): target_models[i] = load_model(target_model_names[i]) # simply compute test error if attack == "test": acc = tf_test_acc(src_model, x, X_test, Y_test) print('{}: {:.1f}'.format(basename(src_model_name), acc)) for (name, target_model) in zip(target_model_names, target_models): acc = tf_test_acc(target_model, x, X_test, Y_test) print('{}: {:.1f}'.format(basename(name), acc)) return eps = args.eps # take the random step in the RAND+FGSM if attack == "rfgs": X_test = np.clip( X_test + args.alpha * np.sign(np.random.randn(*X_test.shape)), 0.0, 1.0) eps -= args.alpha logits = src_model(x) grad = gen_grad(x, logits, y) # FGSM and RAND+FGSM one-shot attack if attack in ["fgs", "rfgs"]: adv_x = symbolic_fgs(x, grad, eps=eps) # iterative FGSM if attack == "pgd": adv_x = iter_fgs(src_model, x, y, steps=args.steps, eps=eps, alpha=eps / 10.0) if attack == 'so': adv_x = so(src_model, x, y, steps=args.steps, eps=eps, alpha=eps / 10.0, norm=args.norm, sd=sd) print('start') # compute the adversarial examples and evaluate X_adv = batch_eval([x, y], [adv_x], [X_test, Y_test])[0] # pdb.set_trace() print('-----done----') # white-box attack acc = tf_test_acc(src_model, x, X_adv, Y_test, sd=sd, num_iter=10) with open('attacks.txt', 'a') as log: log.write('{}->{}: {:.1f}, size = {:.4f}\n'.format( basename(src_model_name), basename(src_model_name), acc, eps)) # black-box attack for (name, target_model) in zip(target_model_names, target_models): acc = tf_test_acc(target_model, x, X_adv, Y_test, sd=sd, num_iter=10) with open('attacks.txt', 'a') as log: log.write('{}->{}: {:.1f}, size = {:.4f}\n'.format( basename(src_model_name), basename(name), acc, eps))
def main(attack, src_model_name, target_model_names): np.random.seed(0) tf.set_random_seed(0) set_flags(20) config = tf.ConfigProto() config.gpu_options.allow_growth = True K.set_session(tf.Session(config=config)) x = K.placeholder( (None, FLAGS.NUM_CHANNELS, FLAGS.IMAGE_ROWS, FLAGS.IMAGE_COLS)) y = K.placeholder((None, FLAGS.NUM_CLASSES)) _, _, X_test, Y_test = load_data() # source model for crafting adversarial examples src_model = load_model(src_model_name) # model(s) to target target_models = [None] * len(target_model_names) for i in range(len(target_model_names)): target_models[i] = load_model(target_model_names[i]) # simply compute test error if attack == "test": err = tf_test_error_rate(src_model, x, X_test, Y_test) print('{}: {:.1f}'.format(basename(src_model_name), 100 - err)) for (name, target_model) in zip(target_model_names, target_models): err = tf_test_error_rate(target_model, x, X_test, Y_test) print('{}: {:.1f}'.format(basename(name), 100 - err)) return eps = args.eps # take the random step in the RAND+FGSM if attack == "rfgs": X_test = np.clip( X_test + args.alpha * np.sign(np.random.randn(*X_test.shape)), 0.0, 1.0) eps -= args.alpha logits = src_model(x) grad = gen_grad(x, logits, y) # FGSM and RAND+FGSM one-shot attack if attack in ["fgs", "rfgs"]: adv_x = symbolic_fgs(x, grad, eps=eps) # iterative FGSM if attack == "pgd": adv_x = iter_fgs(src_model, x, y, steps=args.steps, eps=args.eps, alpha=args.eps / 10.0) if attack == 'mim': adv_x = momentum_fgs(src_model, x, y, eps=args.eps) print('start') # compute the adversarial examples and evaluate X_adv = batch_eval([x, y], [adv_x], [X_test, Y_test])[0] print('-----done----') # white-box attack err = tf_test_error_rate(src_model, x, X_adv, Y_test) print('{}->{}: {:.1f}'.format(basename(src_model_name), basename(src_model_name), 100 - err)) # black-box attack for (name, target_model) in zip(target_model_names, target_models): err = tf_test_error_rate(target_model, x, X_adv, Y_test) print('{}->{}: {:.1f}'.format(basename(src_model_name), basename(name), 100 - err))
#!/usr/bin/env python import cv2 from cifar10 import load_data if __name__ == '__main__': (x_train, y_train), (x_test, y_test) = load_data() print(x_train.shape) ind = 0 image = cv2.cvtColor(x_train[ind], cv2.COLOR_BGR2RGB) labels = ('Airplane', 'Automobile', 'Bird', 'Cat', 'Deer', 'Dog', 'Frog', 'Horse', 'Ship', 'Truck') print(labels[y_train[ind][0]]) name = labels[y_train[ind][0]] cv2.imwrite('cifar_' + str(ind) + '_' + name + '.jpg', image) cv2.imshow('test', image) cv2.waitKey(0) cv2.destroyAllWindows()