def elementwise_sub(self, **kwargs):
"""
Normal case.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
expected_out = kwargs['expect_results'][role]
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[5], dtype='int64')
y = pfl_mpc.data(name='y', shape=[5], dtype='int64')
op_sub = pfl_mpc.layers.elementwise_sub(x=x, y=y)
math_sub = x - y
exe = fluid.Executor(place=fluid.CPUPlace())
sub_results = exe.run(feed={
'x': d_1,
'y': d_2
},
fetch_list=[op_sub, math_sub])
self.assertTrue(np.allclose(sub_results[0], sub_results[1]))
self.assertEqual(sub_results[0].shape, (2, 5))
self.assertTrue(np.allclose(sub_results[0], expected_out))
def load_mpc_model_and_predict(role, ip, server, port, mpc_model_dir,
mpc_model_filename):
"""
Predict based on MPC inference model, save prediction results into files.
"""
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# Step 1. initialize MPC environment and load MPC model to predict
pfl_mpc.init(mpc_protocol_name, role, ip, server, port)
infer_prog, feed_names, fetch_targets = mpc_du.load_mpc_model(
exe=exe,
mpc_model_dir=mpc_model_dir,
mpc_model_filename=mpc_model_filename,
inference=True)
# Step 2. MPC predict
batch_size = network.BATCH_SIZE
feature_file = "/tmp/house_feature"
feature_shape = (13, )
pred_file = "./tmp/uci_prediction.part{}".format(role)
loader = process_data.get_mpc_test_dataloader(feature_file, feature_shape,
role, batch_size)
start_time = time.time()
for sample in loader():
prediction = exe.run(program=infer_prog,
feed={feed_names[0]: np.array(sample)},
fetch_list=fetch_targets)
# Step 3. save prediction results
with open(pred_file, 'ab') as f:
f.write(np.array(prediction).tostring())
break
end_time = time.time()
print('Mpc Predict with samples of {}, cost time in seconds:{}'.format(
batch_size, (end_time - start_time)))
def closure(**kwargs):
role = kwargs['role']
pfl_mpc.init("aby3", role, "localhost", self.server,
int(self.port))
#init_op = fluid.default_main_program().global_block().ops[0]
#_insert_init_op(program, init_op)
executor = Executor(place)
executor.run()
outs = executor.run(prog,
feed=feed_dict,
fetch_list=fetch_list,
return_numpy=False)
# append lod information in last position
lod = []
for idx in range(len(fetch_list)):
return_results[idx].append(np.array(outs[idx]))
lod_i = outs[idx].lod()
lod_concat = []
for i in lod_i:
lod_concat.append(i)
lod.append(lod_concat)
return_results[len(fetch_list)].append(lod)
def lt(self, **kwargs):
"""
Less than.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
expected_out = kwargs['expect_results'][role]
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[3], dtype='int64')
y = fluid.data(name='y', shape=[3], dtype='float32')
op_lt = pfl_mpc.layers.less_than(x=x, y=y)
math_lt = x < y
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={
'x': d_1,
'y': d_2
},
fetch_list=[op_lt, math_lt])
self.assertTrue(np.allclose(results[0], results[1]))
self.assertEqual(results[0].shape, (3, ))
self.assertTrue(np.allclose(results[0], expected_out))
def precision_recall(self, **kwargs):
"""
precision_recall op ut
:param kwargs:
:return:
"""
role = kwargs['role']
preds = kwargs['preds']
labels = kwargs['labels']
loop = kwargs['loop']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=self.input_size, dtype='int64')
y = pfl_mpc.data(name='y', shape=self.input_size, dtype='int64')
out0, out1 = pfl_mpc.layers.precision_recall(input=x,
label=y,
threshold=self.threshold)
exe = fluid.Executor(place=fluid.CPUPlace())
exe.run(fluid.default_startup_program())
for i in range(loop):
batch_res, acc_res = exe.run(feed={
'x': preds[i],
'y': labels[i]
},
fetch_list=[out0, out1])
self.assertTrue(
np.allclose(batch_res * (2**-16), self.exp_res[0][:3], atol=1e-4))
self.assertTrue(
np.allclose(acc_res * (2**-16), self.exp_res[0][3:], atol=1e-4))
def sum(self, **kwargs):
"""
Test normal case.
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
d_3 = kwargs['data_3'][role]
expected_out = kwargs['expect_results'][role]
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='data_1', shape=[4], dtype='int64')
data_2 = pfl_mpc.data(name='data_2', shape=[4], dtype='int64')
data_3 = pfl_mpc.data(name='data_3', shape=[4], dtype='int64')
op_sum = pfl_mpc.layers.sum([data_1, data_2, data_3])
math_sum = data_1 + data_2 + data_3
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={
'data_1': d_1,
'data_2': d_2,
'data_3': d_3
},
fetch_list=[op_sum, math_sum])
self.assertTrue(np.allclose(results[0], results[1]))
self.assertEqual(results[0].shape, (2, 4))
self.assertTrue(np.allclose(results[0], expected_out))
def encrypted_data_generator(data_location_party, sample_reader, index1,
index2_begin, index2_end):
feature_num = index2_end - index2_begin
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
pfl_mpc.init("aby3", int(role), "localhost", server, int(port))
input = fluid.data(name='input',
shape=[feature_num],
dtype='float32')
out = pfl_mpc.layers.share(input, party_id=data_location_party)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for instance in sample_reader():
if role == data_location_party:
feed_data = np.array(
instance[index1][index2_begin:index2_end],
dtype='float32')
else:
feed_data = np.zeros(shape=(feature_num, ),
dtype='float32') #dummy_data
out_share = exe.run(feed={'input': feed_data},
fetch_list=[out])
yield np.array(out_share)
def elementwise_add(self, **kwargs):
"""
Add two variables with one dimension.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
expected_out = kwargs['expect_results'][role]
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[4], dtype='int64')
y = pfl_mpc.data(name='y', shape=[4], dtype='int64')
op_add = pfl_mpc.layers.elementwise_add(x=x, y=y)
math_add = x + y
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={
'x': d_1,
'y': d_2
},
fetch_list=[op_add, math_add])
self.assertTrue(np.allclose(results[0], results[1]))
self.assertEqual(results[0].shape, (2, 4))
self.assertTrue(np.allclose(results[0], expected_out))
def fc(self, **kwargs):
"""
Normal case.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
return_results = kwargs['return_results']
pfl_mpc.init("privc", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='data_1', shape=[3, 2], dtype='int64')
out = pfl_mpc.layers.fc(
input=data_1,
size=1,
num_flatten_dims=-1,
param_attr=fluid.ParamAttr(
initializer=fluid.initializer.ConstantInitializer(
1 * 2**scaling_factor / 2))) # init 1
exe = fluid.Executor(place=fluid.CPUPlace())
exe.run(fluid.default_startup_program())
results = exe.run(feed={'data_1': d_1}, fetch_list=[out])
self.assertEqual(results[0].shape, (3, 1))
return_results.append(results[0])
def batch_norm(self, **kwargs):
"""
Add two variables with one dimension.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[2, 3], dtype='int64')
param_attr = fluid.ParamAttr(
name='batch_norm_w',
initializer=fluid.initializer.ConstantInitializer(value=21845))
bias_attr = fluid.ParamAttr(
name='batch_norm_b',
initializer=fluid.initializer.ConstantInitializer(value=0))
bn_out = pfl_mpc.layers.batch_norm(input=x,
param_attr=param_attr,
bias_attr=bias_attr)
exe = fluid.Executor(place=fluid.CPUPlace())
exe.run(fluid.default_startup_program())
results = exe.run(feed={'x': d_1}, fetch_list=[bn_out])
self.assertEqual(results[0].shape, (2, 2, 3))
return_results.append(results[0])
def mean_normalize(self, **kwargs):
"""
mean_normalize op ut
:param kwargs:
:return:
"""
role = kwargs['role']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
mi = pfl_mpc.data(name='mi', shape=self.input_size, dtype='int64')
ma = pfl_mpc.data(name='ma', shape=self.input_size, dtype='int64')
me = pfl_mpc.data(name='me', shape=self.input_size, dtype='int64')
sn = pfl_mpc.data(name='sn', shape=self.input_size[:-1], dtype='int64')
out0, out1 = pfl_mpc.layers.mean_normalize(f_min=mi,
f_max=ma,
f_mean=me,
sample_num=sn)
exe = fluid.Executor(place=fluid.CPUPlace())
f_range, f_mean = exe.run(feed={
'mi': kwargs['min'],
'ma': kwargs['max'],
'me': kwargs['mean'],
'sn': kwargs['sample_num']
},
fetch_list=[out0, out1])
self.f_range_list.append(f_range)
self.f_mean_list.append(f_mean)
def closure(**kwargs):
role = kwargs['role']
pfl_mpc.init("aby3", role, "localhost", self.server,
int(self.port))
loss = append_loss_ops(block, output_names)
param_grad_list = append_backward(loss=loss,
parameter_list=input_to_check,
no_grad_set=no_grad_set)
inputs = self._get_inputs(block)
feed_dict = self.feed_var(inputs, place)
fetch_list = [g for p, g in param_grad_list]
executor = Executor(place)
executor.run()
outs = executor.run(prog,
feed=feed_dict,
fetch_list=fetch_list,
return_numpy=False)
# append lod information in last position
lod = []
for idx in range(fetch_list_len):
return_results[idx].append(np.array(outs[idx]))
lod_i = outs[idx].lod()
lod_concat = []
for i in lod_i:
lod_concat.append(i)
lod.append(lod_concat)
return_results[fetch_list_len].append(lod)
def mat_mul2(self, **kwargs):
"""
Normal case.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("privc", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='data_1', shape=[2, 3, 4, 5], dtype='int64')
data_2 = pfl_mpc.data(name='data_2', shape=[5, 4, 3, 2], dtype='int64')
out = pfl_mpc.layers.mul(data_1,
data_2,
x_num_col_dims=2,
y_num_col_dims=2)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={
'data_1': d_1,
'data_2': d_2
},
fetch_list=[out])
self.assertEqual(results[0].shape, (2, 3, 3, 2))
return_results.append(results[0])
def encrypt_model_and_train(role, ip, server, port, model_save_dir,
model_filename):
"""
Load uci network and train MPC model.
"""
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# Step 1. Initialize MPC environment and load paddle model network and initialize parameter.
pfl_mpc.init("aby3", role, ip, server, port)
[_, _, _, loss] = network.uci_network()
exe.run(fluid.default_startup_program())
# Step 2. TRANSPILE: encrypt default_main_program into MPC program
aby3.transpile()
# Step 3. MPC-TRAINING: model training based on MPC program.
mpc_data_dir = "../mpc_data/"
feature_file = mpc_data_dir + "house_feature"
feature_shape = (13, )
label_file = mpc_data_dir + "house_label"
label_shape = (1, )
if not os.path.exists('./tmp'):
os.makedirs('./tmp')
loss_file = "./tmp/uci_mpc_loss.part{}".format(role)
if os.path.exists(loss_file):
os.remove(loss_file)
batch_size = network.UCI_BATCH_SIZE
epoch_num = network.TRAIN_EPOCH
feature_name = 'x'
label_name = 'y'
loader = process_data.get_mpc_dataloader(feature_file, label_file,
feature_shape, label_shape,
feature_name, label_name, role,
batch_size)
start_time = time.time()
for epoch_id in range(epoch_num):
step = 0
for sample in loader():
mpc_loss = exe.run(feed=sample, fetch_list=[loss.name])
if step % 50 == 0:
print('Epoch={}, Step={}, Loss={}'.format(
epoch_id, step, mpc_loss))
with open(loss_file, 'ab') as f:
f.write(np.array(mpc_loss).tostring())
step += 1
end_time = time.time()
print('Mpc Training of Epoch={} Batch_size={}, cost time in seconds:{}'.
format(epoch_num, batch_size, (end_time - start_time)))
# Step 4. SAVE trained MPC model as a trainable model.
aby3.save_trainable_model(exe=exe,
model_dir=model_save_dir,
model_filename=model_filename)
print('Successfully save mpc trained model into:{}'.format(model_save_dir))
def infer(args):
"""
infer
"""
logger.info('Start inferring...')
begin = time.time()
place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
cur_model_path = os.path.join(args.model_dir, 'mpc_model', 'epoch_' + str(args.test_epoch),
'checkpoint', 'party_{}'.format(args.role))
with fluid.scope_guard(fluid.Scope()):
pfl_mpc.init('aby3', args.role, 'localhost', args.server, args.port)
infer_program, feed_target_names, fetch_vars = aby3.load_mpc_model(exe=exe,
mpc_model_dir=cur_model_path,
mpc_model_filename='__model__',
inference=True)
mpc_data_dir = args.mpc_data_dir
user_vec_filepath = mpc_data_dir + 'user_vec'
user_vec_part_filepath = user_vec_filepath + '.part{}'.format(args.role)
sample_batch = args.batch_size
watch_vecs = []
search_vecs = []
other_feats = []
watch_vec_reader = read_share(file=mpc_data_dir + 'watch_vec', shape=(sample_batch, args.watch_vec_size))
for vec in watch_vec_reader():
watch_vecs.append(vec)
search_vec_reader = read_share(file=mpc_data_dir + 'search_vec', shape=(sample_batch, args.search_vec_size))
for vec in search_vec_reader():
search_vecs.append(vec)
other_feat_reader = read_share(file=mpc_data_dir + 'other_feat', shape=(sample_batch, args.other_feat_size))
for vec in other_feat_reader():
other_feats.append(vec)
if os.path.exists(user_vec_part_filepath):
os.system('rm -rf ' + user_vec_part_filepath)
for i in range(args.batch_num):
l3 = exe.run(infer_program,
feed={
'watch_vec': watch_vecs[i],
'search_vec': search_vecs[i],
'other_feat': other_feats[i],
},
return_numpy=True,
fetch_list=fetch_vars)
with open(user_vec_part_filepath, 'ab+') as f:
f.write(np.array(l3[0]).tostring())
end = time.time()
logger.info('MPC inferring, cost_time: {:.5f}s'.format(end - begin))
logger.info('End inferring.')
def load_uci_update(role, ip, server, port, mpc_model_dir, mpc_model_filename, updated_model_dir):
"""
Load, update and save uci MPC model.
"""
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# Step 1. initialize MPC environment and load MPC model into default_main_program to update.
pfl_mpc.init("aby3", role, ip, server, port)
aby3.load_mpc_model(exe=exe,
mpc_model_dir=mpc_model_dir,
mpc_model_filename=mpc_model_filename)
# Step 2. MPC update
epoch_num = network.MPC_UPDATE_EPOCH
batch_size = network.BATCH_SIZE
mpc_data_dir = "../mpc_data/"
feature_file = mpc_data_dir + "house_feature"
feature_shape = (13,)
label_file = mpc_data_dir + "house_label"
label_shape = (1,)
loss_file = "./tmp/uci_mpc_loss.part{}".format(role)
if os.path.exists(loss_file):
os.remove(loss_file)
updated_model_name = 'mpc_updated_model'
feature_name = 'x'
label_name = 'y'
# fetch loss if needed
loss = fluid.default_main_program().global_block().var('mean_0.tmp_0')
loader = process_data.get_mpc_dataloader(feature_file, label_file, feature_shape, label_shape,
feature_name, label_name, role, batch_size)
start_time = time.time()
for epoch_id in range(epoch_num):
step = 0
for sample in loader():
mpc_loss = exe.run(feed=sample, fetch_list=[loss.name])
if step % 50 == 0:
print('Epoch={}, Step={}, Loss={}'.format(epoch_id, step, mpc_loss))
with open(loss_file, 'ab') as f:
f.write(np.array(mpc_loss).tostring())
step += 1
end_time = time.time()
print('Mpc Updating of Epoch={} Batch_size={}, cost time in seconds:{}'
.format(epoch_num, batch_size, (end_time - start_time)))
# Step 3. save updated MPC model as a trainable model.
aby3.save_trainable_model(exe=exe,
model_dir=updated_model_dir,
model_filename=updated_model_name)
print('Successfully save mpc updated model into:{}'.format(updated_model_dir))
def closure(**kwargs):
role = kwargs['role']
pfl_mpc.init("privc", role, "localhost", self.server,
int(self.port))
executor = Executor(place)
executor.run()
op.run(scope, place)
for name in output_names:
out = np.array(scope.find_var(name).get_tensor())
return_results[name].append(out)
def closure(**kwargs):
role = kwargs['role']
pfl_mpc.init("privc", role, "localhost", self.server,
int(self.port))
#init_op = fluid.default_main_program().global_block().ops[0]
#_insert_init_op(program, init_op)
executor = Executor(place)
executor.run()
outs = executor.run(prog, feed=feed_dict, fetch_list=fetch_list)
for idx in range(len(fetch_list)):
return_results[idx].append(outs[idx])
def square(self, **kwargs):
"""
Square.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='x', shape=[2, 2], dtype='int64')
op_square = pfl_mpc.layers.square(data_1)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1}, fetch_list=[op_square])
self.assertEqual(results[0].shape, (2, 2, 2))
return_results.append(results[0])
def multi_dim_add(self, **kwargs):
"""
Add two variables with multi dimensions.
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
expected_out = kwargs['expect_results'][role]
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[2, 2], dtype='int64')
y = pfl_mpc.data(name='y', shape=[2, 2], dtype='int64')
add = x + y
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[add])
self.assertTrue(np.allclose(results[0], expected_out))
def mean(self, **kwargs):
"""
Normal case.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
return_results = kwargs['return_results']
pfl_mpc.init("privc", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='data_1', shape=[3, 2], dtype='int64')
out = pfl_mpc.layers.mean(data_1)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'data_1': d_1}, fetch_list=[out])
self.assertEqual(results[0].shape, (1, ))
return_results.append(results[0])
def reduce_sum(self, **kwargs):
"""
Normal case.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='x', shape=[3, 4], dtype='int64')
op_reduce_sum = pfl_mpc.layers.reduce_sum(data_1, [1, 2], keep_dim=True)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1}, fetch_list=[op_reduce_sum])
self.assertEqual(results[0].shape, (2, 1, 1))
return_results.append(results[0])
def multi_dim_mul(self, **kwargs):
"""
Add two variables with multi dimensions.
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[2, 2], dtype='int64')
y = pfl_mpc.data(name='y', shape=[2, 2], dtype='int64')
math_mul = x * y
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[math_mul])
self.assertEqual(results[0].shape, (2, 2, 2))
return_results.append(results[0])
def square_error_cost(self, **kwargs):
"""
Normal case.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
data_1 = pfl_mpc.data(name='data_1', shape=[2, 2], dtype='int64')
data_2 = pfl_mpc.data(name='data_2', shape=[2, 2], dtype='int64')
cost = pfl_mpc.layers.square_error_cost(input=data_1, label=data_2)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'data_1': d_1, 'data_2': d_2}, fetch_list=[cost])
self.assertEqual(results[0].shape, (2, 2, 2))
return_results.append(results[0])
def diff_dim_mul_mid(self, **kwargs):
"""
Add with different dimensions.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[3, 4, 2], dtype='int64')
y = pfl_mpc.data(name='y', shape=[3, 4], dtype='int64')
math_mul = pfl_mpc.layers.elementwise_mul(x, y, axis=0)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[math_mul])
self.assertEqual(results[0].shape, (2, 3, 4, 2))
return_results.append(results[0])
def elementwise_mul(self, **kwargs):
"""
Add two variables with one dimension.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[4], dtype='int64')
y = pfl_mpc.data(name='y', shape=[4], dtype='int64')
op_mul = pfl_mpc.layers.elementwise_mul(x=x, y=y)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[op_mul])
self.assertEqual(results[0].shape, (2, 4))
return_results.append(results[0])
def pool2d(self, **kwargs):
"""
Add two variables with one dimension.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[1, 1, 4, 6], dtype='int64')
pool_out = pfl_mpc.layers.pool2d(input=x, pool_size=2, pool_stride=2)
exe = fluid.Executor(place=fluid.CPUPlace())
#exe.run(fluid.default_startup_program())
results = exe.run(feed={'x': d_1}, fetch_list=[pool_out])
self.assertEqual(results[0].shape, (2, 1, 1, 2, 3))
return_results.append(results[0])
def softmax_with_cross_entropy(self, **kwargs):
"""
Add two variables with one dimension.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[2], dtype='int64')
y = pfl_mpc.data(name='y', shape=[2], dtype='int64')
cost, softmax = pfl_mpc.layers.softmax_with_cross_entropy(
x, y, soft_label=True, return_softmax=True)
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[softmax])
self.assertEqual(results[0].shape, (2, 2))
return_results.append(results[0])
def mul(self, **kwargs):
"""
Mul.
:param kwargs:
:return:
"""
role = kwargs['role']
d_1 = kwargs['data_1'][role]
d_2 = kwargs['data_2'][role]
return_results = kwargs['return_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
x = pfl_mpc.data(name='x', shape=[2, 2], dtype='int64')
y = pfl_mpc.data(name='y', shape=[2, 2], dtype='int64')
op_mul = pfl_mpc.layers.mul(x=x, y=y)
# math_mul = data_1 * data_2
exe = fluid.Executor(place=fluid.CPUPlace())
results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[op_mul])
self.assertEqual(results[0].shape, (2, 2, 2))
return_results.append(results[0])
def embedding_op(self, **kwargs):
role = kwargs['role']
#data = kwargs['data']
data_normal = kwargs['data_normal']
data_share = kwargs['data_share'][role]
w_data = kwargs['w_data']
w_data_share = kwargs['w_data_share'][role]
return_results = kwargs['return_results']
expected_result = kwargs['expect_results']
pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port))
w_param_attrs = fluid.ParamAttr(name='emb_weight',
learning_rate=0.5,
initializer=pfl_mpc.initializer.NumpyArrayInitializer(w_data_share),
trainable=True)
w_param_attrs1 = fluid.ParamAttr(name='emb_weight1',
learning_rate=0.5,
initializer=fluid.initializer.NumpyArrayInitializer(w_data),
trainable=True)
input_shape = np.delete(data_share.shape, 0, 0)
data1 = pfl_mpc.data(name='input', shape=input_shape, dtype='int64')
data2 = fluid.data(name='input1', shape=data_normal.shape, dtype='int64')
math_embedding = fluid.input.embedding(input=data2, size=w_data.shape, param_attr=w_param_attrs1, dtype='float32')
op_embedding = pfl_mpc.input.embedding(input=data1, size=(input_shape[1],input_shape[0]), param_attr=w_param_attrs, dtype='int64')
exe = fluid.Executor(place=fluid.CPUPlace())
exe.run(fluid.default_startup_program())
results = exe.run(feed={'input': data_share, 'input1': data_normal}, fetch_list=[op_embedding, math_embedding])
return_results.append(results[0])
expected_result.append(results[1])
