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()
