def test_stack_convert(self):
tf.reset_default_graph()
global global_filename
global_filename = "stack.pb"
input1 = np.array([1, 4])
input2 = np.array([2, 5])
input3 = np.array([3, 6])
path = export_stack(global_filename, input1.shape)
tf.reset_default_graph()
graph_def = read_graph(path)
tf.reset_default_graph()
actual = run_stack(input1, input2, input3)
tf.reset_default_graph()
config = tfe.LocalConfig([
'server0',
'server1',
'crypto_producer',
'prediction_client',
'weights_provider',
])
with tfe.protocol.Pond(*config.get_players(
'server0, server1, crypto_producer')) as prot:
prot.clear_initializers()
class PredictionClient(tfe.io.InputProvider):
self.input = None
def provide_input(self):
return tf.constant(self.input)
i1 = PredictionClient(config.get_player('prediction_client'))
i1.input = input1
i2 = PredictionClient(config.get_player('prediction_client'))
i2.input = input2
i3 = PredictionClient(config.get_player('prediction_client'))
i3.input = input3
input = [i1, i2, i3]
converter = Converter(config, prot,
config.get_player('weights_provider'))
x = converter.convert(graph_def, input, register())
with config.session() as sess:
tfe.run(sess, prot.initializer, tag='init')
output = x.reveal().eval(sess, tag='reveal')
np.testing.assert_array_almost_equal(output, actual, decimal=3)
def test_strided_slice_convert(self):
tf.reset_default_graph()
global global_filename
global_filename = "strided_slice.pb"
path = export_strided_slice(global_filename)
tf.reset_default_graph()
graph_def = read_graph(path)
tf.reset_default_graph()
input = [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]],
[[5, 5, 5], [6, 6, 6]]]
actual = run_strided_slice(input)
tf.reset_default_graph()
config = tfe.LocalConfig([
'server0',
'server1',
'crypto_producer',
'prediction_client',
'weights_provider',
])
with tfe.protocol.Pond(*config.get_players(
'server0, server1, crypto_producer')) as prot:
prot.clear_initializers()
class PredictionClient(tfe.io.InputProvider):
def provide_input(self):
return tf.constant([[[1, 1, 1], [2, 2, 2]],
[[3, 3, 3], [4, 4, 4]],
[[5, 5, 5], [6, 6, 6]]])
input = PredictionClient(config.get_player('prediction_client'))
converter = Converter(config, prot,
config.get_player('weights_provider'))
x = converter.convert(graph_def, input, register())
with config.session() as sess:
tfe.run(sess, prot.initializer, tag='init')
output = x.reveal().eval(sess, tag='reveal')
np.testing.assert_array_almost_equal(output, actual, decimal=3)
def test_avgpooling_convert(self):
tf.reset_default_graph()
global global_filename
global_filename = "avgpool.pb"
input_shape = [1, 28, 28, 1]
path = export_avgpool(global_filename, input_shape)
tf.reset_default_graph()
graph_def = read_graph(path)
tf.reset_default_graph()
actual = run_avgpool(input_shape)
tf.reset_default_graph()
config = tfe.LocalConfig([
'server0',
'server1',
'crypto_producer',
'prediction_client',
'weights_provider',
])
with tfe.protocol.Pond(*config.get_players(
'server0, server1, crypto_producer')) as prot:
prot.clear_initializers()
class PredictionClient(tfe.io.InputProvider):
def provide_input(self):
return tf.constant(np.ones(input_shape))
input = PredictionClient(config.get_player('prediction_client'))
converter = Converter(config, prot,
config.get_player('weights_provider'))
x = converter.convert(graph_def, input, register())
with config.session() as sess:
tfe.run(sess, prot.initializer, tag='init')
output = x.reveal().eval(sess, tag='reveal')
np.testing.assert_array_almost_equal(output, actual, decimal=3)
config = tfe.LocalConfig(3)
prot = Pond(*config.players)
# parameters
np_w = np.array([.1, .2, .3, .4]).reshape(2, 2)
np_b = np.array([.1, .2, .3, .4]).reshape(2, 2)
w = prot.define_private_variable(np_w)
b = prot.define_private_variable(np_b)
# input
x = prot.define_private_placeholder((2, 2))
# prediction
y = prot.sigmoid(w.dot(x) + b).reveal()
def sigmoid(x):
return 1 / (1 + np.exp(-x))
with config.session() as sess:
tfe.run(sess, prot.initializer, tag='init')
np_x = np.array([.1, -.1, .2, -.2]).reshape(2, 2)
feed_dict = x.feed_from_native(np_x)
prediction = y.eval(sess, feed_dict=feed_dict, tag='reveal')
print('tf pred: ', prediction)
print('numpy pred: ', sigmoid(np_w.dot(np_x) + np_b))
# c = a * b
a = prot.define_private_variable(np.array([1., 2., 3., 4.]).reshape(2, 2))
b = prot.define_private_variable(np.array([1., 2., 3., 4.]).reshape(2, 2))
c = prot.define_private_variable(np.array([1., 2., 3., 4.]).reshape(2, 2))
x = (a * b)
y = (a * c)
z = x + y
w = prot.define_private_variable(np.zeros((2, 2)))
with config.session() as sess:
# print(c.eval(sess, tag='c'))
tfe.run(sess, prot.initializer, tag='init')
tfe.run(sess, prot.assign(w, z), tag='assign')
tfe.run(sess, prot.assign(w, z), tag='assign')
print(w.reveal().eval(sess, tag='reveal'))
# g.eval(sess, tag='g')
# sess.run(prot.assign(d, f))
# sess.run(prot.assign(e, e))
# print(f.reveal().eval(sess))
# g = prot.sigmoid(d)
# print(g.reveal().eval(sess))
prediction_output = PredictionOutputReceiver(config.get_player('prediction_client'))
with tfe.protocol.Pond(*config.get_players('server0, server1, crypto_producer')) as prot:
# # treat weights as private
# initial_w = prot.define_private_input(weights_input)
# w = prot.define_private_variable(initial_w)
# treat weights as private, but initial value as public
# initial_w = prot.define_public_input(weights_input)
# w = prot.define_private_variable(initial_w)
# treat weights as public
initial_w = prot.define_public_input(weights_input)
w = prot.define_public_variable(initial_w)
# load input for prediction
x = prot.define_private_input(prediction_input)
# compute prediction
y = x.dot(w)
# send output
prediction_op = prot.define_output(y, prediction_output)
with config.session() as sess:
tfe.run(sess, tf.global_variables_initializer(), tag='init')
for _ in range(5):
tfe.run(sess, prediction_op, tag='prediction')
export_cnn()
tf.reset_default_graph()
model_filename = 'cnn.pb'
with gfile.FastGFile(model_filename, 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
config = tfe.LocalConfig([
'server0', 'server1', 'crypto_producer', 'prediction_client',
'weights_provider'
])
with tfe.protocol.Pond(
*config.get_players('server0, server1, crypto_producer')) as prot:
input = PredictionInputProvider(config.get_player('prediction_client'))
output = PredictionOutputReceiver(config.get_player('prediction_client'))
c = convert.Converter(config, prot, config.get_player('weights_provider'))
x = c.convert(graph_def, input, register())
prediction_op = prot.define_output(x, output)
with config.session() as sess:
tfe.run(sess, prot.initializer, tag='init')
tfe.run(sess, prediction_op, tag='prediction')
w0, b0, w1, b1 = prot.define_private_input(model_trainer, masked=True) # pylint: disable=E0632
# we'll use the same parameters for each prediction so we cache them to avoid re-training each time
w0, b0, w1, b1 = prot.cache([w0, b0, w1, b1])
# get prediction input from client
x = prot.define_private_input(prediction_client, masked=True) # pylint: disable=E0632
# compute prediction
layer0 = prot.dot(x, w0) + b0
layer1 = prot.sigmoid(layer0 * 0.1) # input normalized to avoid large values
layer2 = prot.dot(layer1, w1) + b1
prediction = layer2
# send prediction output back to client
prediction_op = prot.define_output(prediction, prediction_client)
target = sys.argv[2] if len(sys.argv) > 2 else None
with config.session(target) as sess:
print("Init")
tfe.run(sess, tf.global_variables_initializer(), tag='init')
print("Training")
tfe.run(sess, tfe.global_caches_updator(), tag='training')
for _ in range(5):
print("Predicting")
tfe.run(sess, prediction_op, tag='prediction')
class ResultReceiver(tfe.io.OutputReceiver):
def receive_output(self, tensors: List[tf.Tensor]) -> tf.Operation:
average, = tensors
# simply print average
return tf.Print([], [average], summarize=10, message="Average:")
# create players based on names from above
inputters = [Inputter(config.get_player(name)) for name in player_names_inputter]
result_receiver = ResultReceiver(config.get_player('result_receiver'))
server0 = config.get_player('server0')
server1 = config.get_player('server1')
crypto_producer = config.get_player('crypto_producer')
with tfe.protocol.Pond(server0, server1, crypto_producer) as prot:
# get input from inputters as private values
inputs = [prot.define_private_input(inputter)[0] for inputter in inputters]
# sum all inputs and divide by count
result = reduce(lambda x, y: x + y, inputs) * (1 / len(inputs))
# send result to receiver
result_op = prot.define_output([result], result_receiver)
with config.session() as sess:
tfe.run(sess, tf.global_variables_initializer())
for _ in range(3):
tfe.run(sess, result_op, tag='average')
