def test_add_grad(X, Y, out_g, protocol="Helix"):
cb.activate(protocol)
global sess
if sess is not None:
sess.close()
# ===========================
# init global var
# ===========================
init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
sess.run(init)
# ===========================
# run mpc add grad
# ===========================
print("===========================")
print("run mpc add(X + Y) grad")
mpc_Z = cb.SecureAdd(X, Y)
mpc_g = tf.gradients(
mpc_Z,
[common.get_var_from_rtt_tensor(X),
common.get_var_from_rtt_tensor(Y)])
print(sess.run(mpc_g))
print("===========================")
# ===========================
# reveal value
# ===========================
mpc_out_g = []
for i in range(len(mpc_g)):
print("---------- Reveal mpcadd grad ------------")
mpc_out_g.append(sess.run(cb.SecureReveal(mpc_g[i])))
print(mpc_out_g)
print("------------------------------------------")
# ===========================
# check mpc add grads value
# ===========================
global res_flag
res_flag = common.check_mpc_op_grads(out_g, mpc_out_g)
protocol = "Helix"
rtt.activate(protocol)
input0 = rtt.private_input(0, 1.234)
input1 = rtt.private_input(1, 5.432)
input2 = rtt.private_input(2, 2.222)
print('input0:', input0)
print('input1:', input1)
print('input2:', input2)
i0 = tf.Variable(input0)
i1 = tf.Variable(input1)
i2 = tf.Variable(input2)
ii = rtt.SecureAdd(i0, i1)
ii = rtt.SecureAdd(ii, i2)
ir_add = rtt.SecureReveal(ii) # i0 + i1 + i2
init = tf.global_variables_initializer()
with tf.Session() as sess1:
sess1.run(init)
print('rosetta add:', sess1.run(ir_add))
ii = rtt.SecureMul(i0, i1)
ii = rtt.SecureMul(ii, i2)
ir_mul = rtt.SecureReveal(ii) # i0 * i1 * i2
init = tf.global_variables_initializer()
with tf.Session() as sess1:
sess1.run(init)
if __name__ == "__main__":
cmp_less = rtt.SecureLess(xa, xb)
test_cmp(cmp_less, 'less', test_count)
cmp_greater = rtt.SecureGreater(xa, xb)
test_cmp(cmp_greater, 'greater', test_count)
cmp_less_equal = rtt.SecureLessEqual(xa, xb)
test_cmp(cmp_less_equal, 'less-equal', test_count)
cmp_greater_equal = rtt.SecureGreaterEqual(xa, xb)
test_cmp(cmp_greater_equal, 'cmp-greater-equal', test_count)
add_op = rtt.SecureAdd(xa, xb)
test_cmp(add_op, 'cmp-equal', test_count)
sub_op = rtt.SecureSub(xa, xb)
test_cmp(sub_op, 'cmp-equal', test_count)
div_op = rtt.SecureDiv(xa, xb)
test_cmp(div_op, 'cmp-equal', test_count)
mul_op = rtt.SecureMul(xa, xb)
test_cmp(mul_op, 'cmp-equal', test_count)
cmp_equal = rtt.SecureEqual(xa, xb)
test_cmp(cmp_equal, 'cmp-equal', test_count)
rtt.deactivate()
share_a = tf.Variable(rtt.private_input(0, plain_a))
share_b = tf.Variable(rtt.private_input(1, plain_b))
const_v = tf.constant(const_v)
print(share_a)
print(share_b)
print(const_v)
# init
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
# ######### binary op
# Add
share_c = rtt.SecureAdd(share_a, share_b)
share_d = rtt.SecureAdd(share_c, share_a)
share_e = rtt.SecureAdd(share_d, share_b)
share_f = rtt.SecureAdd(share_e, const_v, rh_is_const=True)
reveal0 = rtt.SecureReveal(share_f)
with tf.Session() as sess:
sess.run(init)
print('SecureAdd:', sess.run(reveal0))
# Sub
share_c = rtt.SecureSub(share_a, share_b)
share_d = rtt.SecureSub(share_c, share_a)
share_e = rtt.SecureSub(share_d, share_b)
share_f = rtt.SecureSub(share_e, const_v, rh_is_const=True)
reveal0 = rtt.SecureReveal(share_f)
with tf.Session() as sess: