def encrypt(file, data_len, encrypted_file):
"""
Encrypt data for each party.
Args:
file: The file that saves data to encrypt.
data_len: The length of plain data. E.g.,for uci housing
feature data, the length is 13.
encrypted_file: The file that saves encrypted data.
"""
data = np.fromfile(file, sep=' ')
data = data.reshape(data.shape[0] // (data_len + 1), data_len + 1)
def sample_reader():
"""
read concated data.
"""
for d in data:
yield d[1:]
def encrypt_sample():
"""
encrypt sample
"""
for sample in sample_reader():
yield aby3.make_shares(sample)
if not os.path.exists('./tmp'):
os.makedirs('./tmp')
aby3.save_aby3_shares(encrypt_sample, "./tmp/" + encrypted_file)
def generate_encrypted_train_data(mpc_data_dir, class_num):
"""
generate encrypted samples
"""
def encrypted_mnist_features():
"""
feature reader
"""
for instance in sample_reader():
yield aby3.make_shares(instance[0])
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)
aby3.save_aby3_shares(encrypted_mnist_features,
mpc_data_dir + "mnist{}_feature".format(class_num))
aby3.save_aby3_shares(encrypted_mnist_labels,
mpc_data_dir + "mnist{}_label".format(class_num))
def test_save_aby3_shares(self):
part_name = './tmp_test_save_aby3_shares'
aby3.save_aby3_shares(share_reader=self.dummy_share_reader,
part_name=part_name)
files = os.listdir('./')
true_filename = 'tmp_test_save_aby3_shares'
for idx in range(3):
tmp_file = true_filename + '.part' + str(idx)
self.assertTrue(tmp_file in files)
self.remove_temp_file(tmp_file)
def gen_random_data():
for i, num in enumerate(sample_nums):
suffix = '.' + str(i)
f_mat = np.random.rand(num, feat_width)
np.save(data_path + 'feature_data' + suffix, f_mat)
process_data.generate_encrypted_data(i, f_mat)
aby3.save_aby3_shares(process_data.encrypted_data(np.array(sample_nums)),
data_path + 'sample_num')
def generate_encrypted_data():
"""
generate encrypted samples
"""
def encrypted_housing_features():
"""
feature reader
"""
for instance in sample_reader():
yield aby3.make_shares(instance[0])
def encrypted_housing_labels():
"""
label reader
"""
for instance in sample_reader():
yield aby3.make_shares(instance[1])
aby3.save_aby3_shares(encrypted_housing_features, "/tmp/house_feature")
aby3.save_aby3_shares(encrypted_housing_labels, "/tmp/house_label")
def generate_encrypted_test_data():
"""
generate encrypted samples
"""
def encrypted_mnist_features():
"""
feature reader
"""
for instance in test_reader():
yield aby3.make_shares(instance[0])
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))
aby3.save_aby3_shares(encrypted_mnist_features, "/tmp/mnist2_test_feature")
aby3.save_aby3_shares(encrypted_mnist_labels, "/tmp/mnist2_test_label")
def generate_encrypted_data(args, mpc_data_dir, reader, label_filepath=None):
"""
generate encrypted samples
"""
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 encrypt_feature_value():
for instance in reader():
#print(np.array(instance[1]).shape)
yield aby3.make_shares(np.array(instance[1]))
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]))
aby3.save_aby3_shares(encrypt_label, mpc_data_dir + "criteo_label")
aby3.save_aby3_shares(encrypt_feature_value,
mpc_data_dir + "criteo_feature_value")
aby3.save_aby3_shares(encrypt_feature_idx,
mpc_data_dir + "criteo_feature_idx")
def generate_encrypted_test_data(mpc_data_dir, class_num,
label_mnist_filepath):
"""
generate encrypted samples
"""
def encrypted_mnist_features():
"""
feature reader
"""
for instance in test_reader():
yield aby3.make_shares(instance[0])
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)
aby3.save_aby3_shares(
encrypted_mnist_features,
mpc_data_dir + "mnist{}_test_feature".format(class_num))
aby3.save_aby3_shares(
encrypted_mnist_labels,
mpc_data_dir + "mnist{}_test_label".format(class_num))
def generate_encrypted_data(mpc_data_dir):
"""
Generate encrypted samples
"""
sample_reader = paddle.dataset.uci_housing.train()
def encrypted_housing_features():
"""
feature reader
"""
for instance in sample_reader():
yield aby3.make_shares(instance[0])
def encrypted_housing_labels():
"""
label reader
"""
for instance in sample_reader():
yield aby3.make_shares(instance[1])
aby3.save_aby3_shares(encrypted_housing_features,
mpc_data_dir + "house_feature")
aby3.save_aby3_shares(encrypted_housing_labels,
mpc_data_dir + "house_label")
def generate_encrypted_data(party_id, f_mat):
"""
generate encrypted data from feature matrix (np.array)
"""
f_max = np.amax(f_mat, axis=0)
f_min = np.amin(f_mat, axis=0)
f_mean = np.mean(f_mat, axis=0)
suffix = '.' + str(party_id)
aby3.save_aby3_shares(encrypted_data(f_max),
data_path + "feature_max" + suffix)
aby3.save_aby3_shares(encrypted_data(f_min),
data_path + "feature_min" + suffix)
aby3.save_aby3_shares(encrypted_data(f_mean),
data_path + "feature_mean" + suffix)
