def __test_reduce_op(op_functor, msg, xa, axis=None):
# max/mean/sum/...
init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
sess.run(init)
###########
# print("=========================== ", msg, " 1 beg")
# xc = op_functor(xa, axis=axis)
# xcc = sess.run(xc)
# print(xcc)
# print("=========================== ", msg, " 1 end")
# axis=None,keep_dims=False,name=None,reduction_indices=None
print("=========================== ", msg, "BEGIN")
xc = op_functor(xa, axis=axis)
#xd = op_functor(xa, axis=axis)
#xe = op_functor(xa, axis=axis)
xee = sess.run([xa, xc])
result = []
# to support both native TF OP and Rosetta OP test
if 'latticex.rosetta' in sys.modules:
import latticex.rosetta as rtt
reveal_input = sess.run(rtt.SecureReveal(xee[0]))
reveal_output = sess.run(rtt.SecureReveal(xee[1]))
print("revealed input:", reveal_input)
print("revealed output:", reveal_output)
result = np.array(reveal_output, dtype=np.float)
else:
print("input:", xee[0])
print("output :", xee[1])
result = np.array(xee[1], dtype=np.float)
print("=========================== ", msg, " END")
return result
def run(self):
with graph.as_default():
# print("thread:", self.tid, self.name, self.sess)
# for ii in range(2):
pred_Y = tf.sigmoid(tf.matmul(X, W) + b)
reaveal_Y = rtt.SecureReveal(pred_Y)
res = sess.run(reaveal_Y)
def bin_op_rh_const_test(protocol, task_id, tf_op, x_init, y_init, expect_val):
Result = True
local_g = tf.Graph()
with local_g.as_default():
X = tf.Variable(x_init)
Z = tf_op(X, y_init)
rv_Z = rtt.SecureReveal(Z)
init = tf.compat.v1.global_variables_initializer()
try:
rtt.activate(protocol, task_id=task_id)
config = tf.ConfigProto(inter_op_parallelism_threads=16,
intra_op_parallelism_threads=16)
with tf.Session(task_id=task_id, config=config) as sess:
sess.run(init)
real_Z = sess.run(rv_Z)
res = check_mpc_results(real_Z, expect_val)
if (res == False):
Result = False
rtt.deactivate(task_id=task_id)
except Exception as e:
print(str(e))
Result = False
return Result
def test_private_input_op(name):
in1 = rtt.PrivateInput(tf.Variable([1, 2]), data_owner=0)
in2 = rtt.PrivateInput(tf.Variable([2, 3]), data_owner=1)
ret = rtt.SecureReveal(tf.multiply(in1, in2)) # expect [2,6]
result = create_run_session(ret)
print("private_input and result: ", result, ", expect: [2,6]")
print("test_private_input ok.")
def classification_loss(logit, label):
# loss = tf.reduce_mean(
# tf.nn.softmax_cross_entropy_with_logits_v2(labels=label, logits=logit))
softmax_logits = tf.nn.softmax(logit)
return None, rtt.SecureReveal(softmax_logits)
prediction = tf.equal(tf.argmax(logit, -1), tf.argmax(label, -1))
accuracy = tf.reduce_mean(tf.cast(prediction, tf.float32))
return None, accuracy
def test_snn_pow(lh_is_const=False, rh_is_const=True):
print("---- test snn pow ----")
in1 = tf.Variable([1, 2], name="in1")
# in2 = tf.constant(["1","1"], name="in2") # not support now
# in2 = tf.constant(["1"], name="in2") # not support now
in2 = tf.constant(1, name="in2")
c = tf.pow(in1, in2) #, lh_is_const=False, rh_is_const=True)
rc = rtt.SecureReveal(c)
#ret = rtt.secure_reveal(c)
## ret = rtt.secure_to_tf(reveal_c, dtype=tf.float64)
result = create_run_session(rc)
print("pow result: ", result, ", math.pow(x, 2): ", 2.0, 4.0)
print("----- test_pow (OK) -----")
def test_accumutive_op(opfn, N=2):
print("---- test snn add_n ----")
elem = ["1", "2", "3"]
inputs = []
for i in range(N):
inputs.append(elem)
c = opfn(inputs)
rc = rtt.SecureReveal(c)
#ret = rtt.secure_reveal(c)
## ret = rtt.secure_to_tf(reveal_c, dtype=tf.float64)
result = create_run_session(rc)
print("add result: ", result, ", math.add_n([1,2,3],....): ", 2, 4, 6)
print("----- test_add (OK) -----")
def test_max_grad(X, axis, 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 max grad
# ===========================
print("===========================")
print("# run mpc max(X) grad, axis=", axis)
mpc_Y = cb.SecureMax(X, axis=axis)
print(sess.run(cb.SecureReveal(mpc_Y)))
mpc_g = tf.gradients(mpc_Y, [common.get_var_from_rtt_tensor(X)])
print(sess.run(mpc_g))
print("===========================")
# ===========================
# check mpcmax grads value
# ===========================
mpc_out_g = []
for i in range(len(mpc_g)):
print("---------- Reveal mpcmax grad ------------")
mpc_out_g.append(sess.run(cb.SecureReveal(mpc_g[i])))
print(mpc_out_g)
print("------------------------------------------")
global res_flag
res_flag = res_flag and common.check_mpc_op_grads(out_g, mpc_out_g)
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)
def test_sigmoidcrocssentropy_grad(logits, labels, out_g, protocol="Helix"):
rst.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 SCE grad:
# ===========================
print("===========================")
print("run mpc SCE(X,Y) grad")
Z_mpc = rst.secure_sigmoid_cross_entropy_with_logits(logits=logits,
labels=labels)
mpc_g = tf.gradients(Z_mpc, [
common.get_var_from_rtt_tensor(logits),
common.get_var_from_rtt_tensor(labels)
])
print(sess.run(mpc_g))
print("===========================")
# ===========================
# check mpcSCE grads value
# ===========================
mpc_out_g = []
for i in range(len(mpc_g)):
print("---------- Reveal mpcSCE grad ------------")
mpc_out_g.append(sess.run(rst.SecureReveal(mpc_g[i])))
print(mpc_out_g)
print("------------------------------------------")
global res_flag
res_flag = res_flag and common.check_mpc_op_grads(out_g, mpc_out_g)
def test_protocol(protocol_name="SecureNN"):
rst.activate(protocol_name)
PRI_LOGITS = rst.private_input(0, np_a)
PRI_LABELS = rst.private_input(1, np_b)
PRI_logits = tf.Variable(PRI_LOGITS, dtype=tf.string)
PRI_labels = tf.Variable(PRI_LABELS, dtype=tf.string)
init = tf.compat.v1.global_variables_initializer()
PRI_sess = tf.compat.v1.Session()
PRI_sess.run(init)
start_t = time.time()
result_mpc = rst.secure_sigmoid_cross_entropy_with_logits(
logits=PRI_logits, labels=PRI_labels)
PRI_sess.run(result_mpc)
end_t = time.time()
reveal_op = rst.SecureReveal(result_mpc)
xcc = PRI_sess.run(reveal_op)
print(xcc)
print("{} elapsed: {} ".format(protocol_name, end_t - start_t))
rst.deactivate()
#
init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
sess.run(init)
print("input xa:", sess.run(xa))
###########
print("=========================== tf op log1p 1")
xc = tf.log1p(xa)
xcc = sess.run(xc)
print("=========================== tf op log1p 2")
print("TF Log1p:", xcc)
import latticex.rosetta as rtt
#rtt.py_protocol_handler.set_loglevel(0)
rtt.activate("SecureNN")
xb = tf.Variable([[1.892, 2], [3, 4.43], [.0091, .3]])
init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
sess.run(init)
print("=========================== mpc op log1p 1")
xc = rtt.SecureReveal(rtt.SecureLog1p(xb))
xcc = sess.run(xc)
print("MPC revealed Log1p:", xcc)
print("=========================== mpc op log1p 2")
###########
for n in nodes:
if n != node:
rtt.send_msg(n, msgid, node + " to " + n)
for n in nodes:
if n != node:
msg = rtt.recv_msg(n, msgid, 2 * len(node) + 4)
print('get msg from ', n, " msg:", msg)
# Get private data from Alice (input x), Bob (input y)
w = tf.Variable(rtt.private_input(0, [[1, 2], [2, 3]]))
x = tf.Variable(rtt.private_input(1, [[1, 2], [2, 3]]))
y = tf.Variable(rtt.private_input(2, [[1, 2], [2, 3]]))
z = tf.Variable(rtt.private_input('p9', [[1, 2], [2, 3]]))
# Define matmul operation
res = tf.matmul(tf.matmul(w, x), tf.matmul(y, z))
# Start execution
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
res = sess.run(res)
# Get the result of Rosetta matmul
# ret: [[b'14.000000' b'20.000000'] [b'20.000000' b'29.000000']]
receivers = (0, 1, 'p9', 2)
receivers = 0b011
receivers = None
print('matmul:', sess.run(rtt.SecureReveal(res, receive_party=receivers)))
rtt.deactivate()
import tensorflow as tf
import sys
import numpy as np
np.set_printoptions(suppress=True)
protocol = "Helix"
rtt.activate(protocol)
x = np.array([[2.0, 2.1], [2.2, 2.3]])
y = np.array([[1, 2.0], [1, 3.0]])
z = np.array([[[0, 1, 2.4, 0, 1, 2.9]], [[0.3, 1, 2, 0, 1.2, 2]]])
input0 = rtt.private_input(0, x)
input1 = rtt.private_input(1, y)
input2 = rtt.private_input(2, z)
print('input0:', type(input0), input0)
print('input1:', type(input1), input1)
print('input2:', type(input2), input2)
i0 = tf.Variable(input0)
i1 = tf.Variable(input1)
i2 = tf.Variable(input2)
ii = rtt.SecureMatMul(i0, i1)
ir_matmul = rtt.SecureReveal(ii)
init = tf.global_variables_initializer()
with tf.Session() as sess1:
sess1.run(init)
print('rosetta matmul:', sess1.run(ir_matmul))
np.set_printoptions(suppress=True)
protocol = "Helix"
rtt.activate(protocol)
patyid = str(rtt.get_party_id())
rtt.set_backend_loglevel(0)
rtt.set_backend_logfile("/tmp/wo-men-dou-shi-hao-hai-zi.log" + patyid)
print("rtt.get_protocol_name():", rtt.get_protocol_name())
X = tf.Variable([[1., 1.], [2., 1.]])
Y = tf.Variable([[1., 3.], [1., 1.]])
z = rtt.SecureMatMul(X, Y)
zr = rtt.SecureReveal(z)
init = tf.global_variables_initializer()
with tf.Session() as sess1:
sess1.run(init)
print('zzzzzr:', sess1.run(zr))
rtt.set_backend_loglevel(3)
rtt.set_backend_logfile("/tmp/wo-men-dou-shi-hao-hai-zi-ma.log" + patyid)
with tf.Session() as sess1:
sess1.run(init)
print('zzzzzr:', sess1.run(zr))
exit(0)
def call_nn(opname, a, b=None):
if opname in nn_fns:
if b:
return rtt.SecureReveal(nn_fns[opname](a, b))
else:
return rtt.SecureReveal(nn_fns[opname](a))
floor_expected = np.floor_divide(num_a, num_b)
a1 = X / Y
floor1 = tf.floordiv(X, Y)
a2 = X / CY
floor2 = tf.floordiv(X, CY)
# in this case, it is hard to get the correct result from big shared right!
a3 = CX / Y
floor3 = tf.floordiv(CX, Y)
a4 = CX / CY
floor4 = tf.floordiv(CX, CY)
r_a1 = rtt.SecureReveal([a1, floor1])
r_a2 = rtt.SecureReveal([a2, floor2])
r_a3 = rtt.SecureReveal([a3, floor3])
r_a4 = rtt.SecureReveal([a4, floor4])
init = tf.global_variables_initializer()
with tf.Session() as sess1:
sess1.run(init)
rr_a1 = sess1.run(r_a1)
rr_a2 = sess1.run(r_a2)
rr_a3 = sess1.run(r_a3)
rr_a4 = sess1.run(r_a4)
print("expected:", expected)
print("floor expected:", floor_expected)
# 1-d
###############################
print('=================1-d=========================')
x = [1, 8, 3]
print(x)
a = tf.Variable(x, dtype=tf.float64)
aa = tf.reduce_mean(a)
a0 = tf.reduce_mean(a, axis=0)
aa_k = tf.reduce_mean(a, keepdims=True)
a0_k = tf.reduce_mean(a, axis=0, keepdims=True)
with tf.Session() as sess:
sess.run(tf.compat.v1.global_variables_initializer())
res_aa = sess.run(rtt.SecureReveal(aa))
print('tf tf.reduce_mean aa:\n', res_aa)
res_a0 = sess.run(rtt.SecureReveal(a0))
print('tf tf.reduce_mean a0:\n', res_a0)
print('====================================================')
res_aa_k = sess.run(rtt.SecureReveal(aa_k))
print('tf tf.reduce_mean aa_k:\n', res_aa_k)
res_a0_k = sess.run(rtt.SecureReveal(a0_k))
print('tf tf.reduce_mean a0_k:\n', res_a0_k)
print('====================================================')
###############################
# 2-d
###############################
print('=================2-d=========================')
def call_reduce(opname, a, axis=None):
if opname in reduce_fns:
if axis:
return rtt.SecureReveal(reduce_fns[opname](a, axis=axis))
else:
return rtt.SecureReveal(reduce_fns[opname](a))
import tensorflow as tf
import latticex.rosetta as rtt
print("inputs: ", [1.0, 0.0, 0, 0, -0.0, 0.0001, -0.000001, -0.000125, -1])
inputs = tf.Variable([1.0, 0.0, 0, 0, -0.0, 0.0001, -0.000001, -0.000125, -1], name="input")
relu_prime = rtt.SecureReveal(rtt.SecureReluPrime(inputs))
init = tf.compat.v1.global_variables_initializer()
with tf.compat.v1.Session() as sess:
sess.run(init)
ret = sess.run(relu_prime)
print("relu-prime: {}".format(ret))
print("ok")
print(pred_Y)
# loss
loss = tf.square(Y - pred_Y)
loss = tf.reduce_mean(loss)
print(loss)
# optimizer
train = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
print(train)
init = tf.global_variables_initializer()
print(init)
# ########### for test, reveal
reveal_W = rtt.SecureReveal(W)
reveal_b = rtt.SecureReveal(b)
reveal_Y = rtt.SecureReveal(pred_Y)
# ########### for test, reveal
# #############################################################
# save to csv for comparing, for debug
if mpc_player_id == 0:
scriptname = os.path.basename(sys.argv[0]).split(".")[0]
csvprefix = "./log/" + scriptname
os.makedirs(csvprefix, exist_ok=True)
csvprefix = csvprefix + "/rtt"
# #############################################################
with tf.Session() as sess:
sess.run(init)
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)
print('rosetta mul:', sess1.run(ir_mul))
)
xb = tf.Variable(
[
[2, 20],
[-2, -20],
[4, -40]
]
)
init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
sess.run(init)
print("=========================== mpc op floordiv 1")
xc = rtt.SecureFloorDiv(xa, xb)
xcc = sess.run(rtt.SecureReveal(xc))
print(xcc)
print("=========================== mpc op floordiv 2")
print("=========================== MPC op divide 1")
xc = rtt.SecureDivide(xa, xb)
xcc = sess.run(rtt.SecureReveal(xc))
print(xcc)
print("=========================== MPC op divide 2")
print("=========================== mpc op high-precision log 1")
xc = rtt.SecureHLog(xa)
xcc = sess.run(rtt.SecureReveal(xc))
print("=========================== mpc op high-precision log 2")
rtt_case = TEST_CASES[case_id]
rtt_res_1 = TEST_CASES[case_id]
cipher_var_a = tf.Variable(rtt.private_input(0, rtt_case["input"][0]))
cipher_var_b = tf.Variable(rtt.private_input(1, rtt_case["input"][1]))
cipher_var_c = cipher_var_a / cipher_var_b
cipher_var_c_1 = rtt.SecureReciprocaldiv(cipher_var_a, cipher_var_b)
init = tf.compat.v1.global_variables_initializer()
with tf.compat.v1.Session() as rtt_sess:
rtt_sess.run(init)
rtt_res = rtt_sess.run(cipher_var_c)
rtt_res_1 = rtt_sess.run(cipher_var_c_1)
# print("local cipher res:", rtt_res)
# reveal to get the plaintext result
rtt_res = rtt_sess.run(rtt.SecureReveal(rtt_res))
rtt_res_1 = rtt_sess.run(rtt.SecureReveal(rtt_res_1))
rtt_case["rtt_res"] = np.array(rtt_res, dtype=np.float)
rtt_case["rtt_res_1"] = np.array(rtt_res_1, dtype=np.float)
print("first case ciphertext result:---------------------")
print("div:")
print(rtt_case["rtt_res"])
print("reci_div:")
print(rtt_case["rtt_res_1"])
print("--------------------------------------------------")
#### 2.2 second case
case_id += 1
rtt_case = TEST_CASES[case_id]
rtt_res_1 = TEST_CASES[case_id]
init = tf.compat.v1.global_variables_initializer()
sess = tf.compat.v1.Session()
sess.run(init)
# print("X:\n", sess.run(xa * 2))
###########
print("=========================== tf op sigmoid 1")
xc = tf.sigmoid(ret)
# xc = tf.nn.sigmoid(ret)
xcc = sess.run(xc)
print("=========================== tf op sigmoid 2")
print(xcc)
# print("=========================== mpc op sigmoid 1")
start = time.time()
xc = rtt.SecureReveal(tf.sigmoid(ret))
xcc = sess.run(xc)
print("secure_sigmoid cost: ", time.time() - start)
# print("=========================== mpc op sigmoid 2")
print(xcc)
# print("=========================== mpc op sigmoidV2 1")
start = time.time()
xc = rtt.SecureReveal(rtt.SecureSigmoidV2(ret))
xcc = sess.run(xc)
print("secure_sigmoid_6Pieces_Python cost: ", time.time() - start)
# print("=========================== mpc op sigmoid 2")
print(xcc)
# print("=========================== mpc op sigmoidV2 1")
start = time.time()
import tensorflow as tf
import latticex.rosetta as rtt
rtt.activate("SecureNN")
X = tf.Variable([1.0, 0.0, 0.0, 1.0], name='x')
# Y = tf.Variable([1.0, 0.0, 1.0, 0.0], name='y')
Z = tf.logical_not(X)
Z2 = tf.logical_not(tf.cast(X, tf.bool))
# try:
# train_step = tf.train.GradientDescentOptimizer(0.01).minimize(Z)
# print("Pass")
# except Exception:
# print("Fail")
reveal_Z = rtt.SecureReveal(Z)
reveal_Z2 = rtt.SecureReveal(Z2)
try:
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print(sess.run(Z))
print(sess.run(reveal_Z))
print(sess.run(Z2))
print(sess.run(reveal_Z2))
print("Pass")
except Exception:
print("Fail")
next_x = iter_x.get_next()
next_y = iter_y.get_next()
print("--------------------------------")
print("create get next.")
print(next_x)
print(next_y)
print("--------------------------------")
# Define matmul operation
res = tf.multiply(next_x, next_y)
print("create res=next_x * next_y")
# Start execution
try:
with tf.Session() as sess:
print("to run session...")
sess.run(tf.global_variables_initializer())
print("global initialized and to make iterator initialization....")
sess.run([iter_x.initializer, iter_y.initializer])
print('matmul:', sess.run(rtt.SecureReveal(res)))
print("Pass")
except:
print("Fail")
rtt.deactivate()
Writer = tf.summary.FileWriter("log/iter", tf.get_default_graph())
Writer.close()
def call_binary(opname, a, b, is_reveal):
if opname in binary_fns:
if is_reveal:
return rtt.SecureReveal(binary_fns[opname](a, b))
else:
return binary_fns[opname](a, b)
loss = tf.square(Y - pred_Y)
loss = tf.reduce_mean(loss)
print(loss)
# optimizer
train = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
print(train)
# save
saver = tf.train.Saver(var_list=None, max_to_keep=5, name='v2')
os.makedirs("./log/ckpt" + str(mpc_player_id), exist_ok=True)
# init
init = tf.global_variables_initializer()
print(init)
reveal_Y = rtt.SecureReveal(pred_Y)
with tf.Session() as sess:
sess.run(init)
xW, xb = sess.run([W, b])
print("init weight:{} \nbias:{}".format(xW, xb))
# train
BATCHES = math.ceil(len(real_X) / BATCH_SIZE)
for e in range(EPOCHES):
for i in range(BATCHES):
bX = real_X[(i * BATCH_SIZE):(i + 1) * BATCH_SIZE]
bY = real_Y[(i * BATCH_SIZE):(i + 1) * BATCH_SIZE]
sess.run(train, feed_dict={X: bX, Y: bY})
j = e * BATCHES + i
def call_unary(opname, b):
if opname in unary_fns:
return rtt.SecureReveal(unary_fns[opname](b))
