def test_softmax_with_cross_entropy(self): data_1 = np.array([1, 1]).astype('float32') data_2 = np.array([1, 0]).astype('float32') expected_out = np.array([0.5, 0.5]).astype('float32') #print("input data_1: {} \n".format(data_1)) data_1_shares = aby3.make_shares(data_1) data_2_shares = aby3.make_shares(data_2) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) data_2_all3shares = np.array( [aby3.get_aby3_shares(data_2_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.softmax_with_cross_entropy, data_1=data_1_all3shares, data_2=data_2_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) #print("revealed: {} \n".format(revealed)) #print("expected: {} \n".format(expected_out)) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def test_dyanmic_gru_op(self): data = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [-1.0, -2.0, -3.0]]).astype('float32') data_share = aby3.make_shares(data) data_all3shares = np.array( [aby3.get_aby3_shares(data_share, i) for i in range(3)]) weight = np.array([[0.0, 0.0, 0.0]]).astype('float32') weight_share = aby3.make_shares(weight) weight_all3shares = np.array( [aby3.get_aby3_shares(weight_share, i) for i in range(3)]) return_results = Manager().list() return_results_cheb = Manager().list() expect_results = Manager().list() ret = self.multi_party_run(target=self.dyanmic_gru_op, data=data, data_share=data_all3shares, weight=weight, weight_share=weight_all3shares, return_results=return_results, return_results_cheb=return_results_cheb, expect_results=expect_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) revealed_cheb = aby3.reconstruct(np.array(return_results_cheb)) print("expected:", expect_results[0]) print("reveal: ", revealed) print("reveal_cheb: ", revealed_cheb) self.assertTrue(np.allclose(revealed, expect_results[0], atol=1e-1 * 5)) self.assertTrue( np.allclose(revealed_cheb, expect_results[0], atol=1e-1 * 5))
def test_diff_dim_mul_mid(self): data_1 = np.full((3, 4, 2), fill_value=2) data_2 = np.full(( 3, 4, ), fill_value=1.5) #data_2 = np.ones((4,)) # print(data_1) # print(data_2) data_1_shares = aby3.make_shares(data_1) data_2_shares = aby3.make_shares(data_2) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) data_2_all3shares = np.array( [aby3.get_aby3_shares(data_2_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.diff_dim_mul_mid, data_1=data_1_all3shares, data_2=data_2_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) expected_out = np.array([[[3, 3], [3, 3], [3, 3], [3, 3]], [[3, 3], [3, 3], [3, 3], [3, 3]], [[3, 3], [3, 3], [3, 3], [3, 3]]]) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def test_embedding_op(self): data = np.array([[1, 0, 0], [0, 1, 0]]) data_normal = np.array([0, 1]).astype('int64') w_data = np.array([[1, 2], [2, 3], [3, 4]]) # data = self.gen_one_hot(data_normal, w_data.shape[0]).astype('int64') data_share = aby3.make_shares(np.array(data)) data_all3shares = np.array([aby3.get_aby3_shares(data_share, i) for i in range(3)]) w_data_share = aby3.make_shares(w_data) w_data_all3shares = np.array([aby3.get_aby3_shares(w_data_share, i) for i in range(3)]) return_results = Manager().list() expect_results = Manager().list() ret = self.multi_party_run(target=self.embedding_op, data=data, data_normal=data_normal, w_data=w_data, data_share=data_all3shares, w_data_share=w_data_all3shares, return_results=return_results, expect_results=expect_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) # print("reveal: ", revealed) self.assertTrue(np.allclose(revealed, expect_results[0], atol=1e-4))
def encrypted_mnist_labels(): """ label reader """ for instance in test_reader(): yield aby3.make_shares( np.array(1) if instance[1] == 0 else np.array(0))
def dummy_share_reader(self): """ Dummy share_reader for share_reader in aby3.save_aby3_shares() :return: """ test_data = np.arange(1, 10).reshape((3, 3)).astype(np.float32) yield aby3.make_shares(test_data)
def test_reconstruct(self): num_arr = np.arange(0, 4).reshape((2, 2)).astype(np.float32) shares = aby3.make_shares(num_arr) all_3shares = np.array( [aby3.get_aby3_shares(shares, i) for i in range(3)]) recon = aby3.reconstruct(all_3shares) self.assertTrue(np.allclose(num_arr, recon))
def test_pool2d(self): data_1 = np.array([[[[1, 2, 3, 4, 0, 100], [5, 6, 7, 8, 0, 100], [9, 10, 11, 12, 0, 200], [13, 14, 15, 16, 0, 200]]]]).astype('float32') expected_out = np.array([[[[6, 8, 100], [14, 16, 200]]]]).astype('float32') print("input data_1: {} \n".format(data_1)) data_1_shares = aby3.make_shares(data_1) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.pool2d, data_1=data_1_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) #print("revealed: {} \n".format(revealed)) #print("expected: {} \n".format(expected_out)) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-2))
def encrypt_label(): for instance in reader(): #print(np.array(instance[2])) if label_filepath != None: with open(label_filepath, 'a+') as f: f.write(str(instance[2][0]) + '\n') yield aby3.make_shares(np.array(instance[2]))
def encrypt_feature_idx(): for instance in reader(): global count feature_idx_ = np.array(instance[0]) feature_idx = np.eye(args.sparse_feature_number + 1)[feature_idx_.reshape(-1)] yield aby3.make_shares(feature_idx)
def test_elementwise_mul(self): data_1 = np.full(shape=(4), fill_value=2) data_2 = np.full(shape=(4), fill_value=3) data_1_shares = aby3.make_shares(data_1) data_2_shares = aby3.make_shares(data_2) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) data_2_all3shares = np.array( [aby3.get_aby3_shares(data_2_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.elementwise_mul, data_1=data_1_all3shares, data_2=data_2_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) expected_out = np.array([[6, 6, 6, 6]]) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def test_square_error_cost(self): data_1 = np.arange(0, 4).reshape((2, 2)) data_2 = np.full(shape=(2, 2), fill_value=2) data_1_shares = aby3.make_shares(data_1) data_2_shares = aby3.make_shares(data_2) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) data_2_all3shares = np.array( [aby3.get_aby3_shares(data_2_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.square_error_cost, data_1=data_1_all3shares, data_2=data_2_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) expected_out = np.array([[4, 1], [0, 1]]) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def save_cypher(cypher_file, vec): """ save cypertext to file """ shares = aby3.make_shares(vec) exts = ['.part0', '.part1', '.part2'] with open(cypher_file + exts[0], 'ab') as file0, \ open(cypher_file + exts[1], 'ab') as file1, \ open(cypher_file + exts[2], 'ab') as file2: files = [file0, file1, file2] for idx in six.moves.range(0, 3): # 3 parts share = aby3.get_aby3_shares(shares, idx) files[idx].write(share.tostring())
def test_relu(self): data_1 = np.arange(-3, 3).reshape((3, 2)) data_1_shares = aby3.make_shares(data_1) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.relu, data_1=data_1_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) expected_out = np.array([[0, 0], [0, 0], [1, 2]]) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def encrypted_mnist_labels(): """ label reader """ for instance in sample_reader(): if class_num == 2: label = np.array(1) if instance[1] == 0 else np.array(0) elif class_num == 10: label = np.eye(N=1, M=10, k=instance[1], dtype=float).reshape(10) else: raise ValueError( "class_num should be 2 or 10, but received {}.".format( class_num)) yield aby3.make_shares(label)
def test_mean(self): """ Test normal case. :return: """ data_1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) data_1_shares = aby3.make_shares(data_1) data_1_all3shares = np.array([aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.mean, data_1=data_1_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) expected_out = np.array([4.5]) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def test_square(self): """ Test normal case. :return: """ data_1 = np.full(shape=(2, 2), fill_value=3) data_1_shares = aby3.make_shares(data_1) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.square, data_1=data_1_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) expected_out = np.array([[9, 9], [9, 9]]) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-4))
def encrypted_mnist_labels(): """ label reader """ for instance in test_reader(): if class_num == 2: label = np.array(1) if instance[1] == 0 else np.array(0) with open(label_mnist_filepath, 'a+') as f: f.write(str(1 if instance[1] == 0 else 0) + '\n') elif class_num == 10: label = np.eye(N=1, M=10, k=instance[1], dtype=float).reshape(10) with open(label_mnist_filepath, 'a+') as f: f.write(str(instance[1]) + '\n') else: raise ValueError( "class_num should be 2 or 10, but received {}.".format( class_num)) yield aby3.make_shares(label)
def test_batch_norm(self): data_1 = np.array([[10, 10, 10], [50, 50, 50]]).astype('float32') expected_out = np.array([[-1, -1, -1], [1, 1, 1]]).astype('float32') # print("input data_1: {} \n".format(data_1)) data_1_shares = aby3.make_shares(data_1) data_1_all3shares = np.array( [aby3.get_aby3_shares(data_1_shares, i) for i in range(3)]) return_results = Manager().list() ret = self.multi_party_run(target=self.batch_norm, data_1=data_1_all3shares, return_results=return_results) self.assertEqual(ret[0], True) revealed = aby3.reconstruct(np.array(return_results)) # print("revealed: {} \n".format(revealed)) # print("expected: {} \n".format(expected_out)) self.assertTrue(np.allclose(revealed, expected_out, atol=1e-2))
def encrypt_sample(): """ encrypt sample """ for sample in sample_reader(): yield aby3.make_shares(sample)
def test_mpc_one_hot(self): data = np.array([0, 1]).astype('int64') ret = self.gen_one_hot(data, 3) mpc_one_hot = aby3.make_shares(ret)
def encrypt_feature_value(): for instance in reader(): #print(np.array(instance[1]).shape) yield aby3.make_shares(np.array(instance[1]))
def test_make_shares_3dim(self): num_arr = np.arange(0, 8).reshape((2, 2, 2)) shares = aby3.make_shares(num_arr) self.assertEqual((3, 2, 2, 2), shares.shape)
def func(): yield aby3.make_shares(data)
def encrypted_housing_labels(): """ label reader """ for instance in sample_reader(): yield aby3.make_shares(instance[1])
def encrypted_housing_features(): """ feature reader """ for instance in sample_reader(): yield aby3.make_shares(instance[0])
def encrypted_mnist_features(): """ feature reader """ for instance in test_reader(): yield aby3.make_shares(instance[0])
def func(): """ make shares """ yield aby3.make_shares(data)