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_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 perform_inference(test_data, test_data_labels, parameters):
"""
Performs inference. Based on: https://github.com/IntelAI/he-transformer/blob/master/examples/MNIST/pyclient_mnist.py
:param test_data: The test data.
:param test_data_labels: The test labels.
:param parameters: The parameters.
:return: The number of correct predictions.
"""
num_classes = test_data_labels.shape[1]
test_data_flat = test_data.flatten("C")
start_time = time.time()
client = pyhe_client.HESealClient(
parameters.hostname, parameters.port, parameters.batch_size, {
parameters.tensor_name:
(parameters.encrypt_data_str, test_data_flat)
})
print("Waiting for results.")
prediction_scores = np.array(client.get_results()).reshape(
parameters.batch_size, num_classes)
end_time = time.time()
print("Got predictions with shape {} in time: {}".format(
prediction_scores.shape, end_time - start_time))
correct_predictions = calculate_num_correct_predictions(
prediction_scores, test_data_labels)
num_samples = test_data_labels.shape[0]
print('HE-Transformer: {}/{} Test set: Accuracy: ({:.4f})'.format(
correct_predictions, num_samples, correct_predictions / num_samples))
return correct_predictions
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 main(FLAGS):
data = (2, 4, 6, 8)
batch_size = 1
client = pyhe_client.HESealClient(
FLAGS.hostname, FLAGS.port, batch_size,
{"client_parameter_name": ("encrypt", data)})
results = client.get_results()
print("results", results)
def main(FLAGS):
data = (1, 2, 3, 4)
port = 34000
batch_size = 1
client = pyhe_client.HESealClient(
FLAGS.hostname, port, batch_size,
{'client_parameter_name': ('encrypt', data)})
results = client.get_results()
print('results', results)
def main(FLAGS):
util.VAL_IMAGE_FLAGS = FLAGS
imagenet_inference_labels = get_imagenet_inference_labels()
imagenet_training_labels = get_imagenet_training_labels()
assert (
sorted(imagenet_training_labels) == sorted(imagenet_inference_labels))
validation_nums = get_validation_labels(FLAGS)
x_test = get_validation_images(FLAGS)
validation_labels = imagenet_inference_labels[validation_nums]
if FLAGS.batch_size < 10:
print('validation_labels', validation_labels)
(batch_size, width, height, channels) = x_test.shape
print('batch_size', batch_size)
print('width', width)
print('height', height)
print('channels', channels)
x_test_flat = x_test.flatten(order='C')
hostname = 'localhost'
port = 34000
if 'NGRAPH_COMPLEX_PACK' in os.environ:
complex_packing = str2bool(os.environ['NGRAPH_COMPLEX_PACK'])
else:
complex_packing = False
client = pyhe_client.HESealClient(FLAGS.hostname, port, batch_size,
x_test_flat, complex_packing)
while not client.is_done():
time.sleep(1)
results = client.get_results()
imagenet_labels = get_imagenet_labels()
results = np.array(results)
if (FLAGS.batch_size == 1):
top5 = results.argsort()[-5:]
else:
results = np.reshape(results, (FLAGS.batch_size, 1001))
top5 = np.flip(results.argsort()[:, -5:], axis=1)
preds = imagenet_labels[top5]
print('validation_labels', validation_labels)
print('top5', preds)
util.accuracy(preds, validation_labels)
def test_network(FLAGS):
(x_train, y_train, x_test,
y_test) = load_fhir_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.array(client.get_results()).reshape(FLAGS.batch_size, 2)
y_pred = np.argmax(results, 1)
print("y_pred", y_pred)
def main(FLAGS):
data = (1, 2, 3, 4)
port = 34000
batch_size = 1
client = pyhe_client.HESealClient(FLAGS.hostname, port, batch_size, data,
False)
while not client.is_done():
time.sleep(1)
results = client.get_results()
print('results', results)
def test_network(FLAGS):
x_test = Dataset.get_user("dataset/npy/", FLAGS.user)
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, 9)
with np.printoptions(precision=3, suppress=True):
print(y_pred_reshape)
y_pred = y_pred_reshape.argmax(axis=1)
print("y_pred", y_pred)
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 main(FLAGS):
imagenet_inference_labels = get_imagenet_inference_labels()
imagenet_training_labels = get_imagenet_training_labels()
assert (
sorted(imagenet_training_labels) == sorted(imagenet_inference_labels))
validation_nums = get_validation_labels(FLAGS)
x_test = get_validation_images(FLAGS)
validation_labels = imagenet_inference_labels[validation_nums]
if FLAGS.batch_size < 10:
print('validation_labels', validation_labels)
(batch_size, width, height, channels) = x_test.shape
print('batch_size', batch_size)
print('width', width)
print('height', height)
print('channels', channels)
x_test_flat = x_test.flatten(order='C')
port = 34000
client = pyhe_client.HESealClient(FLAGS.hostname, port, batch_size,
{'input': ('encrypt', x_test_flat)})
results = client.get_results()
imagenet_labels = get_imagenet_labels()
results = np.array(results)
if (FLAGS.batch_size == 1):
top5 = results.argsort()[-5:]
else:
results = np.reshape(results, (FLAGS.batch_size, 1001))
top5 = np.flip(results.argsort()[:, -5:], axis=1)
preds = imagenet_labels[top5]
print('validation_labels', validation_labels)
print('top5', preds)
util.accuracy(preds, validation_labels)
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import pyhe_client
import time
data = (1, 2, 3, 4)
hostname = 'localhost'
port = 34000
batch_size = 1
client = pyhe_client.HESealClient(hostname, port, batch_size, data, False)
while not client.is_done():
time.sleep(1)
results = client.get_results()
print('results', results)
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)
return response.json()
def test_network(FLAGS, xtest):
"""Encrypt data and send to inference server.
FLAGS: Client flags.
xtest: ndarray with EHR data.
:return: float with mortality prediction"""
(x_train, y_train, x_test, y_test) = load_fhir_data(
0, 1)
x_test = xtest.to_numpy().astype("float32")
data = x_test.flatten("C")
print(data)
print(FLAGS)
client = pyhe_client.HESealClient(
hostname,
FLAGS.port,
1,
{FLAGS.tensor_name: ("encrypt", data)},
)
results = np.array(client.get_results()).reshape(FLAGS.batch_size,2)
print(results)
y_pred = np.argmax(results,1)
print("y_pred", y_pred)
return y_pred
app = Flask(__name__)
@app.route('/', methods=['GET'])