def test_binarize(self) -> None:
prime_factory = native_factory(tf.int32, 1001)
x = prime_factory.tensor(
tf.constant(
[
3, # == 3
-1, # == p-1 == max
0 # min
],
shape=[3],
dtype=np.int32))
y = x.bits()
expected = np.array([
[1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
]).reshape([3, 10])
with tf.Session() as sess:
actual = sess.run(y.value)
np.testing.assert_array_equal(actual, expected)
def __init__(
self,
server_0: Optional[Player] = None,
server_1: Optional[Player] = None,
server_2: Optional[Player] = None,
tensor_factory: Optional[AbstractFactory] = None,
prime_factory: Optional[AbstractFactory] = None,
odd_factory: Optional[AbstractFactory] = None,
**kwargs,
) -> None:
server_0 = server_0 or get_config().get_player("server0")
server_1 = server_1 or get_config().get_player("server1")
server_2 = (server_2 or get_config().get_player("server2")
or get_config().get_player("crypto-producer"))
assert server_0 is not None
assert server_1 is not None
assert server_2 is not None
super(SecureNN, self).__init__(
server_0=server_0,
server_1=server_1,
triple_source=server_2,
tensor_factory=tensor_factory,
**kwargs,
)
self.server_2 = server_2
if odd_factory is None:
if self.tensor_factory is int64factory:
odd_factory = oddint64_factory
else:
odd_factory = self.tensor_factory
if prime_factory is None:
prime = 107
assert prime > math.ceil(math.log2(self.tensor_factory.modulus))
prime_factory = native_factory(self.tensor_factory.native_type,
prime)
self.prime_factory = prime_factory
self.odd_factory = odd_factory
assert self.prime_factory.native_type == self.tensor_factory.native_type
assert self.odd_factory.native_type == self.tensor_factory.native_type
def set_up_indexing(self):
m = 2**31
prime_factory = native_factory(tf.int32, m)
self.np_fix1d = np.arange(24)
self.np_fix2d = self.np_fix1d.reshape(8, 3)
self.np_fix3d = self.np_fix1d.reshape(2, 4, 3)
self.np_fix4d = self.np_fix1d.reshape(2, 2, 2, 3)
self.prime_fix1d = prime_factory.tensor(self.np_fix1d)
self.prime_fix2d = prime_factory.tensor(self.np_fix2d)
self.prime_fix3d = prime_factory.tensor(self.np_fix3d)
self.prime_fix4d = prime_factory.tensor(self.np_fix4d)
self.np_fixtures = [
getattr(self, "np_fix{}d".format(i)) for i in range(1, 5)
]
self.prime_fixtures = [
getattr(self, "prime_fix{}d".format(i)) for i in range(1, 5)
]
def test_arithmetic(self) -> None:
prime_factory = native_factory(tf.int32, 2**16)
x = prime_factory.tensor(tf.constant([2**16, 2**16 + 1]))
y = prime_factory.tensor(tf.constant([2**16 + 2, 2]))
with tf.Session() as sess:
z = (x * y).value
z0 = sess.run(z)
np.testing.assert_array_equal(z0, np.array([0, 2]))
z = (x + y).value
z1 = sess.run(z)
np.testing.assert_array_equal(z1, np.array([2, 3]))
z = (x - y).value
z2 = sess.run(z)
np.testing.assert_array_equal(z2, np.array([65534, 65535]))
def test_prime(self):
self._core_test_sharing(native_factory(tf.int32, 67))