def generate_bandit_dataset(fp, model=None, source_number=1): """generate bandit dataset with a trained model Args: fp(pathlib.PosixPath): path to read/save the dataset model(tf.keras.Model): model of the logging policy, loading a model in `.h5` file is preferred source_number(int): 1 for counting mnist, 2 for sequential mnist Returns: The bandit dataset is saved in the given path """ if source_number == 1: x, y = load_counting_data(fp) elif source_number == 2: x, y = load_mnist_data() else: raise ValueError('Source data is not found') predictions = model.predict(x) actions = np.argmax(predictions, axis=1) scores = predictions[np.arange(predictions.shape[0]), actions] # if the chosen action is the same as the ground-truth label, the loss is 0; # otherwise, the loss is 1, the goal is to minimize the loss delta = (actions != np.argmax(y, axis=1)).astype('int') print(f'Accuracy of observed actions is {1 - delta.sum() / delta.size}') data_list = [x, y, actions, scores, delta] with gzip.open(fp / f"Bandit_{source_number}.pickle", "wb") as f: pickle.dump(data_list, f, protocol=-1)
def caller (): x_train, y_train, x_test, y_test, num_classes, input_shape = utils.load_mnist_data() model = define_deep_nn_model([64, 128, 256], num_classes, input_shape) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(x_test, y_test)) ## predict on test set scores = model.evaluate(x_test, y_test, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
def __init__(self, input = None, nvisible = None, nhidden = 100, lrate = 1e-2, W = None, vbias = None, hbias = None, seed = 123): if (input is None): try: input = load_mnist_data()[0] except: print('Not able to load mnist data') if (nvisible is None): try: nvisible = input[0].shape[0] except: print('Not able to get number of visible units') ''' If not set, the weights are initialized according to http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf where the weights are sampled from a symmetric uniform interval ''' if(W is None): t = 4.0 * np.sqrt(6.0/float(nvisible + nhidden)) W = np.random.uniform(-t, t, (nvisible, nhidden)).astype('float32') if(vbias is None): vbias = np.zeros(nvisible, dtype = 'float32') if(hbias is None): hbias = np.zeros(nhidden, dtype = 'float32') self.nsample = input.shape[0] self.imsize = int(np.sqrt(input.shape[1])) self.seed = seed #np.random.seed(seed) self.input = input.astype('float32') self.nvisible = nvisible self.nhidden = nhidden self.lrate = lrate self.W = W self.vbias = vbias self.hbias = hbias self.bit_index = 0
def train_logging_policy(mpath, source_number=1): if source_number == 1: x, y = load_counting_data(fp=Path('./data'), fn='Dataset_10k.pickle') elif source_number == 2: x, y = load_mnist_data() else: raise ValueError('Source data is not found') X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0) data = X_train, y_train, X_test, y_test it = InvokeTimes() temp_fp = mpath / 'logging' temp_fp.mkdir(parents=True, exist_ok=True) func = partial(hyperopt_logging_policy, data=data, counter=it, fp=temp_fp) config = { 'repr_size': 16 * scope.int(hp.quniform('repr_size', 1, 8, 1)), 'activation': hp.choice('activation', ['sigmoid', 'relu', 'tanh']), # 'inp_drop': scope.roundup(hp.uniform('inp_drop', 0.1, 0.9)), # 're_drop': scope.roundup(hp.uniform('re_drop', 0.1, 0.9)), 'l2_coef': np.power(10, scope.int(hp.quniform('l2_coef', -10, -1, 1))), 'lr': np.power(10, scope.int(hp.quniform('lr', -10, -1, 1))), } trials = Trials() fmin(fn=func, space=config, algo=rand.suggest, max_evals=20, trials=trials, rstate=np.random.RandomState(0), return_argmin=False, show_progressbar=True) df = pd.DataFrame(trials.results) df.to_csv(mpath / 'trials.csv')
G = generator(Z) D_real = discriminator(X) D_fake = discriminator(G, reuse=True) return G, D_real, D_fake # Define constants NUM_EPOCHS = 100 BATCH_SIZE = 128 LEARNING_RATE = 0.0002 BETA1 = 0.5 NOISE_DIM = 100 SAMPLE_SIZE = 100 # Load mnist data X_train = utils.load_mnist_data() utils.plot_sample(X_train[:SAMPLE_SIZE], "output/mnist_data.png") X_train = utils.preprocess_images(X_train) mini_batches = utils.random_mini_batches(X_train, BATCH_SIZE) # Create DCGAN X = tf.placeholder(tf.float32, shape=(None, X_train.shape[1], X_train.shape[2], X_train.shape[3])) Z = tf.placeholder(tf.float32, [None, NOISE_DIM]) G, D_real, D_fake = create_gan(X, Z) # Create training steps G_loss_func, D_loss_func = utils.create_loss_funcs(D_real, D_fake) G_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="Generator") D_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="Discriminator") G_train_step = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE, beta1=BETA1).minimize(G_loss_func, var_list=G_vars) D_train_step = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE, beta1=BETA1).minimize(D_loss_func, var_list=D_vars)
from rbm import RBM from utils import load_mnist_data import numpy as np import PIL.Image as Image if __name__ == '__main__': data = load_mnist_data() train_x, train_y, valid_x, valid_y, test_x, test_y = data print(train_x.shape) print(valid_x.shape) print(test_x.shape) M = RBM() #M.contrastive_divergence(validation = valid_x) #m = np.asarray([[1, 2, 3, 4], [2, 3, 4, 5], [2, 3, 1, 1]])
parser.add_argument("--savefile", help="filename to save params", type=str) parser.add_argument("--resumefile", help="filename to resume params from", type=str) # parser.add_argument("--data", help="bw, grey, or mnist", type = str, default = 'mnist') parser.add_argument("--method", help="pyswarm or spsa", type=str, default='spsa') parser.add_argument("--model", help="balanced or cascade", type=str, default='balanced') args = parser.parse_args() classes = (0, 1) train_data, train_labels, test_data, test_labels = utils.load_mnist_data( 'data/4', classes, val_split=0.1) print(len(train_data), len(test_data)) #TODO: make hyperparameters also arguments to train() params = None n = 16 #len(train_data[0]) n_trials = 1 mod = model.Model(n=n, num_trials=n_trials, classes=classes) if args.model == 'cascade': mod = model2.Model(n=n, num_trials=n_trials, classes=classes) # print(np.linalg.norm(train_data[0]), train_data[0], "hello") init_params = None init_params = np.random.normal(loc=0.0, scale=1.0, size=mod.count) if args.resumefile: init_params = utils.load_params(args.resumefile)
def attack_bayes(): """ Perform BayesOpt attack """ # get dataset and list of indices of images to attack if args.dset == 'mnist': test_dataset = load_mnist_data() samples = np.arange(args.start, args.start + args.num_attacks) elif args.dset == 'cifar10': test_dataset = load_cifar10_data() samples = np.arange(args.start, args.start + args.num_attacks) elif args.dset == 'imagenet': if args.arch == 'inception_v3': test_dataset = load_imagenet_data(299, 299) else: test_dataset = load_imagenet_data() # see readme samples = np.load('random_indices_imagenet.npy') samples = samples[args.start:args.start + args.num_attacks] print("Length of sample_set: ", len(samples)) results_dict = {} # loop over images, attacking each one if it is initially correctly classified for idx in samples[:args.num_attacks]: image, label = test_dataset[idx] image = image.unsqueeze(0).to(device) print(f"Image {idx:d} Original label: {label:d}") predicted_label = torch.argmax(cnn_model.predict_scores(image)) print("Predicted label: ", predicted_label.item()) # ignore incorrectly classified images if label == predicted_label: # itr, success = bayes_opt(image, label) retry = 0 while retry < 5: try: itr, success = bayes_opt(image, label) break except: print('Retry_{}'.format(retry)) retry += 1 print(itr, success) if success: results_dict[idx] = itr else: results_dict[idx] = 0 sys.stdout.flush() # results saved as dictionary, with entries of the form # dataset idx : 0 if unsuccessfully attacked, # of queries if successfully attacked print('RESULTS', results_dict) if args.save: pickle.dump( results_dict, open( f"{args.dset:s}{args.arch:s}_{args.start:d}_{args.iter:d}_{args.dim:d}_{args.eps:.2f}_{args.num_attacks:d}.pkl", 'wb'))
tf.nn.sigmoid_cross_entropy_with_logits(dist_ff1, targets_distinguisher)) optimizer_dist = tf.train.AdamOptimizer(0.0002) train_dist = optimizer_dist.minimize( cross_entropy_distinguisher, var_list=[v for v in tf.trainable_variables() if 'dist' in v.name]) cross_entropy_generator = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( tf.slice(dist_ff1, [32, 0], [-1, -1]), targets_generator)) optimizer_gen = tf.train.AdamOptimizer(0.0002) train_gen = optimizer_gen.minimize( cross_entropy_generator, var_list=[v for v in tf.trainable_variables() if 'gen' in v.name]) data_train, labels_train, _, _, _, _ = load_mnist_data( ) # the data is 55k samples widgets = [ 'Training: ', Percentage(), ' ', AnimatedMarker(markers='←↖↑↗→↘↓↙'), ' ', ETA() ] pbar = ProgressBar(widgets=widgets, maxval=n_epochs * data_train.shape[0] // 32).start() i = 0 with tf.Session() as sess: sess.run(tf.initialize_all_variables()) for epoch in range(n_epochs): batches = minibatches(data_train, labels_train, batch_size=32) for data, _ in batches:
if dist[label] > 0.5: num_correct += 1 print("test accuracy = ", "{0:.2f}%".format(num_correct / len(test_data) * 100)) print("number of circuit runs = ", mod.num_runs) if __name__ == '__main__': parser = argparse.ArgumentParser( description='Test accuracy for provided params') parser.add_argument("--file", help="filename of params", type=str) parser.add_argument("--class1", help="class of data", type=int) parser.add_argument("--class2", help="class of data", type=int) parser.add_argument("--num", help="Number of samples", type=int) args = parser.parse_args() filename = args.file print(filename) train_data, train_labels, test_data, test_labels = utils.load_mnist_data( 'data/4', (args.class1, args.class2)) params = np.loadtxt(open("params/" + filename, "rb"), delimiter=",") if args.num == None: args.num = len(test_data) n = 16 n_trials = 1 mod = model.Model(n=n, num_trials=n_trials, classes=[args.class1, args.class2]) get_accuracy(test_data[:args.num], test_labels[:args.num], mod, params)
from random import shuffle import numpy as np import utils import nn HIDDEN_NEURONS = 100 def validation_test(output, label): return np.argmax(output) == np.argmax(label) train_x, train_y, valid_x, valid_y, test_x, test_y = utils.load_mnist_data() train_data = [(feature.reshape((784, 1)), utils.vectorize_y(label)) for feature, label in zip(train_x, train_y)] valid_data = [(feature.reshape((784, 1)), utils.vectorize_y(label)) for feature, label in zip(valid_x, valid_y)] test_data = [(feature.reshape(784, 1), utils.vectorize_y(label)) for feature, label in zip(test_x, test_y)] net = nn.Network([28 * 28, HIDDEN_NEURONS, 10]) net.train(train_data, 50, 0.3, 1.0, momentum=0.5, mini_batch_size=32, cost=nn.CrossEntropyCost, validation_data=valid_data, validation_test=validation_test) test_correct = net.evaluate(test_data, validation_test) print("----------------------------------------") print( "Test accuracy: " + str(test_correct) + "/" + str(len(test_data)) + ";" + str(test_correct / len(test_data) * 100))
if __name__ == "__main__": # Choose from 'mnist', 'portraits' dataset = sys.argv[1] # Choose from '0', '1', '2' config = sys.argv[2] if dataset=='mnist': # For Rotated MNIST dataset # config = 0: 60-degree duration 500, 30-degree duration 250, 0-degree duration 125 # config = 1: 60-degree duration 125, 30-degree duration 250, 0-degree duration 500 # config = 2: 60-degree duration 250, 30-degree duration 250, 60-degree duration 125, 0-degree duration 125, 60-degree duration 125 if config=='1': t_u = [125, 250, 500] else: t_u = [500, 250, 125] X, Y = load_mnist_data('mnist_file', t_u) if config=='2': X1 = [X[250:-125], X[:125], X[-125:], X[125:250]] Y1 = [Y[250:-125], Y[:125], Y[-125:], Y[125:250]] X = torch.cat(X1, dim=0) Y = torch.cat(Y1, dim=0) alpha_list = [0.1, 0.2, 0.4, 0.6, 0.8, 1.2, 1.5, 2, 3] else: # For Portraits dataset # config = 0: durations 512, 256, 128, 64, 32 # config = 1: durations 32, 64, 128, 256, 512 # config = 2: durations 200, 200, 200, 200, 200 if config=='0': t_u = [512, 256, 128, 64, 32] elif config=='1': t_u = [32, 64, 128, 256, 512]
image_data_raw[:, (img_dim + 1) * ii:(img_dim + 1) * ii + img_dim] = tile_raster_images(X=samples, img_shape=(img_dim, img_dim), tile_shape=(n_samples, 1), tile_spacing=(1, 1)) image = Image.fromarray(image_data) image.save(os.path.join(output_dir, 'samples.png')) if plotRawAlso: image = Image.fromarray(image_data) image.save(os.path.join(output_dir, 'samplesRaw.png')) saveToFile(os.path.join(output_dir, 'rbm.pkl.gz'), rbm) return rbm, meanCosts if __name__ == '__main__': resman.start('junk', diary=True) datasets = load_mnist_data('../data/mnist.pkl.gz', shared=False) print 'done loading.' test_rbm(datasets=datasets, training_epochs=45, n_hidden=500, learning_rate=.002, output_dir=resman.rundir, quickHack=False) resman.stop()
# Visualization Code based on #https://github.com/ageron/handson-ml2/blob/master/03_classification.ipynb import numpy as np import matplotlib as mpl import matplotlib.pyplot as plt from utils import save_fig, load_mnist_data mpl.rc('axes', labelsize=14) mpl.rc('xtick', labelsize=12) mpl.rc('ytick', labelsize=12) X_train, X_test, y_train, y_test = load_mnist_data() def plot_digit(data): image = data.reshape(28, 28) plt.imshow(image, cmap=mpl.cm.binary, interpolation="nearest") plt.axis("off") def plot_digits(instances, images_per_row=10, **options): size = 28 images_per_row = min(len(instances), images_per_row) images = [instance.reshape(size, size) for instance in instances] n_rows = (len(instances) - 1) // images_per_row + 1 row_images = [] n_empty = n_rows * images_per_row - len(instances) images.append(np.zeros((size, size * n_empty))) for row in range(n_rows):
if plotRawAlso: image_data_raw[:,(img_dim+1)*ii:(img_dim+1)*ii+img_dim] = tile_raster_images( X = samples, img_shape = (img_dim,img_dim), tile_shape = (n_samples, 1), tile_spacing = (1,1)) image = Image.fromarray(image_data) image.save(os.path.join(output_dir, 'samples.png')) if plotRawAlso: image = Image.fromarray(image_data) image.save(os.path.join(output_dir, 'samplesRaw.png')) saveToFile(os.path.join(output_dir, 'rbm.pkl.gz'), rbm) return rbm, meanCosts if __name__ == '__main__': resman.start('junk', diary = True) datasets = load_mnist_data('../data/mnist.pkl.gz', shared = False) print 'done loading.' test_rbm(datasets = datasets, training_epochs = 45, n_hidden = 500, learning_rate = .002, output_dir = resman.rundir, quickHack = False) resman.stop()