def test_iterate_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): return tf.reshape(tf.range(0, 8), [4, 2]) # define inputs x = tfe.define_private_input('input-provider', provide_input) write_op = x.write("x.tfrecord") with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result sess.run(write_op) x = tfe.read("x.tfrecord", batch_size=5, n_columns=2) y = tfe.iterate(x, batch_size=3, repeat=True, shuffle=False) z = tfe.iterate(x, batch_size=3, repeat=True, shuffle=True) with tfe.Session() as sess: sess.run(tfe.global_variables_initializer()) print(sess.run(x.reveal())) print(sess.run(y.reveal())) print(sess.run(y.reveal())) print(sess.run(x.reveal())) print(sess.run(z.reveal()))
def test_iterate_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): return tf.reshape(tf.range(0, 8), [4, 2]) # define inputs x = tfe.define_private_input("input-provider", provide_input) _, tmp_filename = tempfile.mkstemp() write_op = x.write(tmp_filename) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result sess.run(write_op) x = tfe.read(tmp_filename, batch_size=5, n_columns=2) y = tfe.iterate(x, batch_size=3, repeat=True, shuffle=False) z = tfe.iterate(x, batch_size=3, repeat=True, shuffle=True) with tfe.Session() as sess: sess.run(tfe.global_variables_initializer()) # TODO: fix this test print(sess.run(x.reveal())) print(sess.run(y.reveal())) print(sess.run(y.reveal())) print(sess.run(x.reveal())) print(sess.run(z.reveal())) os.remove(tmp_filename)
def test_add_private_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): # normal TensorFlow operations can be run locally # as part of defining a private input, in this # case on the machine of the input provider return tf.ones(shape=(2, 2)) * 1.3 # define inputs x = tfe.define_private_variable(tf.ones(shape=(2, 2))) y = tfe.define_private_input('input-provider', provide_input) # define computation z = x + y with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z.reveal()) # Should be [[2.3, 2.3], [2.3, 2.3]] np.testing.assert_allclose(result, np.array([[2.3, 2.3], [2.3, 2.3]]), rtol=0.0, atol=0.01) print("test_add_private_private succeeds")
def test_mul_private_public(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) # define inputs x = tfe.define_private_variable(tf.ones(shape=(2, 2)) * 2) y = tfe.define_constant(np.array([[0.6, 0.7], [0.8, 0.9]])) w = tfe.define_constant(np.array([[2, 2], [2, 2]])) # define computation z1 = y * x # mul_public_private z2 = z1 * w # mul_private_public with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z2.reveal()) np.testing.assert_allclose(result, np.array([[2.4, 2.8], [3.2, 3.6]]), rtol=0.0, atol=0.01) print("test_mul_private_public succeeds")
def test_neg(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) # define inputs x = tfe.define_private_variable(np.array([[0.6, -0.7], [-0.8, 0.9]])) y = tfe.define_constant(np.array([[0.6, -0.7], [-0.8, 0.9]])) # define computation z1 = -x z2 = -y with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose(result, np.array([[-0.6, 0.7], [0.8, -0.9]]), rtol=0.0, atol=0.01) result = sess.run(z2) np.testing.assert_allclose(result, np.array([[-0.6, 0.7], [0.8, -0.9]]), rtol=0.0, atol=0.01) print("test_neg succeeds")
def test_read_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): return tf.reshape(tf.range(0, 8), [4, 2]) # define inputs x = tfe.define_private_input('input-provider', provide_input) write_op = x.write("x.tfrecord") with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result sess.run(write_op) x = tfe.read("x.tfrecord", batch_size=5, n_columns=2) with tfe.Session() as sess: result = sess.run(x.reveal()) np.testing.assert_allclose(result, np.array(list(range(0, 8)) + [0, 1]).reshape([5, 2]), rtol=0.0, atol=0.01) print("test_read_private succeeds")
def test_assign_synchronization(self): # from https://github.com/tf-encrypted/tf-encrypted/pull/665 prot = tfe.protocol.Pond() tfe.set_protocol(prot) def poc(x, y): x_shares = x.unwrapped y_shares = y.unwrapped z_shares = [None, None] with tf.name_scope("fabricated_test"): with tf.device(prot.server_0.device_name): z_shares[0] = x_shares[1] + y_shares[1] with tf.device(prot.server_1.device_name): z_shares[1] = x_shares[0] + y_shares[0] return tfe.protocol.pond.PondPrivateTensor(prot, z_shares[0], z_shares[1], x.is_scaled) a = prot.define_private_variable(tf.ones(shape=(1, 1))) b = prot.define_private_variable(tf.ones(shape=(1, 1))) op = prot.assign(a, poc(a, b)) with tfe.Session() as sess: sess.run(tfe.global_variables_initializer()) for _ in range(100): sess.run(op) result = sess.run(a.reveal()) assert result == np.array([101.])
def test_fp_sqrt_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) r = np.random.rand(16) * 100 # random in [0, 100) # define inputs x = tfe.define_private_input("input-provider", lambda: tf.constant(r)) # define computation sqrt_x = prot.fp_sqrt(x).reveal() sqrt_inv_x = prot.fp_sqrt_inv(x).reveal() with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result sqrt_x, sqrt_inv_x = sess.run([sqrt_x, sqrt_inv_x], tag="fp_sqrt") np.testing.assert_allclose(sqrt_x, np.sqrt(r), rtol=0.03, atol=0.05) np.testing.assert_allclose(sqrt_inv_x, 1. / np.sqrt(r), rtol=0.03, atol=0.05)
def test_polynomial_piecewise(): tf.reset_default_graph() import time start = time.time() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable( tf.constant([[-1, -0.5, -0.25], [0, 0.25, 2]])) # This is the approximation of the sigmoid function by using a piecewise function: # f(x) = (0 if x<-0.5), (x+0.5 if -0.5<=x<0.5), (1 if x>=0.5) z1 = tfe.polynomial_piecewise( x, (-0.5, 0.5), ( (0, ), (0.5, 1), (1, ) ) # Should use tuple because list is not hashable for the memoir cache key ) # Or, simply use the pre-defined sigmoid API which includes a different approximation z2 = tfe.sigmoid(x) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) close(result, np.array([[0, 0, 0.25], [0.5, 0.75, 1]])) result = sess.run(z2.reveal()) close(result, np.array([[0.33, 0.415, 0.4575], [0.5, 0.5425, 0.84]])) print("test_polynomial_piecewise succeeds") end = time.time() print("Elapsed time: {} seconds".format(end - start))
def test_bit_extract(): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(np.array([[1, -2, 3], [-4, -5, 6]]), share_type=ARITHMETIC) y = tfe.define_private_variable(np.array([[1, -2, 3], [-4, -5, 6]]), share_type=ARITHMETIC, apply_scaling=False) z = tfe.bit_extract( x, 63 ) # The sign bit. Since x is scaled, you should be more careful about extracting other bits. w = tfe.bit_extract(y, 1) # y is not scaled s = tfe.msb(x) # Sign bit with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z.reveal()) close(result.astype(int), np.array([[0, 1, 0], [1, 1, 0]])) result = sess.run(w.reveal()) close(result.astype(int), np.array([[0, 1, 1], [0, 1, 1]])) result = sess.run(s.reveal()) close(result.astype(int), np.array([[0, 1, 0], [1, 1, 0]])) print("test_bit_extract succeeds")
def test_ot(): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) m0 = prot.define_constant(np.array([[1, 2, 3], [4, 5, 6]]), apply_scaling=False).unwrapped[0] m1 = prot.define_constant(np.array([[2, 3, 4], [5, 6, 7]]), apply_scaling=False).unwrapped[0] c_on_receiver = prot.define_constant( np.array([[1, 0, 1], [0, 1, 0]]), apply_scaling=False, factory=prot.bool_factory).unwrapped[0] c_on_helper = prot.define_constant(np.array([[1, 0, 1], [0, 1, 0]]), apply_scaling=False, factory=prot.bool_factory).unwrapped[0] m_c = prot._ot(prot.servers[1], prot.servers[2], prot.servers[0], m0, m1, c_on_receiver, c_on_helper, prot.pairwise_keys[1][0], prot.pairwise_keys[0][1], prot.pairwise_nonces[0]) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(prot._decode(m_c, False)) close(result, np.array([[2, 2, 4], [4, 6, 6]])) print("test_ot succeeds")
def test_sub_private_public(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) # define inputs x = tfe.define_private_variable(tf.ones(shape=(2, 2))) y = tfe.define_constant(np.array([[0.6, 0.7], [0.8, 0.9]])) # define computation z1 = x - y z2 = y - x with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose(result, np.array([[0.4, 0.3], [0.2, 0.1]]), rtol=0.0, atol=0.01) result = sess.run(z2.reveal()) np.testing.assert_allclose(result, np.array([[-0.4, -0.3], [-0.2, -0.1]]), rtol=0.0, atol=0.01) print("test_sub_private_public succeeds")
def test_3d_matmul_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) # 3-D matrix mult x = tfe.define_private_variable( tf.constant(np.arange(1, 13), shape=[2, 2, 3])) y = tfe.define_private_variable( tf.constant(np.arange(13, 25), shape=[2, 3, 2])) z = tfe.matmul(x, y) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z.reveal()) np.testing.assert_allclose( result, np.array([[[94, 100], [229, 244]], [[508, 532], [697, 730]]]), rtol=0.0, atol=0.01, )
def test_mul_trunc2_private_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): # normal TensorFlow operations can be run locally # as part of defining a private input, in this # case on the machine of the input provider return tf.ones(shape=(2, 2)) * 1.3 # define inputs x = tfe.define_private_variable(tf.ones(shape=(2, 2)) * 2) y = tfe.define_private_input("input-provider", provide_input) # define computation z = tfe.mul_trunc2(x, y) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z.reveal(), tag="mul_trunc2") np.testing.assert_allclose( result, np.array([[2.6, 2.6], [2.6, 2.6]]), rtol=0.0, atol=0.01 )
def test_matmul_public_private(): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): # normal TensorFlow operations can be run locally # as part of defining a private input, in this # case on the machine of the input provider return tf.constant(np.array([[1.1, 1.2], [1.3, 1.4], [1.5, 1.6]])) # define inputs x = tfe.define_private_variable(tf.ones(shape=(2, 2))) y = tfe.define_public_input('input-provider', provide_input) v = tfe.define_constant(np.ones((2, 2))) # define computation w = y.matmul(x) # matmul_public_private z = w.matmul(v) # matmul_private_public with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(w.reveal()) close(result, np.array([[2.3, 2.3], [2.7, 2.7], [3.1, 3.1]])) result = sess.run(z.reveal()) close(result, np.array([[4.6, 4.6], [5.4, 5.4], [6.2, 6.2]])) print("test_matmul_public_private succeeds")
def test_transpose(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[1, 2, 3], [4, 5, 6]])) y = tfe.define_constant(np.array([[1, 2, 3], [4, 5, 6]])) z1 = x.transpose() z2 = tfe.transpose(y) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[1, 4], [2, 5], [3, 6]]), rtol=0.0, atol=0.01 ) result = sess.run(z2) np.testing.assert_allclose( result, np.array([[1, 4], [2, 5], [3, 6]]), rtol=0.0, atol=0.01 )
def test_concat(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x1 = tfe.define_private_variable(tf.constant([[1, 2], [4, 5]])) x2 = tfe.define_private_variable(tf.constant([[3], [6]])) y1 = tfe.define_constant(np.array([[1, 2, 3]])) y2 = tfe.define_constant(np.array([[4, 5, 6]])) z1 = tfe.concat([x1, x2], axis=1) z2 = tfe.concat([y1, y2], axis=0) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[1, 2, 3], [4, 5, 6]]), rtol=0.0, atol=0.01 ) result = sess.run(z2) np.testing.assert_allclose( result, np.array([[1, 2, 3], [4, 5, 6]]), rtol=0.0, atol=0.01 )
def test_polynomial_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[1, 2, 3], [4, 5, 6]])) # Friendly version y = 1 + 1.2 * x + 3 * (x ** 2) + 0.5 * (x ** 3) # More optimized version: No truncation for multiplying integer coefficients (e.g., '3' in this example) z = tfe.polynomial(x, [1, 1.2, 3, 0.5]) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(y.reveal()) np.testing.assert_allclose( result, np.array([[5.7, 19.4, 45.1], [85.8, 144.5, 224.2]]), rtol=0.0, atol=0.01, ) result = sess.run(z.reveal()) np.testing.assert_allclose( result, np.array([[5.7, 19.4, 45.1], [85.8, 144.5, 224.2]]), rtol=0.0, atol=0.01, )
def test_polynomial_piecewise(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[-1, -0.5, -0.25], [0, 0.25, 2]])) # This is the approximation of the sigmoid function by using a piecewise function: # f(x) = (0 if x<-0.5), (x+0.5 if -0.5<=x<0.5), (1 if x>=0.5) z1 = tfe.polynomial_piecewise( x, (-0.5, 0.5), ((0,), (0.5, 1), (1,)), # use tuple because list is not hashable ) # Or, simply use the pre-defined sigmoid API which includes a different approximation z2 = tfe.sigmoid(x) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[0, 0, 0.25], [0.5, 0.75, 1]]), rtol=0.0, atol=0.01 ) result = sess.run(z2.reveal()) np.testing.assert_allclose( result, np.array([[0.33, 0.415, 0.4575], [0.5, 0.5425, 0.84]]), rtol=0.0, atol=0.01, )
def test_ppa_private_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable( tf.constant([[1, 2, 3], [4, 5, 6]]), share_type=BOOLEAN ) y = tfe.define_private_variable( tf.constant([[7, 8, 9], [10, 11, 12]]), share_type=BOOLEAN ) # Parallel prefix adder. It is simply an adder for boolean sharing. z1 = tfe.B_ppa(x, y, topology="sklansky") z2 = tfe.B_ppa(x, y, topology="kogge_stone") with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[8, 10, 12], [14, 16, 18]]), rtol=0.0, atol=0.01 ) result = sess.run(z2.reveal()) np.testing.assert_allclose( result, np.array([[8, 10, 12], [14, 16, 18]]), rtol=0.0, atol=0.01 )
def test_mul_AB_private_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable( np.array([[1, 2, 3], [4, 5, 6]]), share_type=ARITHMETIC, ) y = tfe.define_private_variable( tf.constant([[1, 0, 0], [0, 1, 0]]), apply_scaling=False, share_type=BOOLEAN, factory=prot.bool_factory, ) z = tfe.mul_AB(x, y) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z.reveal()) np.testing.assert_allclose( result, np.array([[1, 0, 0], [0, 5, 0]]), rtol=0.0, atol=0.01 )
def test_boolean_sharing(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable( tf.constant([[1, 2, 3], [4, 5, 6]]), share_type=BOOLEAN ) y = tfe.define_private_variable( tf.constant([[7, 8, 9], [10, 11, 12]]), share_type=BOOLEAN ) z1 = tfe.B_xor(x, y) z2 = tfe.B_and(x, y) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[6, 10, 10], [14, 14, 10]]), rtol=0.0, atol=0.01 ) result = sess.run(z2.reveal()) np.testing.assert_allclose( result, np.array([[1, 0, 1], [0, 1, 4]]), rtol=0.0, atol=0.01 )
def test_not_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable( tf.constant([[1, 2, 3], [4, 5, 6]]), share_type=BOOLEAN, apply_scaling=False ) y = tfe.define_private_variable( tf.constant([[1, 0, 0], [0, 1, 0]]), apply_scaling=False, share_type=BOOLEAN, factory=prot.bool_factory, ) z1 = ~x z2 = ~y with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[-2, -3, -4], [-5, -6, -7]]), rtol=0.0, atol=0.01 ) result = sess.run(z2.reveal()) np.testing.assert_allclose( result, np.array([[0, 1, 1], [1, 0, 1]]), rtol=0.0, atol=0.01 )
def test_read_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): return tf.reshape(tf.range(0, 8), [4, 2]) # define inputs x = tfe.define_private_input("input-provider", provide_input) _, tmp_filename = tempfile.mkstemp() write_op = x.write(tmp_filename) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result sess.run(write_op) x = tfe.read(tmp_filename, batch_size=5, n_columns=2) with tfe.Session() as sess: result = sess.run(x.reveal()) np.testing.assert_allclose( result, np.array(list(range(0, 8)) + [0, 1]).reshape([5, 2]), rtol=0.0, atol=0.01, ) os.remove(tmp_filename)
def test_write_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) def provide_input(): # normal TensorFlow operations can be run locally # as part of defining a private input, in this # case on the machine of the input provider return tf.ones(shape=(2, 2)) * 1.3 # define inputs x = tfe.define_private_input("input-provider", provide_input) _, tmp_filename = tempfile.mkstemp() write_op = x.write(tmp_filename) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result sess.run(write_op) os.remove(tmp_filename)
def test_reduce_sum(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[1, 2, 3], [4, 5, 6]])) y = tfe.define_constant(np.array([[1, 2, 3], [4, 5, 6]])) z1 = x.reduce_sum(axis=1, keepdims=True) z2 = tfe.reduce_sum(y, axis=0, keepdims=False) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose(result, np.array([[6], [15]]), rtol=0.0, atol=0.01) result = sess.run(z2) np.testing.assert_allclose(result, np.array([5, 7, 9]), rtol=0.0, atol=0.01)
def test_pow_private(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[1, 2, 3], [4, 5, 6]])) y = x**2 z = x**3 with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(y.reveal()) np.testing.assert_allclose(result, np.array([[1, 4, 9], [16, 25, 36]]), rtol=0.0, atol=0.01) result = sess.run(z.reveal()) np.testing.assert_allclose(result, np.array([[1, 8, 27], [64, 125, 216]]), rtol=0.0, atol=0.01)
def test_rshift_private(): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[1, 2, 3], [4, 5, 6]]), share_type=BOOLEAN) y = tfe.define_private_variable(tf.constant([[-1, -2, -3], [-4, 5, 6]]), share_type=BOOLEAN, apply_scaling=False) z = x >> 1 w = y >> 1 s = y.logical_rshift(1) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z.reveal()) close(result, np.array( [[0.5, 1, 1.5], [2, 2.5, 3]])) # NOTE: x is scaled and treated as fixed-point number result = sess.run(w.reveal()) close(result, np.array([[-1, -1, -2], [-2, 2, 3]])) result = sess.run(s.reveal()) close( result, np.array([[(-1 & ((1 << prot.nbits) - 1)) >> 1, (-2 & ((1 << prot.nbits) - 1)) >> 1, (-3 & ((1 << prot.nbits) - 1)) >> 1], [(-4 & ((1 << prot.nbits) - 1)) >> 1, 2, 3]])) print("test_rshift_private succeeds")
def main(server): num_rows = 7000 num_features = 32 num_epoch = 5 batch_size = 200 num_batches = (num_rows // batch_size) * num_epoch #who shall receive the output model_owner = ModelOwner('alice') data_schema0 = DataSchema([tf.float64] * 16, [0.0] * 16) data_schema1 = DataSchema([tf.int64] + [tf.float64] * 16, [0] + [0.0] * 16) data_owner_0 = DataOwner('alice', 'aliceTrainFile.csv', data_schema0, batch_size=batch_size) data_owner_1 = DataOwner('bob', 'bobTrainFileWithLabel.csv', data_schema1, batch_size=batch_size) tfe.set_protocol( tfe.protocol.Pond( tfe.get_config().get_player(data_owner_0.player_name), tfe.get_config().get_player(data_owner_1.player_name))) x_train_0 = tfe.define_private_input(data_owner_0.player_name, data_owner_0.provide_data) x_train_1 = tfe.define_private_input(data_owner_1.player_name, data_owner_1.provide_data) y_train = tfe.gather(x_train_1, 0, axis=1) y_train = tfe.reshape(y_train, [batch_size, 1]) #Remove bob's first column (which is label) x_train_1 = tfe.strided_slice(x_train_1, [0, 1], [x_train_1.shape[0], x_train_1.shape[1]], [1, 1]) x_train = tfe.concat([x_train_0, x_train_1], axis=1) model = LogisticRegression(num_features) reveal_weights_op = model_owner.receive_weights(model.weights) with tfe.Session() as sess: sess.run(tfe.global_variables_initializer(), tag='init') start_time = time.time() model.fit(sess, x_train, y_train, num_batches) end_time = time.time() # TODO(Morten) # each evaluation results in nodes for a forward pass being added to the graph; # maybe there's some way to avoid this, even if it means only if the shapes match model.evaluate(sess, x_train, y_train, data_owner_0) model.evaluate(sess, x_train, y_train, data_owner_1) print(sess.run(reveal_weights_op, tag='reveal'), ((end_time - start_time) * 1000))
def test_simple_lr_model(): tf.reset_default_graph() import time start = time.time() prot = ABY3() tfe.set_protocol(prot) # define inputs x_raw = tf.random.uniform(minval=-0.5, maxval=0.5, shape=[99, 10], seed=1000) x = tfe.define_private_variable(x_raw, name="x") y_raw = tf.cast(tf.reduce_mean(x_raw, axis=1, keepdims=True) > 0, dtype=tf.float32) y = tfe.define_private_variable(y_raw, name="y") w = tfe.define_private_variable(tf.random_uniform([10, 1], -0.01, 0.01, seed=100), name="w") b = tfe.define_private_variable(tf.zeros([1]), name="b") learning_rate = 0.01 with tf.name_scope("forward"): out = tfe.matmul(x, w) + b y_hat = tfe.sigmoid(out) with tf.name_scope("loss-grad"): dy = y_hat - y batch_size = x.shape.as_list()[0] with tf.name_scope("backward"): dw = tfe.matmul(tfe.transpose(x), dy) / batch_size db = tfe.reduce_sum(dy, axis=0) / batch_size upd1 = dw * learning_rate upd2 = db * learning_rate assign_ops = [tfe.assign(w, w - upd1), tfe.assign(b, b - upd2)] with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) for i in range(1): sess.run(assign_ops) print(sess.run(w.reveal())) end = time.time() print("Elapsed time: {} seconds".format(end - start))