def test_network(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data(FLAGS.start_batch, FLAGS.batch_size) data = x_test.flatten("C") client = pyhe_client.HESealClient( FLAGS.hostname, FLAGS.port, FLAGS.batch_size, {FLAGS.tensor_name: (FLAGS.encrypt_data_str, data)}, ) results = np.round(client.get_results(), 2) y_pred_reshape = np.array(results).reshape(FLAGS.batch_size, 10) with np.printoptions(precision=3, suppress=True): print(y_pred_reshape) y_pred = y_pred_reshape.argmax(axis=1) print("y_pred", y_pred) correct = np.sum(np.equal(y_pred, y_test.argmax(axis=1))) acc = correct / float(FLAGS.batch_size) print("correct", correct) print("Accuracy (batch size", FLAGS.batch_size, ") =", acc * 100.0, "%")
def test_cryptonets_relu(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x = tf.compat.v1.placeholder(tf.float32, [None, 28, 28, 1], name='input') y_ = tf.compat.v1.placeholder(tf.float32, [None, 10]) # Create the model y_conv = cryptonets_relu_test_squashed(x) config = server_config_from_flags(FLAGS, x.name) print('config', config) with tf.compat.v1.Session(config=config) as sess: x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] start_time = time.time() y_conv_val = y_conv.eval(feed_dict={x: x_test, y_: y_test}) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) if not FLAGS.enable_client: y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) y_pred = np.argmax(y_conv_val, 1) correct_prediction = np.equal(y_pred, y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Error count', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: %g ' % test_accuracy)
def test_mnist_cnn(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x_test_batch = x_test[:FLAGS.batch_size] y_test_batch = y_test[:FLAGS.batch_size] data = x_test_batch.flatten('C') print('Client batch size from FLAG:', FLAGS.batch_size) port = 34000 encrypt_str = 'encrypt' if FLAGS.encrypt_data else 'plain' client = pyhe_client.HESealClient(FLAGS.hostname, port, FLAGS.batch_size, {'input': (encrypt_str, data)}) results = client.get_results() results = np.round(results, 2) y_pred_reshape = np.array(results).reshape(FLAGS.batch_size, 10) with np.printoptions(precision=3, suppress=True): print(y_pred_reshape) y_pred = y_pred_reshape.argmax(axis=1) print('y_pred', y_pred) y_true = y_test_batch.argmax(axis=1) correct = np.sum(np.equal(y_pred, y_true)) acc = correct / float(FLAGS.batch_size) print('pred size', len(y_pred)) print('correct', correct) print('Accuracy (batch size', FLAGS.batch_size, ') =', acc * 100., '%')
def test_cryptonets_relu(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x = tf.compat.v1.placeholder(tf.float32, [None, 28, 28, 1]) y_ = tf.compat.v1.placeholder(tf.float32, [None, 10]) # Create the model y_conv = cryptonets_relu_test_squashed(x) with tf.compat.v1.Session() as sess: x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] start_time = time.time() y_conv_val = y_conv.eval(feed_dict={x: x_test, y_: y_test}) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) using_client = (os.environ.get('NGRAPH_ENABLE_CLIENT') is not None) if not using_client: y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) y_pred = np.argmax(y_conv_val, 1) print('y_pred', y_pred) correct_prediction = np.equal(y_pred, y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Error count', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: %g ' % test_accuracy)
def test_mnist_cnn(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x = tf.compat.v1.placeholder(tf.float32, [None, 28, 28, 1]) y_ = tf.compat.v1.placeholder(tf.float32, [None, 10]) # Create the model y_conv = cryptonets_test_squashed(x) with tf.compat.v1.Session() as sess: x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] start_time = time.time() y_conv_val = y_conv.eval(feed_dict={x: x_test, y_: y_test}) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) correct_prediction = np.equal(np.argmax(y_conv_val, 1), y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Error count:', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: ', test_accuracy)
def main(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x = tf.compat.v1.placeholder(tf.float32, [None, 28, 28, 1]) y_ = tf.compat.v1.placeholder(tf.float32, [None, 10]) y_conv = model.cryptonets_relu_model(x, 'train') with tf.name_scope('loss'): cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2( labels=y_, logits=y_conv) cross_entropy = tf.reduce_mean(cross_entropy) with tf.name_scope('adam_optimizer'): train_step = tf.compat.v1.train.AdamOptimizer(1e-4).minimize( cross_entropy) with tf.name_scope('accuracy'): correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) correct_prediction = tf.cast(correct_prediction, tf.float32) accuracy = tf.reduce_mean(correct_prediction) with tf.compat.v1.Session() as sess: sess.run(tf.compat.v1.global_variables_initializer()) for i in range(FLAGS.train_loop_count): x_batch, y_batch = get_train_batch(i, FLAGS.batch_size, x_train, y_train) if i % 100 == 0: t = time.time() train_accuracy = accuracy.eval(feed_dict={ x: x_batch, y_: y_batch }) print('step %d, training accuracy %g, %g msec to evaluate' % (i, train_accuracy, 1000 * (time.time() - t))) t = time.time() _, loss = sess.run([train_step, cross_entropy], feed_dict={ x: x_batch, y_: y_batch }) if i % 1000 == 999 or i == FLAGS.train_loop_count - 1: test_accuracy = accuracy.eval(feed_dict={ x: x_test, y_: y_test }) print('test accuracy %g' % test_accuracy) print("Training finished. Saving variables.") for var in tf.compat.v1.get_collection( tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES): weight = (sess.run([var]))[0].flatten().tolist() filename = (str(var).split())[1].replace('/', '_') filename = filename.replace("'", "").replace(':0', '') + '.txt' print("saving", filename) np.savetxt(str(filename), weight) squash_layers()
def main(FLAGS): (x_train, y_train, x_test, y_test) = mnist_util.load_mnist_data() x = Input(shape=( 28, 28, 1, ), name="input") y = model.cryptonets_model(x) cryptonets_model = Model(inputs=x, outputs=y) print(cryptonets_model.summary()) def loss(labels, logits): return keras.losses.categorical_crossentropy(labels, logits, from_logits=True) optimizer = SGD(learning_rate=0.008, momentum=0.9) cryptonets_model.compile(optimizer=optimizer, loss=loss, metrics=["accuracy"]) cryptonets_model.fit(x_train, y_train, epochs=FLAGS.epochs, batch_size=FLAGS.batch_size, validation_data=(x_test, y_test), verbose=1) test_loss, test_acc = cryptonets_model.evaluate(x_test, y_test, verbose=1) print("Test accuracy:", test_acc) # Squash weights and save model weights = squash_layers(cryptonets_model, tf.compat.v1.keras.backend.get_session()) (conv1_weights, squashed_weights, fc1_weights, fc_1half_weights, fc2_weights) = weights[0:5] tf.reset_default_graph() sess = tf.compat.v1.Session() x = Input(shape=( 28, 28, 1, ), name="input") y = model.cryptonets_model_squashed(x, conv1_weights, squashed_weights, fc_1half_weights, fc2_weights) sess.run(tf.compat.v1.global_variables_initializer()) mnist_util.save_model( sess, ["output/BiasAdd"], "./models", "testnets_1", )
def main(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x = tf.compat.v1.placeholder(tf.float32, [None, 28, 28, 1], name='input') y_ = tf.compat.v1.placeholder(tf.float32, [None, 10]) y_conv = model.mnist_mlp_model(x) with tf.name_scope('loss'): cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2( labels=y_, logits=y_conv) cross_entropy = tf.reduce_mean(cross_entropy) with tf.name_scope('adam_optimizer'): train_step = tf.compat.v1.train.AdamOptimizer(1e-4).minimize( cross_entropy) with tf.name_scope('accuracy'): correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) correct_prediction = tf.cast(correct_prediction, tf.float32) accuracy = tf.reduce_mean(correct_prediction) with tf.compat.v1.Session() as sess: sess.run(tf.compat.v1.global_variables_initializer()) for i in range(FLAGS.train_loop_count): x_batch, y_batch = get_train_batch(i, FLAGS.batch_size, x_train, y_train) if i % 100 == 0: t = time.time() train_accuracy = accuracy.eval(feed_dict={ x: x_batch, y_: y_batch }) print('step %d, training accuracy %g, %g msec to evaluate' % (i, train_accuracy, 1000 * (time.time() - t))) t = time.time() _, loss = sess.run([train_step, cross_entropy], feed_dict={ x: x_batch, y_: y_batch }) if i % 1000 == 999 or i == FLAGS.train_loop_count - 1: test_accuracy = accuracy.eval(feed_dict={ x: x_test, y_: y_test }) print('test accuracy %g' % test_accuracy) print("Training finished. Saving model.") save_model(sess, './model', 'model')
def test_mnist_cnn(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() batch_size = FLAGS.batch_size x_test_batch = x_test[:batch_size] y_test_batch = y_test[:FLAGS.batch_size] data = x_test_batch.swapaxes(1, 2).flatten('F') print('Client batch size from FLAG: ', batch_size) complex_scale_factor = 1 if ('NGRAPH_COMPLEX_PACK' in os.environ): complex_scale_factor = 2 print('complex_scale_factor', complex_scale_factor) # TODO: support even batch sizes assert (batch_size % complex_scale_factor == 0) hostname = 'localhost' port = 34000 new_batch_size = batch_size // complex_scale_factor print('new_batch_size', new_batch_size) client = he_seal_client.HESealClient(hostname, port, new_batch_size, data) print('Sleeping until client is done') while not client.is_done(): time.sleep(1) results = client.get_results() results = np.round(results, 2) y_pred_reshape = np.array(results).reshape(10, batch_size) with np.printoptions(precision=3, suppress=True): print(y_pred_reshape.T) y_pred = y_pred_reshape.argmax(axis=0) print('y_pred', y_pred) y_true = y_test_batch.argmax(axis=1) correct = np.sum(np.equal(y_pred, y_true)) acc = correct / float(batch_size) print('pred size', len(y_pred)) print('correct', correct) print('Accuracy (batch size', batch_size, ') =', acc * 100., '%')
def train_model(): (x_train, y_train, x_test, y_test) = load_mnist_data() x = Input( shape=( 28, 28, 1, ), name="input") y = mnist_mlp_model(x) mlp_model = Model(inputs=x, outputs=y) print(mlp_model.summary()) def loss(labels, logits): return categorical_crossentropy(labels, logits, from_logits=True) optimizer = Adam() mlp_model.compile(optimizer=optimizer, loss=loss, metrics=["accuracy"]) t0 = time.perf_counter() mlp_model.fit( x_train, y_train, epochs=10, batch_size=128, validation_data=(x_test, y_test), verbose=1) t1 = time.perf_counter() cur_times['t_training'] = delta_ms(t0, t1) test_loss, test_acc = mlp_model.evaluate(x_test, y_test, verbose=1) print("\nTest accuracy:", test_acc) save_model( tf.compat.v1.keras.backend.get_session(), ["output/BiasAdd"], "./models", "mlp", ) # If we want to have training and testing in the same run, we must clean up after training tf.keras.backend.clear_session tf.reset_default_graph()
def get_data(name, party_id, n_parties, FLAGS): if name == 'mnist': (x_train, y_train, x_test, y_test) = load_mnist_data(FLAGS.start_batch, FLAGS.batch_size) leftover = len(x_train) % (n_parties + 1) x_train, y_train = x_train[:-leftover], y_train[:-leftover] leftover = len(x_test) % (n_parties + 1) x_test, y_Test = x_test[:-leftover], y_test[:-leftover] train_indices = np.arange(len(x_train)) # TODO: party_t* variables below are not used. party_train_indices = np.split(train_indices, n_parties)[party_id] test_indices = np.arange(len(x_test)) party_test_indices = np.split(test_indices, n_parties)[party_id] return (x_train[train_indices], y_train[train_indices]), (x_test[test_indices], y_test[test_indices]) else: raise ValueError(f"Invalid dataset name: {name}.")
def test_network(): batch_size = 4000 # Load MNIST data (for test set) (x_train, y_train, x_test, y_test) = load_mnist_data(start_batch=0, batch_size=batch_size) # Load saved model tf.import_graph_def(load_pb_file("models/cryptonets.pb")) print("loaded model") print_nodes() # Get input / output tensors x_input = tf.compat.v1.get_default_graph().get_tensor_by_name( "import/input:0") y_output = tf.compat.v1.get_default_graph().get_tensor_by_name( "import/output/BiasAdd:0") # Create configuration to encrypt input config = server_config(x_input.name) with tf.compat.v1.Session(config=config) as sess: sess.run(tf.compat.v1.global_variables_initializer()) start_time = time.time() t0 = time.perf_counter() y_hat = y_output.eval(feed_dict={x_input: x_test}) t1 = time.perf_counter() cur_times['t_computation'] = delta_ms(t0, t1) elasped_time = time.time() - start_time print("total time(s)", np.round(elasped_time, 3)) y_test_label = np.argmax(y_test, 1) if batch_size < 60: print("y_hat", np.round(y_hat, 2)) y_pred = np.argmax(y_hat, 1) correct_prediction = np.equal(y_pred, y_test_label) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print("Error count", error_count, "of", batch_size, "elements.") print("Accuracy: %g " % test_accuracy) cur_times['test_accuracy'] = test_accuracy
def test_mnist_cnn(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() batch_size = FLAGS.batch_size x_test_batch = x_test[:batch_size] y_test_batch = y_test[:FLAGS.batch_size] data = x_test_batch.flatten('C') print('Client batch size from FLAG:', batch_size) complex_packing = False if ('NGRAPH_COMPLEX_PACK' in os.environ): complex_packing = str2bool(os.environ['NGRAPH_COMPLEX_PACK']) hostname = 'localhost' port = 34000 print('complex_packing?', complex_packing) client = pyhe_client.HESealClient(hostname, port, batch_size, data, complex_packing) print('Sleeping until client is done') while not client.is_done(): time.sleep(1) results = client.get_results() results = np.round(results, 2) y_pred_reshape = np.array(results).reshape(batch_size, 10) with np.printoptions(precision=3, suppress=True): print(y_pred_reshape) y_pred = y_pred_reshape.argmax(axis=1) print('y_pred', y_pred) y_true = y_test_batch.argmax(axis=1) correct = np.sum(np.equal(y_pred, y_true)) acc = correct / float(batch_size) print('pred size', len(y_pred)) print('correct', correct) print('Accuracy (batch size', batch_size, ') =', acc * 100., '%')
def test_mnist_mlp(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] graph_def = load_pb_file('./model/model.pb') with tf.Graph().as_default(): tf.import_graph_def(graph_def) y_conv = tf.compat.v1.get_default_graph().get_tensor_by_name( "import/output:0") x_input = tf.compat.v1.get_default_graph().get_tensor_by_name( "import/input:0") config = server_config_from_flags(FLAGS, x_input.name) print('config', config) with tf.compat.v1.Session(config=config) as sess: start_time = time.time() y_conv_val = y_conv.eval( session=sess, feed_dict={ x_input: x_test, }) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) if not FLAGS.enable_client: y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) y_pred = np.argmax(y_conv_val, 1) print('y_pred', y_pred) correct_prediction = np.equal(y_pred, y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Error count', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: %g ' % test_accuracy)
def test_network(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data(FLAGS.start_batch, FLAGS.batch_size) # Load saved model tf.import_graph_def(load_pb_file(FLAGS.model_file)) print("loaded model") print_nodes() # Get input / output tensors x_input = tf.compat.v1.get_default_graph().get_tensor_by_name( FLAGS.input_node) y_output = tf.compat.v1.get_default_graph().get_tensor_by_name( FLAGS.output_node) # Create configuration to encrypt input FLAGS, unparsed = server_argument_parser().parse_known_args() config = server_config_from_flags(FLAGS, x_input.name) with tf.compat.v1.Session(config=config) as sess: sess.run(tf.compat.v1.global_variables_initializer()) start_time = time.time() y_hat = y_output.eval(feed_dict={x_input: x_test}) elasped_time = time.time() - start_time print("total time(s)", np.round(elasped_time, 3)) if not FLAGS.enable_client: y_test_label = np.argmax(y_test, 1) if FLAGS.batch_size < 60: print("y_hat", np.round(y_hat, 2)) y_pred = np.argmax(y_hat, 1) correct_prediction = np.equal(y_pred, y_test_label) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print("Error count", error_count, "of", FLAGS.batch_size, "elements.") print("Accuracy: %g " % test_accuracy)
def test_mnist_mlp(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] graph_def = load_pb_file('./model/model.pb') with tf.Graph().as_default(): tf.import_graph_def(graph_def) y_conv = tf.compat.v1.get_default_graph().get_tensor_by_name( "import/output:0") x_input = tf.compat.v1.get_default_graph().get_tensor_by_name( "import/Placeholder:0") sess = tf.compat.v1.Session() start_time = time.time() y_conv_val = y_conv.eval( session=sess, feed_dict={ x_input: x_test, }) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) using_client = (os.environ.get('NGRAPH_ENABLE_CLIENT') is not None) if not using_client: y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) y_pred = np.argmax(y_conv_val, 1) print('y_pred', y_pred) correct_prediction = np.equal(y_pred, y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Error count', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: %g ' % test_accuracy)
def main(FLAGS): (x_train, y_train, x_test, y_test) = mnist_util.load_mnist_data() x = Input( shape=( 28, 28, 1, ), name="input") y = model.mnist_mlp_model(x) mlp_model = Model(inputs=x, outputs=y) print(mlp_model.summary()) def loss(labels, logits): return categorical_crossentropy(labels, logits, from_logits=True) optimizer = SGD(learning_rate=0.008, momentum=0.9) mlp_model.compile(optimizer=optimizer, loss=loss, metrics=["accuracy"]) mlp_model.fit( x_train, y_train, epochs=FLAGS.epochs, batch_size=FLAGS.batch_size, validation_data=(x_test, y_test), verbose=1) test_loss, test_acc = mlp_model.evaluate(x_test, y_test, verbose=1) print("\nTest accuracy:", test_acc) mnist_util.save_model( tf.compat.v1.keras.backend.get_session(), ["output/BiasAdd"], "./models", "mlp", )
def train_model(): (x_train, y_train, x_test, y_test) = load_mnist_data() x = Input(shape=( 28, 28, 1, ), name="input") y = cryptonets_model(x) cryptonets_model_var = Model(inputs=x, outputs=y) print(cryptonets_model_var.summary()) def loss(labels, logits): return categorical_crossentropy(labels, logits, from_logits=True) optimizer = Adam() cryptonets_model_var.compile(optimizer=optimizer, loss=loss, metrics=["accuracy"]) t0 = time.perf_counter() cryptonets_model_var.fit(x_train, y_train, epochs=10, batch_size=128, validation_data=(x_test, y_test), verbose=1) t1 = time.perf_counter() cur_times['t_training'] = delta_ms(t0, t1) test_loss, test_acc = cryptonets_model_var.evaluate(x_test, y_test, verbose=1) print("Test accuracy:", test_acc) # Squash weights and save model weights = squash_layers(cryptonets_model_var, tf.compat.v1.keras.backend.get_session()) (conv1_weights, squashed_weights, fc1_weights, fc2_weights, act1_weights, act2_weights) = weights[0:6] tf.reset_default_graph() sess = tf.compat.v1.Session() x = Input(shape=( 28, 28, 1, ), name="input") y = cryptonets_model_squashed(x, conv1_weights, squashed_weights, fc2_weights, act1_weights, act2_weights) sess.run(tf.compat.v1.global_variables_initializer()) save_model( sess, ["output/BiasAdd"], "./models", "cryptonets", ) # If we want to have training and testing in the same run, we must clean up after training tf.keras.backend.clear_session tf.reset_default_graph()
def test_mnist_cnn(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data() x = tf.compat.v1.placeholder(tf.float32, [None, 28, 28, 1], name='input') y_ = tf.compat.v1.placeholder(tf.float32, [None, 10]) # Create the model #Using full dataset y_conv = cryptonets_test_squashed(x) config = server_config_from_flags(FLAGS, x.name) print('config', config) with tf.compat.v1.Session(config=config) as sess: x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] start_time = time.time() y_conv_val = y_conv.eval(feed_dict={x: x_test, y_: y_test}) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) print('y_conv_val', np.round(y_conv_val, 2)) y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) correct_prediction = np.equal(np.argmax(y_conv_val, 1), y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Using full dataset') print('Error count:', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: ', test_accuracy) #Using in HE_averaging y_conv = cryptonets_HE_avg(x) config = server_config_from_flags(FLAGS, x.name) print('config', config) with tf.compat.v1.Session(config=config) as sess: x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] start_time = time.time() y_conv_val = y_conv.eval(feed_dict={x: x_test, y_: y_test}) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) print('y_conv_val', np.round(y_conv_val, 2)) y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) correct_prediction = np.equal(np.argmax(y_conv_val, 1), y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Using HE_averaging') print('Error count:', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: ', test_accuracy) #Using in repeated sampling,mode 3 y_conv = cryptonets_test_squashed_mode(x,3) config = server_config_from_flags(FLAGS, x.name) print('config', config) with tf.compat.v1.Session(config=config) as sess: x_test = x_test[:FLAGS.batch_size] y_test = y_test[:FLAGS.batch_size] start_time = time.time() y_conv_val = y_conv.eval(feed_dict={x: x_test, y_: y_test}) elasped_time = (time.time() - start_time) print("total time(s)", np.round(elasped_time, 3)) print('y_conv_val', np.round(y_conv_val, 2)) y_test_batch = y_test[:FLAGS.batch_size] y_label_batch = np.argmax(y_test_batch, 1) correct_prediction = np.equal(np.argmax(y_conv_val, 1), y_label_batch) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print('Using average of 4 partitions_repeated sampling') print('Error count:', error_count, 'of', FLAGS.batch_size, 'elements.') print('Accuracy: ', test_accuracy)
with open("output.txt", 'w') as outfile: for v in array_sum.flatten(): outfile.write(f'{v}\n') csp_filenames = [f'noise{port}privacy.txt' for port in FLAGS.ports] label = csp.get_histogram( client_filename='output.txt', csp_filenames=csp_filenames, csp_sum_filename='final.txt') print(label) if __name__ == "__main__": FLAGS, unparsed = client_argument_parser().parse_known_args() if unparsed: print("Unparsed flags:", unparsed) exit(1) (x_train, y_train, x_test, y_test) = load_mnist_data( FLAGS.start_batch, FLAGS.batch_size) is_test = False if is_test: data = mnist_x_test y_test = [mnist_y_test] else: data = x_test.flatten("C") # print('data (x_test): ', data) # print('y_test: ', y_test) run_client(FLAGS=FLAGS, data=data, labels=y_test)
def run_server(FLAGS): (x_train, y_train, x_test, y_test) = load_mnist_data(FLAGS.start_batch, FLAGS.batch_size) # Load saved model tf.import_graph_def(load_pb_file(FLAGS.model_file)) print("loaded model") print_nodes() # Get input / output tensors x_input = tf.compat.v1.get_default_graph().get_tensor_by_name( FLAGS.input_node) y_output = tf.compat.v1.get_default_graph().get_tensor_by_name( FLAGS.output_node) # y_max = tf.nn.softmax(y_output) # y_max = y_output # y_max = approximate_softmax(x=y_output, nr_terms=2) # y_max = max_pool(y_output=y_output, FLAGS=FLAGS) print('r_star: ', FLAGS.rstar) print('is r_star [-1.0]', FLAGS.rstar == [-1.0]) r_star = None if FLAGS.rstar is None: # for debugging: we don't want any r* y_max = y_output else: if FLAGS.rstar == [-1.0]: # Generate random r_star if y_test is not None: r_shape = y_test.shape batch_size = r_shape[0] num_classes = r_shape[1] else: batch_size, num_classes = FLAGS.batch_size, FLAGS.num_classes r_star = get_rstar_server( max_logit=FLAGS.max_logit, batch_size=batch_size, num_classes=num_classes, exp=FLAGS.rstar_exp, ) else: r_star = np.array(FLAGS.rstar) # r - r* (subtract the random vector r* from logits) y_max = tf.subtract(y_output, tf.convert_to_tensor(r_star, dtype=tf.float32)) if FLAGS.debug is True: print('y_max shape: ', y_max.shape) print('r_star shape: ', r_star.shape) y_max = tf.concat([y_max, r_star], axis=0) # Create configuration to encrypt input config = server_config_from_flags(FLAGS, x_input.name) with tf.compat.v1.Session(config=config) as sess: sess.run(tf.compat.v1.global_variables_initializer()) start_time = time.time() y_hat = sess.run(y_max, feed_dict={x_input: x_test}) # y_hat = y_max.eval(feed_dict={x_input: x_test}) print('y_hat: ', y_hat) if FLAGS.debug is True: r_star = y_hat[FLAGS.batch_size:] y_hat = y_hat[:FLAGS.batch_size] print("logits (y_hat): ", array_str(y_hat)) print("logits (y_hat) type: ", type(y_hat)) print("logits (y_hat) shape: ", y_hat.shape) # print("change y_hat to one_hot encoding") y_pred = y_hat.argmax(axis=1) print("y_pred: ", y_pred) elasped_time = time.time() - start_time print("total time(s)", np.round(elasped_time, 3)) party_id = int(FLAGS.port) if r_star is not None: print("doing 2pc") print('r_star (r*): ', array_str(r_star)) if FLAGS.round_exp is not None: # r_star = (r_star * 2 ** FLAGS.round_exp).astype(np.int64) r_star = round_array(x=r_star, exp=FLAGS.round_exp) print('rounded r_star (r*): ', array_str(r_star)) with open(f'{out_server_name}{party_id}.txt', 'w') as outfile: # party id # assume batch size of 1 for now TODO: make this work for > 1 batch size for val in r_star.flatten(): outfile.write(f"{int(val)}" + '\n') time.sleep(1) process = subprocess.Popen([ './gc-emp-test/bin/argmax_1', '1', '12345', f'{out_server_name}{party_id}.txt', f'{out_final_name}{party_id}.txt' ]) # time.sleep(15) process.wait() else: print('r_star is None in he_server.py!') if not FLAGS.enable_client: y_test_label = np.argmax(y_test, 1) if FLAGS.batch_size < 60: print("y_hat", np.round(y_hat, 2)) y_pred = np.argmax(y_hat, 1) correct_prediction = np.equal(y_pred, y_test_label) error_count = np.size(correct_prediction) - np.sum(correct_prediction) test_accuracy = np.mean(correct_prediction) print("Error count", error_count, "of", FLAGS.batch_size, "elements.") print("Accuracy: %g " % test_accuracy)