def run_client(FLAGS, data):
port = FLAGS.port
if isinstance(port, list) or isinstance(port, tuple):
print("WARNING: list ports were passed. Only one should be passed.")
port = port[0] # only one port should be passed
if FLAGS.batch_size > 1:
raise ValueError('batch size > 1 not currently supported.')
inference_start = time.time()
client = pyhe_client.HESealClient(
FLAGS.hostname,
port,
FLAGS.batch_size,
{
"import/input"
# FLAGS.tensor_name
: (FLAGS.encrypt_data_str, data)},
)
print(f"data shape: {data.shape}")
r_rstar = np.array(client.get_results())
inference_end = time.time()
print(f"Inference time: {inference_end - inference_start}s")
with open(inference_times_name, 'a') as outfile:
outfile.write(str(inference_end - inference_start))
outfile.write('\n')
print('r_rstar (r-r*): ', array_str(r_rstar))
rstar = FLAGS.r_star
if rstar is None:
raise ValueError('r_star should be provided but was None.')
r_rstar = round_array(x=r_rstar, exp=FLAGS.round_exp)
print('rounded r_rstar (r-r*): ', array_str(r_rstar))
print("Writing out logits file to txt.")
with open(f'{out_client_name}{port}privacy.txt', 'w') as outfile:
for val in r_rstar.flatten():
outfile.write(f"{int(val)}\n")
# do 2 party computation with each Answering Party
msg = 'starting 2pc with Answering Party'
print(msg)
log_timing(stage='client:' + msg,
log_file=FLAGS.log_timing_file)
# completed = {port: False for port in flags.ports}
max_t = time.time() + 100000
while not os.path.exists(f"{out_final_name}{port}privacy.txt"):
print(f'client starting 2pc with port: {port}')
process = subprocess.Popen(
['./gc-emp-test/bin/argmax_1', '2', '12345',
f'{out_client_name}{port}privacy.txt'])
time.sleep(1)
if time.time() > max_t:
raise ValueError("Step 1' of protocol never finished. Issue.")
log_timing(stage='client:finished 2PC',
log_file=FLAGS.log_timing_file)
return r_rstar, rstar
def test_round_array3(self):
a = np.array([[0.38, 0.42], [0.28, 0.32]])
a = round_array(x=a, exp=100)
print('rounded a: ', array_str(a))
b = [[481707228086727178198246752256, 532413252095856328925366976512],
[354942168063904266196074102784, 405648192073033416923194327040]]
np.testing.assert_array_equal(x=a, y=b)
def check_rstar_stage1(rstar, r_rstar, labels, port):
if len(labels.shape) > 1:
# change from one-hot encoding to labels
labels = labels.argmax(axis=1)
correct, pred_r = is_correct_pred(r_rstar=r_rstar,
rstar=rstar,
labels=labels)
if correct:
print(f'expected label(s) for port {port}: ', labels)
print('r_rstar label(s): ', pred_r)
print('stage 1 correct')
else:
print('rstar: ', array_str(rstar))
print('r_rstar: ', array_str(r_rstar))
print(f'expected label(s) for port {port}: ', labels, ' type: ',
type(labels))
print('r_rstar label(s): ', pred_r, ' type: ', type(pred_r))
raise Exception(f'Failed stage 1 for port: {port}.')
def run_server(FLAGS, query):
# tf.import_graph_def(load_pb_file(FLAGS.model_file))
tf.import_graph_def(
load_pb_file("/home/dockuser/models/cryptonets-relu.pb"))
# tf.import_graph_def(load_pb_file(f"/home/dockuser/models/{FLAGS.port}.pb"))
print("loaded model")
print_nodes()
print(f"query: {query.shape}")
# Get input / output tensors
x_input = tf.compat.v1.get_default_graph().get_tensor_by_name(
# FLAGS.input_node
# "import/Placeholder:0"
"import/input:0")
y_output = tf.compat.v1.get_default_graph().get_tensor_by_name(
"import/output/BiasAdd:0"
# FLAGS.output_node
# "import/dense/BiasAdd:0"
)
# weight_check = tf.compat.v1.get_default_graph().get_tensor_by_name("import/conv2d_1/kernel:0")
# print(weight_check)
# Load saved model
#
# model = models.Local_Model(FLAGS.num_classes, FLAGS.dataset_name) # load the model object
# input_x = tf.compat.v1.placeholder( # define input
# shape=(
# None,
# 3,
# 32,
# 32,
# ), name="input", dtype=tf.float32)
# init = tf.compat.v1.global_variables_initializer()
# model.build((None, 3, 32, 32))
# model.compile('adam', tf.keras.losses.CategoricalCrossentropy())
# output_y = model.get_out(input_x) # input through layers
# print("loaded model")
# print_nodes()
# print(input_x)
# print(output_y)
# 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.r_star)
r_star = np.array(FLAGS.r_star)
# r - r* (subtract the random vector r* from logits)
y_max = tf.subtract(y_output, tf.convert_to_tensor(r_star,
dtype=tf.float32))
# Create configuration to encrypt input
# config = server_config_from_flags(FLAGS, x_input.name)
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())
# model.initialize_weights(FLAGS.model_file)
start_time = time.time()
print(f"query shape before processing: {query.shape}")
inference_start = time.time()
y_hat = sess.run(y_max, feed_dict={x_input: query})
inference_end = time.time()
print(f"Inference time: {inference_end - inference_start}s")
with open(inference_no_network_times_name, 'a') as outfile:
outfile.write(str(inference_end - inference_start))
outfile.write('\n')
elasped_time = time.time() - start_time
print("total time(s)", np.round(elasped_time, 3))
party_id = int(FLAGS.port)
msg = "doing 2pc"
print(msg)
log_timing(stage='server_client:' + msg,
log_file=FLAGS.log_timing_file)
print('r_star (r*): ', array_str(r_star))
r_star = round_array(x=r_star, exp=FLAGS.round_exp)
print('rounded r_star (r*): ', array_str(r_star))
if FLAGS.backend == 'HE_SEAL':
argmax_time_start = time.time()
with open(f'{out_server_name}{FLAGS.port}.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')
process = subprocess.Popen([
'./gc-emp-test/bin/argmax_1', '1', '12345',
f'{out_server_name}{FLAGS.port}.txt',
f'{out_final_name}{FLAGS.port}.txt'
])
# time.sleep(15)
process.wait()
argmax_time_end = time.time()
with open(argmax_times_name, 'a') as outfile:
outfile.write(str(argmax_time_end - argmax_time_start))
outfile.write("\n")
log_timing(stage='server_client:finished 2PC',
log_file=FLAGS.log_timing_file)
def run_client(FLAGS, data=None, labels=None):
if data is None:
data = np.load(consts.input_data)
if labels is None:
labels = np.load(consts.input_labels)
r_rstars = {}
for i, port in enumerate(FLAGS.ports):
client = pyhe_client.HESealClient(
FLAGS.hostname,
port,
FLAGS.batch_size,
{FLAGS.tensor_name: (FLAGS.encrypt_data_str, data)},
)
raw_results = np.array(client.get_results())
print('raw results: ', array_str(raw_results))
rstar = None
if FLAGS.debug is True:
if FLAGS.rstar is not None:
raise Exception(
"Either debug or r_star or both flags have to be None.")
raw_shape_0 = raw_results.shape[0]
expected_shape_0 = 2 * FLAGS.batch_size
if raw_shape_0 != expected_shape_0:
raise Exception(
f'Expected r_star for each example in the batch'
f'and dim 0 size of the result: {expected_shape_0}'
f', but received result with dim 0 size:'
f' {raw_shape_0}')
r_rstar = raw_results[:FLAGS.batch_size]
rstar = raw_results[FLAGS.batch_size:]
else:
if FLAGS.rstar is None:
rstar = None
elif FLAGS.rstar == [-1.0]:
raise Exception('We do not generate r_star in the client.'
'r_star provided is [-1.0].')
if FLAGS.rstar is not None:
rstar = np.array(FLAGS.rstar)
r_rstar = raw_results
print('r_rstar (r-r*): ', array_str(r_rstar))
if FLAGS.round_exp:
# r_rstar = (r_rstar * 2 ** FLAGS.round_exp).astype(np.int64)
r_rstar = round_array(x=r_rstar, exp=FLAGS.round_exp)
print('rounded r_rstar (r-r*): ', array_str(r_rstar))
r_rstars[port] = r_rstar
y_pred_reshape = np.array(r_rstar).reshape(FLAGS.batch_size, 10)
y_labels = labels.argmax(axis=1)
print("y_test: ", y_labels)
y_pred = y_pred_reshape.argmax(axis=1)
print("y_pred: ", y_pred)
correct = np.sum(np.equal(y_pred, y_labels))
acc = correct / float(FLAGS.batch_size)
print("correct from original result: ", correct)
print(
"Accuracy original result (batch size", FLAGS.batch_size, ") =",
acc * 100.0, "%")
with open(f'{out_client_name}{port}privacy.txt', 'w') as outfile:
for val in y_pred_reshape.flatten():
outfile.write(f"{int(val)}\n")
if rstar is not None:
results_r = y_pred_reshape + rstar
y_pred_r = results_r.argmax(axis=1)
print('y_pred_r: ', y_pred_r)
correct = np.sum(np.equal(y_pred_r, y_labels))
acc = correct / float(FLAGS.batch_size)
print("correct after adding r*: ", correct)
print(
"Accuracy after adding r* (batch size", FLAGS.batch_size, ") =",
acc * 100.0, "%")
print(port, "DONE----------------------")
time.sleep(5)
# do 2 party computation with each Answering Party
print('starting 2pc')
completed = {port: False for port in FLAGS.ports}
n_parties = len(completed.keys())
max_t = time.time() + 100000
processes = []
while sum(completed.values()) < n_parties and time.time() < max_t:
for port in completed.keys():
if not completed[port]:
if not os.path.exists(f"{out_client_name}{port}privacy.txt"):
raise ValueError('something broke')
out_server_file = f"{out_server_name}{port}privacy.txt"
if os.path.exists(out_server_file):
if FLAGS.predict_labels_file is not None:
predict_labels_file = FLAGS.predict_labels_file + str(
port) + '.npy'
predict_labels = np.load(predict_labels_file)
check_rstar_file_stage1(
rstar_file=out_server_file,
r_rstar=r_rstars[port],
labels=predict_labels,
port=port,
)
print(f'client starting 2pc with port: {port}')
completed[port] = True
process = subprocess.Popen(
['./gc-emp-test/bin/argmax_1', '2', '12345',
f'{out_client_name}{port}privacy.txt'])
process.wait()
processes.append(process)
else:
print(
f'Expected output file {out_server_file} from the party {port} does not exist yet!')
max_t = time.time() + 10000
while any([p.poll() for p in
processes]) is None: # wait on all argmaxs to finish first
time.sleep(1)
if time.time() > max_t:
raise ValueError(
f'something broke while waiting on processes for 2pc with servers: {[p.poll() for p in processes]}')
print("Prepping for 2pc with CSP")
if not sum(completed.values()) == n_parties:
raise ValueError('a 2pc with a server failed')
r_rstars = []
for port in FLAGS.ports:
with open(f'output{port}privacy.txt', 'r') as infile:
r_rstar = []
for line in infile:
r_rstar.append(int(line))
r_rstars.append(r_rstar)
r_rstars = np.array(r_rstars, np.int64)
print(r_rstars)
print('done')
if FLAGS.final_call:
fs = [f"output{port}privacy.txt" for port in FLAGS.ports]
array_sum = csp.sum_files(fs)
print(array_sum)
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)
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)
def test_round_array2(self):
a = np.array([[0.38, 0.42], [0.28, 0.32]])
a = round_array(x=a, exp=4)
print('rounded a: ', array_str(a))
b = [[6, 6], [4, 5]]
np.testing.assert_array_equal(x=a, y=b)
def test_round_array(self):
a = np.array([0.28, 0.32])
a = round_array(x=a, exp=4)
print('rounded a: ', array_str(a))
b = [4, 5]
np.testing.assert_array_equal(x=a, y=b)