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