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 backward(self, x, dy, learning_rate=0.01):
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
assign_ops = [
tfe.assign(self.w, self.w - dw * learning_rate),
tfe.assign(self.b, self.b - db * learning_rate),
]
return assign_ops
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))
xp, yp = tfe.define_private_input('input-provider', lambda: gen_training_input(training_set_size, nb_feats, batch_size))
xp_test, yp_test = tfe.define_private_input('input-provider', lambda: gen_test_input(training_set_size, nb_feats, batch_size))
W = tfe.define_private_variable(tf.random_uniform([nb_feats, 1], -0.01, 0.01))
b = tfe.define_private_variable(tf.zeros([1]))
# Training model
out = tfe.matmul(xp, W) + b
pred = tfe.sigmoid(out)
# Due to missing log function approximation, we need to compute the cost in numpy
# cost = -tfe.sum(y * tfe.log(pred) + (1 - y) * tfe.log(1 - pred)) * (1/train_batch_size)
# Backprop
dc_dout = pred - yp
dW = tfe.matmul(tfe.transpose(xp), dc_dout) * (1 / batch_size)
db = tfe.reduce_sum(1. * dc_dout, axis=0) * (1 / batch_size)
ops = [
tfe.assign(W, W - dW * learning_rate),
tfe.assign(b, b - db * learning_rate)
]
# Testing model
pred_test = tfe.sigmoid(tfe.matmul(xp_test, W) + b)
def print_accuracy(pred_test_tf, y_test_tf: tf.Tensor) -> tf.Operation:
correct_prediction = tf.equal(tf.round(pred_test_tf), y_test_tf)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
return tf.print("Accuracy", accuracy)
def loss(self, y_hat, y, batch_size):
""" Compute L2 loss """
with tf.name_scope("loss"):
# loss_val = 0.5 * tfe.reduce_sum(tfe.square(y_hat - y)) / batch_size
loss_val = tfe.reduce_sum(tfe.square(y_hat - y)) / batch_size
return loss_val
