def main(args):
print_train_params(args)
if not is_valid_task(args.task):
print(f'{args.task} is an invalid task')
return
for run_id in range(args.num_runs):
print(f'EXPERIMENT {run_id}')
lr = np.exp(np.random.uniform(np.log(1e-5), np.log(1.)))
wd = np.exp(np.random.uniform(np.log(1e-7), np.log(1.)))
m = np.random.uniform(0.01, 0.99)
if args.task in ['multitask', 'adversarial']:
train_multitask(args.data_path, args.exp_desc, args.batch_size,
args.hidden_dim, args.embedding_type, args.task,
args.event_type, args.optimizer, args.num_layers,
args.num_epochs, lr, wd, m, args.early_stop,
args.use_gpu, args.mute)
elif args.task in ['event_type', 'criticality']:
train_model(args.data_path, args.exp_desc, args.batch_size,
args.embedding_dim, args.hidden_dim,
args.embedding_type, args.task, args.event_type,
args.optimizer, args.num_layers, args.num_epochs, lr,
wd, m, args.early_stop, args.use_gpu, args.mute)
print(f'LR: {lr} WD: {wd} M: {m}')
print(
'-----------------------------------------------------------------'
)
def main():
args = parse_inputs()
# Get data loaders for training and build the model
loaders = get_data_loaders(args.data_dir)
train_set = loaders["train_set"]
train, valid, test = loaders["loaders"]
model = build_model(args.arch, None, args.hidden_units, None, None)
# Train and test model
train_model(model, train, valid, args.learn_rate, args.epochs, args.gpu)
test_model(model, test, args.gpu)
# Saving checkpoint
model_options = ["vgg11", "vgg13", "vgg19"]
checkpoint = {
"fc1_input": 25088,
"fc1_output": args.hidden_units,
"fc2_output": 102,
"dp_rate": 0.2,
"epochs": args.epochs,
"model_state": model.state_dict(),
"class_to_idx": train_set.class_to_idx
}
if args.arch in model_options:
checkpoint["arch"] = args.arch
filename = "checkpoint_{}.pth".format(args.arch)
else:
checkpoint["arch"] = "vgg11"
filename = "checkpoint_vgg11.pth"
torch.save(checkpoint, filename)
print("Model checkpoint saved!")
print("You can now use the predict.py script to classify flower images")
def train_tf_model(model_name, lr, train_X, train_Y, val_X, val_Y, checkpoint_dir,
logdir, epochs, seed):
'''Train a model from models.py on train_X and train_Y, and write the best version
to a file in checkpoint_dir
Arguments
---------
model_name: str
The name of the model to be imported from models.py
lr: float
The size of each update step made by the optimizer
train_X: numpy.array
The gene expression data to train the model on
train_Y: numpy.array
The labels corresponding to whether each sample represents healthy or unhealthy
gene expression
val_X: numpy.array
The gene expression data to be held out to evaluate model performance
val_Y: numpy.array
The labels corresponding to whether each sample in val_X represents healthy or
unhealthy gene expression
checkpoint_dir: str or Path
The base directory in which to store checkpoint files for the best performing models
logdir: str or Path or None
The directory to save tensorboard logs to
epochs: int
The number of times the model should see the entirety of train_X before it completes
training
seed: int
The current seed for the random number generator
Returns
-------
val_acc: float
The accuracy the model achieved in predicting val_Y from val_X
val_auroc: float
The area under the receiver operating characteristic curve based on the
model's decision function on val_X
'''
lr_string = '{:.0e}'.format(lr)
checkpoint_string = '{}_{}_{}'.format(model_name, lr_string, seed)
checkpoint_path = os.path.join(checkpoint_dir, checkpoint_string, 'checkpoint')
os.makedirs(os.path.join(checkpoint_dir, checkpoint_string), exist_ok=True)
classifier.train_model(train_X, train_Y, val_X, val_Y, checkpoint_path,
model_name=model_name, lr=lr,
epochs=int(epochs))
return checkpoint_path
def train_target_model(dataset, epochs=100, batch_size=100, learning_rate=0.01, l2_ratio=1e-7,
n_hidden=50, model='nn', save=True, DATA_PATH = './data/', MODEL_PATH = './model/'):
train_x, train_y, test_x, test_y = dataset
output_layer = train_model(dataset, n_hidden=n_hidden, epochs=epochs, learning_rate=learning_rate,
batch_size=batch_size, model=model, l2_ratio=l2_ratio)
# test data for attack model
attack_x, attack_y = [], []
input_var = T.matrix('x')
prob = lasagne.layers.get_output(output_layer, input_var, deterministic=True)
prob_fn = theano.function([input_var], prob)
# data used in training, label is 1
for batch in iterate_minibatches(train_x, train_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
attack_y.append(np.ones(batch_size))
# data not used in training, label is 0
for batch in iterate_minibatches(test_x, test_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
attack_y.append(np.zeros(batch_size))
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
if save:
np.savez(MODEL_PATH + 'attack_test_data.npz', attack_x, attack_y)
np.savez(MODEL_PATH + 'target_model.npz', *lasagne.layers.get_all_param_values(output_layer))
classes = np.concatenate([train_y, test_y])
return attack_x, attack_y, classes
def train_model_endpoint():
import sys
sys.path.insert(0, '../neuralNetwork')
from classifier import train_model
hist = train_model(output_mlmodel=True)
return jsonify(hist)
def train_shadow_models(n_hidden=50,
epochs=100,
n_shadow=20,
learning_rate=0.05,
batch_size=100,
l2_ratio=1e-7,
model='nn',
save=True):
attack_x, attack_y = [], []
classes = []
for i in range(n_shadow):
#print('Training shadow model {}'.format(i))
dataset = load_data('shadow{}_data.npz'.format(i), args)
train_x, train_y, test_x, test_y = dataset
# train model
classifier = train_model(dataset,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
l2_ratio=l2_ratio)
#print('Gather training data for attack model')
attack_i_x, attack_i_y = [], []
# data used in training, label is 1
pred_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
x={'x': train_x}, num_epochs=1, shuffle=False)
predictions = classifier.predict(input_fn=pred_input_fn)
_, pred_scores = get_predictions(predictions)
attack_i_x.append(pred_scores)
attack_i_y.append(np.ones(train_x.shape[0]))
# data not used in training, label is 0
pred_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
x={'x': test_x}, num_epochs=1, shuffle=False)
predictions = classifier.predict(input_fn=pred_input_fn)
_, pred_scores = get_predictions(predictions)
attack_i_x.append(pred_scores)
attack_i_y.append(np.zeros(test_x.shape[0]))
attack_x += attack_i_x
attack_y += attack_i_y
classes.append(np.concatenate([train_y, test_y]))
# train data for attack model
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
classes = np.concatenate(classes)
if save:
np.savez(MODEL_PATH + 'attack_train_data.npz', attack_x, attack_y)
return attack_x, attack_y, classes
def train_attack_model(classes, dataset=None, n_hidden=50, learning_rate=0.01, batch_size=200, epochs=50,
model='nn', l2_ratio=1e-7, DATA_PATH = './data/', MODEL_PATH = './model/'):
if dataset is None:
dataset = load_attack_data()
train_x, train_y, test_x, test_y = dataset
train_classes, test_classes = classes
train_indices = np.arange(len(train_x))
test_indices = np.arange(len(test_x))
unique_classes = np.unique(train_classes)
true_y = []
pred_y = []
for c in unique_classes:
print 'Training attack model for class {}...'.format(c)
c_train_indices = train_indices[train_classes == c]
c_train_x, c_train_y = train_x[c_train_indices], train_y[c_train_indices]
c_test_indices = test_indices[test_classes == c]
c_test_x, c_test_y = test_x[c_test_indices], test_y[c_test_indices]
c_dataset = (c_train_x, c_train_y, c_test_x, c_test_y)
c_pred_y = train_model(c_dataset, n_hidden=n_hidden, epochs=epochs, learning_rate=learning_rate,
batch_size=batch_size, model=model, rtn_layer=False, l2_ratio=l2_ratio)
true_y.append(c_test_y)
pred_y.append(c_pred_y)
print '-' * 10 + 'FINAL EVALUATION' + '-' * 10 + '\n'
true_y = np.concatenate(true_y)
pred_y = np.concatenate(pred_y)
print 'Attack Testing Accuracy: {}'.format(accuracy_score(true_y, pred_y))
print classification_report(true_y, pred_y)
def scenario5():
home = os.path.dirname(os.getcwd())
fopen = open(home + "\\Attributes\\train_dataset.dat", mode='rb')
train = pickle.load(fopen)
fopen.close()
import matplotlib.pyplot as plt
for i in range(9):
plt.subplot(3, 3, i + 1)
plt.axis('off')
plt.imshow(train[i][0], cmap='gray')
model = cl.CNN_model_2(3)
cl.train_model(train, model, 0, 5)
plt.show()
def train_attack_model(classes,
dataset=None,
n_hidden=50,
learning_rate=0.01,
batch_size=200,
epochs=50,
model='nn',
l2_ratio=1e-7):
if dataset is None:
dataset = load_attack_data()
train_x, train_y, test_x, test_y = dataset
train_classes, test_classes = classes
train_indices = np.arange(len(train_x))
test_indices = np.arange(len(test_x))
unique_classes = np.unique(train_classes)
true_y = []
pred_y = []
pred_scores = []
true_x = []
for c in unique_classes:
#print('Training attack model for class {}...'.format(c))
c_train_indices = train_indices[train_classes == c]
c_train_x, c_train_y = train_x[c_train_indices], train_y[
c_train_indices]
c_test_indices = test_indices[test_classes == c]
c_test_x, c_test_y = test_x[c_test_indices], test_y[c_test_indices]
c_dataset = (c_train_x, c_train_y, c_test_x, c_test_y)
classifier = train_model(c_dataset,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
l2_ratio=l2_ratio)
pred_input_fn = tf.estimator.inputs.numpy_input_fn(x={'x': c_test_x},
num_epochs=1,
shuffle=False)
predictions = classifier.predict(input_fn=pred_input_fn)
c_pred_y, c_pred_scores = get_predictions(predictions)
true_y.append(c_test_y)
pred_y.append(c_pred_y)
true_x.append(c_test_x)
pred_scores.append(c_pred_scores)
print('-' * 10 + 'FINAL EVALUATION' + '-' * 10 + '\n')
true_y = np.concatenate(true_y)
pred_y = np.concatenate(pred_y)
true_x = np.concatenate(true_x)
pred_scores = np.concatenate(pred_scores)
#print('Testing Accuracy: {}'.format(accuracy_score(true_y, pred_y)))
#print(classification_report(true_y, pred_y))
prety_print_result(true_y, pred_y)
fpr, tpr, thresholds = roc_curve(true_y, pred_y, pos_label=1)
attack_adv = tpr[1] - fpr[1]
return (attack_adv, pred_scores)
def train_attack_model(classes,
dataset=None,
n_hidden=50,
learning_rate=0.01,
batch_size=200,
epochs=50,
model='nn',
l2_ratio=1e-7):
if dataset is None:
dataset = load_attack_data()
train_x, train_y, test_x, test_y = dataset
train_classes, test_classes = classes
train_indices = np.arange(len(train_x))
test_indices = np.arange(len(test_x))
unique_classes = np.unique(train_classes)
print("TTTTT", train_indices)
print("UUUUU", test_indices)
print("VVVVV", unique_classes)
# f=open("./theano_train_y.txt", "w+")
# f.write(str(train_y)+ "\n")
print(train_y)
input()
true_y = []
pred_y = []
for c in unique_classes:
print('Training attack model for class {}...'.format(c))
c_train_indices = train_indices[train_classes == c]
c_train_x, c_train_y = train_x[c_train_indices], train_y[
c_train_indices]
c_test_indices = test_indices[test_classes == c]
c_test_x, c_test_y = test_x[c_test_indices], test_y[c_test_indices]
c_dataset = (c_train_x, c_train_y, c_test_x, c_test_y)
c_pred_y = train_model(c_dataset,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
rtn_layer=False,
l2_ratio=l2_ratio)
true_y.append(c_test_y)
pred_y.append(c_pred_y)
print('-' * 10 + 'FINAL EVALUATION' + '-' * 10 + '\n')
true_y = np.concatenate(true_y)
pred_y = np.concatenate(pred_y)
print('Testing Accuracy: {}'.format(accuracy_score(true_y, pred_y)))
print(classification_report(true_y, pred_y))
input()
def train_target_model(dataset, name,epochs=100, batch_size=100, learning_rate=0.01, l2_ratio=1e-7,
n_hidden=50, model='nn', save=True):
print("deeplearning.py -- train_target_model")
returnDouble=True
train_x, train_y, test_x, test_y = dataset
print("begin traning:")
output_layer = train_model(dataset, n_hidden=n_hidden, epochs=epochs, learning_rate=learning_rate,
batch_size=batch_size, model=model, l2_ratio=l2_ratio)
# test data for attack model
attack_x, attack_y = [], []
isCorrect = []
if model=='cnn' or model=='Droppcnn'or model=='Droppcnn2' :
input_var = T.tensor4('x')
elif model=='cnn2':
input_var = T.tensor4('x')
else:
input_var = T.matrix('x')
prob = lasagne.layers.get_output(output_layer, input_var, deterministic=True)
prob_fn = theano.function([input_var], prob)
# data used in training, label is 1
for batch in iterate_minibatches(train_x, train_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
predicted = np.argmax(prob_fn(batch[0]), axis=1)
isCorrect.append((batch[1] == predicted).astype('float32'))
attack_y.append(np.zeros(len(batch[0])))
# data not used in training, label is 0
for batch in iterate_minibatches(test_x, test_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
predicted = np.argmax(prob_fn(batch[0]), axis=1)
isCorrect.append((batch[1] == predicted).astype('float32'))
attack_y.append(np.ones(len(batch[0])))
#print len(attack_y)
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
isCorrect = np.concatenate(isCorrect)
#print('total length ' + str(sum(attack_y)))
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
if save:
np.savez(MODEL_PATH + 'attack_test_data'+str(name)+'.npz', attack_x)
np.savez(MODEL_PATH + 'attack_test_label'+str(name)+'.npz', attack_y)
np.savez(MODEL_PATH + 'target_model'+str(name)+'.npz', *lasagne.layers.get_all_param_values(output_layer))
classes = np.concatenate([train_y, test_y])
if(returnDouble):
return attack_x, attack_y, output_layer,prob_fn
else:
return attack_x, attack_y, output_layer
def train_attack_model(classes,
dataset=None,
n_hidden=50,
learning_rate=0.01,
batch_size=200,
epochs=50,
model='nn',
l2_ratio=1e-7):
if dataset is None:
dataset = load_attack_data()
train_x, train_y, test_x, test_y = dataset
train_classes, test_classes = classes
train_indices = np.arange(len(train_x))
test_indices = np.arange(len(test_x))
unique_classes = np.unique(train_classes)
true_y = []
pred_y = []
pred_scores = np.empty(len(test_y))
true_x = []
for c in unique_classes:
#print('Training attack model for class {}...'.format(c))
c_train_indices = train_indices[train_classes == c]
c_train_x, c_train_y = train_x[c_train_indices], train_y[
c_train_indices]
c_test_indices = test_indices[test_classes == c]
c_test_x, c_test_y = test_x[c_test_indices], test_y[c_test_indices]
c_dataset = (c_train_x, c_train_y, c_test_x, c_test_y)
_, c_pred_y, c_pred_scores, _, _, _ = train_model(
c_dataset,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
l2_ratio=l2_ratio,
non_linearity='relu')
true_y.append(c_test_y)
pred_y.append(c_pred_y)
true_x.append(c_test_x)
# place c_pred_scores where it belongs in pred_scores (train, then test)
pred_scores[c_test_indices] = c_pred_scores[:, 1]
print('-' * 10 + 'FINAL EVALUATION' + '-' * 10 + '\n')
true_y = np.concatenate(true_y)
pred_y = np.concatenate(pred_y)
true_x = np.concatenate(true_x)
#print('Testing Accuracy: {}'.format(accuracy_score(true_y, pred_y)))
#print(classification_report(true_y, pred_y))
fpr, tpr, thresholds = roc_curve(true_y, pred_y, pos_label=1)
print(fpr, tpr, tpr - fpr)
attack_adv = tpr[1] - fpr[1]
return attack_adv, pred_scores
def train_shadow_models(n_hidden=50,
epochs=100,
n_shadow=20,
learning_rate=0.05,
batch_size=100,
l2_ratio=1e-7,
model='nn',
save=True):
# for getting probabilities
input_var = T.matrix('x')
# for attack model
attack_x, attack_y = [], []
classes = []
for i in range(n_shadow):
print('Training shadow model {}'.format(i))
data = load_data('shadow{}_data.npz'.format(i))
train_x, train_y, test_x, test_y = data
# train model
output_layer = train_model(data,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
l2_ratio=l2_ratio)
prob = lasagne.layers.get_output(output_layer,
input_var,
deterministic=True)
prob_fn = theano.function([input_var], prob)
print('Gather training data for attack model')
attack_i_x, attack_i_y = [], []
# data used in training, label is 1
for batch in iterate_minibatches(train_x, train_y, batch_size, False):
attack_i_x.append(prob_fn(batch[0]))
attack_i_y.append(np.ones(batch_size))
# data not used in training, label is 0
for batch in iterate_minibatches(test_x, test_y, batch_size, False):
attack_i_x.append(prob_fn(batch[0]))
attack_i_y.append(np.zeros(batch_size))
attack_x += attack_i_x
attack_y += attack_i_y
classes.append(np.concatenate([train_y, test_y]))
# print("22222", len(np.unique(train_y)), len(np.unique(test_y)))
# input()
# train data for attack model
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
classes = np.concatenate(classes)
if save:
np.savez(MODEL_PATH + 'attack_train_data.npz', attack_x, attack_y)
return attack_x, attack_y, classes
def trainAttackSoftmax(X_train, y_train, X_test, y_test):
dataset = (X_train.astype(np.float32), y_train.astype(np.int32),
X_test.astype(np.float32), y_test.astype(np.int32))
output = classifier.train_model(dataset=dataset,
epochs=50,
batch_size=10,
learning_rate=0.01,
n_hidden=64,
l2_ratio=1e-6,
model='softmax')
return output
def main(args):
print_train_params(args)
if not is_valid_task(args.task):
print(f'{args.task} is an invalid task')
return
if args.task in ['multitask', 'adversarial']:
train_multitask(args.data_path, args.exp_desc, args.batch_size,
args.hidden_dim, args.embedding_type, args.task,
args.event_type, args.optimizer, args.num_layers,
args.num_epochs, args.lr, args.wd, args.momentum,
args.dropout, args.early_stop, args.use_gpu, args.mute,
args.output_path)
elif args.task in ['event_type', 'criticality']:
train_model(args.data_path, args.exp_desc, args.batch_size,
args.embedding_dim, args.hidden_dim, args.embedding_type,
args.task, args.event_type, args.optimizer,
args.num_layers, args.num_epochs, args.lr, args.wd,
args.momentum, args.dropout, args.early_stop, args.use_gpu,
args.mute, args.output_path)
else:
print('Unknown task.')
def train_target_model(args, dataset=None, epochs=100, batch_size=100, learning_rate=0.01, clipping_threshold=1, l2_ratio=1e-7, n_hidden=50, model='nn', privacy='no_privacy', dp='dp', epsilon=0.5, delta=1e-5, save=True):
if dataset == None:
dataset = load_data('target_data.npz', args)
train_x, train_y, test_x, test_y = dataset
classifier, aux = train_model(dataset, n_hidden=n_hidden, epochs=epochs, learning_rate=learning_rate, clipping_threshold=clipping_threshold, batch_size=batch_size, model=model, l2_ratio=l2_ratio, silent=False, privacy=privacy, dp=dp, epsilon=epsilon, delta=delta)
# test data for attack model
attack_x, attack_y = [], []
# data used in training, label is 1
pred_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
x={'x': train_x},
num_epochs=1,
shuffle=False)
predictions = classifier.predict(input_fn=pred_input_fn)
_, pred_scores = get_predictions(predictions)
attack_x.append(pred_scores)
attack_y.append(np.ones(train_x.shape[0]))
# data not used in training, label is 0
pred_input_fn = tf.compat.v1.estimator.inputs.numpy_input_fn(
x={'x': test_x},
num_epochs=1,
shuffle=False)
predictions = classifier.predict(input_fn=pred_input_fn)
_, pred_scores = get_predictions(predictions)
attack_x.append(pred_scores)
attack_y.append(np.zeros(test_x.shape[0]))
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
if save:
np.savez(MODEL_PATH + 'attack_test_data.npz', attack_x, attack_y)
classes = np.concatenate([train_y, test_y])
return attack_x, attack_y, classes, classifier, aux
def train_target_model(dataset,epochs=100, batch_size=100, learning_rate=0.01, l2_ratio=1e-7,
n_hidden=50, model='nn'):
train_x, train_y, test_x, test_y = dataset
output_layer = train_model(dataset, n_hidden=n_hidden, epochs=epochs, learning_rate=learning_rate,
batch_size=batch_size, model=model, l2_ratio=l2_ratio)
# test data for attack model
attack_x, attack_y = [], []
if model=='cnn':
#Dimension for CIFAR-10
input_var = T.tensor4('x')
else:
#Dimension for News
input_var = T.matrix('x')
prob = lasagne.layers.get_output(output_layer, input_var, deterministic=True)
prob_fn = theano.function([input_var], prob)
# data used in training, label is 1
for batch in iterate_minibatches(train_x, train_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
attack_y.append(np.ones(len(batch[0])))
# data not used in training, label is 0
for batch in iterate_minibatches(test_x, test_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
attack_y.append(np.zeros(len(batch[0])))
#print len(attack_y)
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
#print('total length ' + str(sum(attack_y)))
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
return attack_x, attack_y, output_layer
app = Flask(__name__)
app.config.from_object(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['DATASET_FOLDER'] = DATASET_FOLDER
db_keys = []
global text_clf
app.config.update(
dict(
SECRET_KEY='development key',
USERNAME='******',
PASSWORD='******',
))
text_clf = classifier.train_model(app.config['DATASET_FOLDER'])
#Index page
@app.route('/index')
def index():
return render_template('index.html')
#Link page
@app.route('/link')
def link():
return render_template('link.html')
def allowed_file(filename):
def train_shadow_models(n_hidden=50,
epochs=100,
n_shadow=20,
learning_rate=0.05,
batch_size=100,
l2_ratio=1e-7,
model='nn',
save=True):
print '-' * 10 + 'TRAIN SHADOW' + '-' * 10 + '\n'
if model == 'cnn':
input_var = T.tensor4('x')
else:
input_var = T.matrix('x')
attack_x, attack_y = [], []
classes = []
for i in xrange(n_shadow):
print 'Training shadow model {}'.format(i)
data = load_data('shadow{}_data.npz'.format(i))
train_x, train_y, test_x, test_y = data
# train model
output_layer = train_model(data,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
l2_ratio=l2_ratio)
if model == 'cnn':
train_x = np.dstack(
(train_x[:, :1024], train_x[:, 1024:2048], train_x[:, 2048:]))
train_x = train_x.reshape((-1, 32, 32, 3)).transpose(0, 3, 1, 2)
test_x = np.dstack(
(test_x[:, :1024], test_x[:, 1024:2048], test_x[:, 2048:]))
test_x = test_x.reshape((-1, 32, 32, 3)).transpose(0, 3, 1, 2)
prob = lasagne.layers.get_output(output_layer,
input_var,
deterministic=True)
prob_fn = theano.function([input_var], prob)
if save:
np.savez(MODEL_PATH + 'shadow' + str(i) + '_model.npz',
*lasagne.layers.get_all_param_values(output_layer))
print 'Gather training data for attack model'
attack_i_x, attack_i_y = [], []
# data used in training, label is 1
for batch in iterate_minibatches(train_x, train_y, batch_size, False):
attack_i_x.append(prob_fn(batch[0]))
attack_i_y.append(np.ones(batch_size))
# data not used in training, label is 0
for batch in iterate_minibatches(test_x, test_y, batch_size, False):
attack_i_x.append(prob_fn(batch[0]))
attack_i_y.append(np.zeros(batch_size))
attack_x += attack_i_x
attack_y += attack_i_y
classes.append(np.concatenate([train_y, test_y]))
# train data for attack model
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
classes = np.concatenate(classes)
if save:
np.savez(MODEL_PATH + 'attack_train_data.npz', attack_x, attack_y)
np.savez(MODEL_PATH + 'attack_train_class.npz', classes)
return attack_x, attack_y, classes
def train_target_model(epochs=100,
batch_size=100,
learning_rate=0.01,
l2_ratio=1e-7,
n_hidden=50,
model='nn',
save=True,
ratio=0):
print '-' * 10 + 'TRAIN TARGET' + '-' * 10 + '\n'
dataset = load_data('target_data.npz')
train_x, train_y, test_x, test_y = dataset
num_sample = train_x.shape[0]
if ratio > 0:
index = random.sample(range(num_sample), int(ratio * num_sample))
index.sort()
mask = np.random.choice([0, 1],
size=train_x.shape[-1:],
p=[2. / 3, 1. / 3])
for i in index:
train_x[i] = np.clip(
train_x[i] + np.multiply(
mask, np.random.normal(scale=0.3,
size=train_x.shape[-1:])), 0, 1)
output_layer = train_model(dataset,
n_hidden=n_hidden,
epochs=epochs,
learning_rate=learning_rate,
batch_size=batch_size,
model=model,
l2_ratio=l2_ratio)
attack_x, attack_y = [], []
dataset = load_data('target_data.npz')
train_x, train_y, test_x, test_y = dataset
if model == 'cnn':
train_x = np.dstack(
(train_x[:, :1024], train_x[:, 1024:2048], train_x[:, 2048:]))
train_x = train_x.reshape((-1, 32, 32, 3)).transpose(0, 3, 1, 2)
test_x = np.dstack(
(test_x[:, :1024], test_x[:, 1024:2048], test_x[:, 2048:]))
test_x = test_x.reshape((-1, 32, 32, 3)).transpose(0, 3, 1, 2)
input_var = T.tensor4('x')
else:
input_var = T.matrix('x')
prob = lasagne.layers.get_output(output_layer,
input_var,
deterministic=True)
prob_fn = theano.function([input_var], prob)
for batch in iterate_minibatches(train_x, train_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
attack_y.append(np.ones(batch_size))
for batch in iterate_minibatches(test_x, test_y, batch_size, False):
attack_x.append(prob_fn(batch[0]))
attack_y.append(np.zeros(batch_size))
attack_x = np.vstack(attack_x)
attack_y = np.concatenate(attack_y)
attack_x = attack_x.astype('float32')
attack_y = attack_y.astype('int32')
classes = np.concatenate([train_y, test_y])
if save:
np.savez(MODEL_PATH + 'attack_test_data.npz', attack_x, attack_y)
np.savez(MODEL_PATH + 'target_model.npz',
*lasagne.layers.get_all_param_values(output_layer))
np.savez(MODEL_PATH + 'attack_test_class.npz', classes)
return attack_x, attack_y, classes
novice_dataset = JigsawsDataset(['NoviceSamplesG6.csv'],ratio = 10)
#novice_dataloader = DataLoader(novice_dataset, batch_size=10, shuffle=True, num_workers=0)
expert_dataset = JigsawsDataset(['ExpertSamplesG6.csv'], ratio = 10)
#expert_dataloader = DataLoader(expert_dataset, batch_size=10, shuffle=True, num_workers=0)
# train or load classifier network
if not classifier_pretrained:
train_epochs = 120
all_accs = list()
end_accs = list()
for i in trange(5): # random cross validation
train_dataset, test_dataset = random_split(combined_dataset, [int(combined_dataset.__len__()*0.7), int(combined_dataset.__len__())-int(combined_dataset.__len__()*0.7)], generator=torch.Generator().manual_seed(i+10))
train_dataloader = DataLoader(train_dataset, batch_size=train_dataset.__len__(), shuffle=False, num_workers=0)
test_dataloader = DataLoader(test_dataset, batch_size=test_dataset.__len__(), shuffle=False, num_workers=0)
model = classifier.LSTMClassifier(train_dataset[:]['X'].size(2), hidden_dim=30) #input dim, hidden dim
model, train_accs, test_accs = classifier.train_model(model, train_dataloader, test_dataloader, train_dataset, test_dataset, train_epochs) # model, train loader, test loader, train set, test set, epochs
acc = classifier.model_accuracy(model, test_dataset[:]['X'], test_dataset[:]['y'], True)
end_accs.append(acc.item())
all_accs.append([train_accs, test_accs])
classifier.plot(end_accs, all_accs)
# save trained model
PATH = __location__ + '/Classifier.pth'
torch.save(model.state_dict(), PATH)
PATH = __location__ + '/acc.png'
plt.savefig(PATH, dpi=250)
else:
PATH = __location__ + '/Classifier.pth'
model = classifier.LSTMClassifier(combined_dataset[:]['X'].size(2), 30) # input dim, hidden dim
model.load_state_dict(torch.load(PATH))
model.eval()
