def diff_dim_mul(self, **kwargs): """ Mul 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], dtype='int64') y = pfl_mpc.data(name='y', shape=[4, 5], dtype='int64') op_mul = pfl_mpc.layers.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, 3, 5)) 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("privc", 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') out = pfl_mpc.layers.square_error_cost(data_1, data_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, 2)) 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 diff_dim_add_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=[4], dtype='int64') # math_add = x + y math_add = pfl_mpc.layers.elementwise_add(x, y, axis=1) exe = fluid.Executor(place=fluid.CPUPlace()) results = exe.run(feed={'x': d_1, 'y': d_2}, fetch_list=[math_add]) self.assertEqual(results[0].shape, (2, 3, 4, 2)) return_results.append(results[0])
def decrypt_online(shares, shape): main_program = fluid.Program() startup_program = fluid.Program() with fluid.program_guard(main_program, startup_program): input = pfl_mpc.data(name='input', shape=shape[1:], dtype='int64') out = pfl_mpc.layers.reveal(input) place=fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) out_ = exe.run(feed={'input': np.array(shares).reshape(shape)}, fetch_list=[out]) return out_
def mean(self, **kwargs): """ Mean. :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='data_1', shape=[2, 4], dtype='int64') op_mean = pfl_mpc.layers.mean(data_1) exe = fluid.Executor(place=fluid.CPUPlace()) results = exe.run(feed={'data_1': d_1}, fetch_list=[op_mean]) self.assertEqual(results[0].shape, (2, 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 relu(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='data_1', shape=[3, 2], dtype='int64') relu_out = pfl_mpc.layers.relu(input=data_1) exe = fluid.Executor(place=fluid.CPUPlace()) results = exe.run(feed={'data_1': d_1}, fetch_list=[relu_out]) self.assertEqual(results[0].shape, (2, 3, 2)) 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 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("aby3", role, "localhost", self.server, int(self.port)) data_1 = pfl_mpc.data(name='data_1', shape=[3, 2], dtype='int64') fc_out = pfl_mpc.layers.fc( input=data_1, size=1, param_attr=fluid.ParamAttr( initializer=fluid.initializer.ConstantInitializer(0))) exe = fluid.Executor(place=fluid.CPUPlace()) exe.run(fluid.default_startup_program()) results = exe.run(feed={'data_1': d_1}, fetch_list=[fc_out]) self.assertEqual(results[0].shape, (2, 3, 1)) 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])
import paddle import paddle.fluid as fluid import paddle_fl.mpc as pfl_mpc import paddle_fl.mpc.data_utils.aby3 as aby3 role, server, port = sys.argv[1], sys.argv[2], sys.argv[3] # modify host(localhost). pfl_mpc.init("aby3", int(role), "localhost", server, int(port)) role = int(role) # data preprocessing BATCH_SIZE = 128 epoch_num = 2 # network x = pfl_mpc.data(name='x', shape=[BATCH_SIZE, 784], dtype='int64') y = pfl_mpc.data(name='y', shape=[BATCH_SIZE, 1], dtype='int64') y_pre = pfl_mpc.layers.fc(input=x, size=1) cost = pfl_mpc.layers.sigmoid_cross_entropy_with_logits(y_pre, y) infer_program = fluid.default_main_program().clone(for_test=False) avg_loss = pfl_mpc.layers.mean(cost) optimizer = pfl_mpc.optimizer.SGD(learning_rate=0.001) optimizer.minimize(avg_loss) mpc_data_dir = "./mpc_data/" if not os.path.exists(mpc_data_dir): raise ValueError( "mpc_data_dir is not found. Please prepare encrypted data.")
import paddle_fl.mpc.data_utils.aby3 as aby3 logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger("fluid") logger.setLevel(logging.INFO) role, server, port = sys.argv[1], sys.argv[2], sys.argv[3] # modify host(localhost). pfl_mpc.init("aby3", int(role), "localhost", server, int(port)) role = int(role) # data preprocessing BATCH_SIZE = 128 epoch_num = 1 x = pfl_mpc.data(name='x', shape=[BATCH_SIZE, 1, 28, 28], dtype='int64') y = pfl_mpc.data(name='y', shape=[BATCH_SIZE, 10], dtype='int64') class Model(object): def __int__(self): pass def lenet3(self): conv = pfl_mpc.layers.conv2d(input=x, num_filters=16, filter_size=5, act='relu') pool = pfl_mpc.layers.pool2d(input=conv, pool_size=2, pool_stride=2) fc_1 = pfl_mpc.layers.fc(input=pool, size=100, act='relu') fc_out = pfl_mpc.layers.fc(input=fc_1, size=10) cost, softmax = pfl_mpc.layers.softmax_with_cross_entropy(logits=fc_out, label=y, soft_label=True,
""" reader = aby3.load_aby3_shares(path, id=role, shape=(party_num, )) for n in reader(): return n f_max = get_shares(data_path + 'feature_max') f_min = get_shares(data_path + 'feature_min') f_mean = get_shares(data_path + 'feature_mean') sample_num = get_sample_num(data_path + 'sample_num') pfl_mpc.init("aby3", int(role), "localhost", server, int(port)) shape = [party_num, feat_num] mi = pfl_mpc.data(name='mi', shape=shape, dtype='int64') ma = pfl_mpc.data(name='ma', shape=shape, dtype='int64') me = pfl_mpc.data(name='me', shape=shape, dtype='int64') sn = pfl_mpc.data(name='sn', shape=shape[:-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': f_min, 'ma': f_max, 'me': f_mean, 'sn': sample_num}, fetch_list=[out0, out1])
# choose party 0 as nccl "server", which receive nccl id of other parties # party 0 listens on ports listed in endpoints # other parties connect to those ports and send their nccl id role, server = sys.argv[1], sys.argv[2] pfl_mpc.init(mpc_protocol_name, int(role), net_server_addr=server, endpoints="33784,45888", network_mode="nccl") role = int(role) # data preprocessing BATCH_SIZE = 32 epoch_num = 1 x = pfl_mpc.data(name='x', shape=[BATCH_SIZE, 3, 224, 224], dtype='int64') y = pfl_mpc.data(name='y', shape=[BATCH_SIZE, 1000], dtype='int64') class Model(object): """ lenet model: alexnet, vgg-16 """ def __int__(self): """ init """ pass def alexnet(self): """
def train(args): # Init MPC role = int(args.role) pfl_mpc.init("aby3", role, "localhost", args.server, int(args.port)) # Input and Network BATCH_SIZE = args.batch_size FIELD_NUM = args.num_field FEATURE_NUM = args.sparse_feature_number + 1 feat_idx = pfl_mpc.data(name='feat_idx', shape=[BATCH_SIZE, FIELD_NUM, FEATURE_NUM], lod_level=1, dtype="int64") feat_value = pfl_mpc.data(name='feat_value', shape=[BATCH_SIZE, FIELD_NUM], lod_level=0, dtype="int64") label = pfl_mpc.data(name='label', shape=[BATCH_SIZE, 1], lod_level=1, dtype="int64") inputs = [feat_idx] + [feat_value] + [label] avg_cost, predict = mpc_network.FM(args, inputs, seed=2) infer_program = fluid.default_main_program().clone(for_test=True) optimizer = pfl_mpc.optimizer.SGD(args.base_lr) optimizer.minimize(avg_cost) place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # Prepare train data mpc_data_dir = "./mpc_data/" mpc_train_data_dir = mpc_data_dir + 'train/' if not os.path.exists(mpc_train_data_dir): raise ValueError( "{} is not found. Please prepare encrypted data.".format( mpc_train_data_dir)) feature_idx_reader = aby3.load_aby3_shares(mpc_train_data_dir + "criteo_feature_idx", id=role, shape=(FIELD_NUM, FEATURE_NUM)) feature_value_reader = aby3.load_aby3_shares(mpc_train_data_dir + "criteo_feature_value", id=role, shape=(FIELD_NUM, )) label_reader = aby3.load_aby3_shares(mpc_train_data_dir + "criteo_label", id=role, shape=(1, )) batch_feature_idx = aby3.batch(feature_idx_reader, BATCH_SIZE, drop_last=True) batch_feature_value = aby3.batch(feature_value_reader, BATCH_SIZE, drop_last=True) batch_label = aby3.batch(label_reader, BATCH_SIZE, drop_last=True) loader = fluid.io.DataLoader.from_generator( feed_list=[feat_idx, feat_value, label], capacity=BATCH_SIZE) batch_sample = paddle.reader.compose(batch_feature_idx, batch_feature_value, batch_label) loader.set_batch_generator(batch_sample, places=place) # Training logger.info('******************************************') logger.info('Start Training...') logger.info('batch_size = {}, learning_rate = {}'.format( args.batch_size, args.base_lr)) mpc_model_basedir = "./mpc_model/" start_time = time.time() step = 0 for epoch_id in range(args.epoch_num): for sample in loader(): step += 1 exe.run(feed=sample, fetch_list=[predict.name]) batch_end = time.time() if step % 100 == 0: print('Epoch={}, Step={}, current cost time: {}'.format( epoch_id, step, batch_end - start_time)) print('Epoch={}, current cost time: {}'.format(epoch_id, batch_end - start_time)) # For each epoch: save infer program mpc_model_dir = mpc_model_basedir + "epoch{}/party{}".format( epoch_id, role) fluid.io.save_inference_model( dirname=mpc_model_dir, feeded_var_names=["feat_idx", "feat_value", "label"], target_vars=[predict], executor=exe, main_program=infer_program, model_filename="__model__") logger.info('Model is saved in {}'.format(mpc_model_dir)) end_time = time.time() print('Mpc Training of Epoch={} Batch_size={}, epoch_cost={:.4f} s'.format( args.epoch_num, BATCH_SIZE, (end_time - start_time))) logger.info('******************************************') logger.info('End Training...')
""" # set proper path for fluid_encrypted without install, should be first line import env_set import time import sys import numpy as np import paddle.fluid as fluid import paddle_fl.mpc as pfl_mpc role, server, port = env_set.TestOptions().values() pfl_mpc.init("aby3", int(role), "localhost", server, int(port)) data_1 = pfl_mpc.data(name='data_1', shape=[2, 2], dtype='int64') data_2 = fluid.data(name='data_2', shape=[1, 2, 2], dtype='float32') out_gt = data_1 > data_2 out_ge = data_1 >= data_2 out_lt = data_1 < data_2 out_le = data_1 <= data_2 out_eq = data_1 == data_2 out_neq = data_1 != data_2 d_1 = np.array([[[65536, 65536], [65536, 65536]], [[65536, 65536], [65536, 65536]]]).astype('int64') d_2 = np.array([[[10, 3], [0, -3]]]).astype('float32') exe = fluid.Executor(place=fluid.CPUPlace()) exe.run(fluid.default_startup_program())
""" # set proper path for fluid_encrypted without install, should be first line import env_set import sys import numpy as np import paddle.fluid as fluid import paddle_fl.mpc as pfl_mpc role, server, port = env_set.TestOptions().values() # call mpc add pfl_mpc.init("aby3", int(role), "localhost", server, int(port)) data_1 = pfl_mpc.data(name='data_1', shape=[8], dtype='int64') data_2 = pfl_mpc.data(name='data_2', shape=[8], dtype='int64') d_1 = np.array([[0, 1, 2, 3, 4, 5, 6, 7], [0, 1, 2, 3, 4, 5, 6, 7]]).astype('int64') d_2 = np.array([[7, 6, 5, 4, 3, 2, 1, 0], [7, 6, 5, 4, 3, 2, 1, 0]]).astype('int64') out_add = data_1 + data_2 exe = fluid.Executor(place=fluid.CPUPlace()) out_add = exe.run(feed={ 'data_1': d_1, 'data_2': d_2, }, fetch_list=[out_add])
def load_model_and_infer(args): # Init MPC role = int(args.role) pfl_mpc.init("aby3", role, "localhost", args.server, int(args.port)) place = fluid.CPUPlace() exe = fluid.Executor(place) # Input BATCH_SIZE = args.batch_size FIELD_NUM = args.num_field FEATURE_NUM = args.sparse_feature_number + 1 feat_idx = pfl_mpc.data(name='feat_idx', shape=[BATCH_SIZE, FIELD_NUM, FEATURE_NUM], lod_level=1, dtype="int64") feat_value = pfl_mpc.data(name='feat_value', shape=[BATCH_SIZE, FIELD_NUM], lod_level=0, dtype="int64") label = pfl_mpc.data(name='label', shape=[BATCH_SIZE, 1], lod_level=1, dtype="int64") # Prepare test data mpc_data_dir = "./mpc_data/" mpc_test_data_dir = mpc_data_dir + 'test/' if not os.path.exists(mpc_test_data_dir): raise ValueError( "{}is not found. Please prepare encrypted data.".format( mpc_test_data_dir)) test_feature_idx_reader = aby3.load_aby3_shares( mpc_test_data_dir + "criteo_feature_idx", id=role, shape=(FIELD_NUM, FEATURE_NUM)) test_feature_value_reader = aby3.load_aby3_shares(mpc_test_data_dir + "criteo_feature_value", id=role, shape=(FIELD_NUM, )) test_label_reader = aby3.load_aby3_shares(mpc_test_data_dir + "criteo_label", id=role, shape=(1, )) test_batch_feature_idx = aby3.batch(test_feature_idx_reader, BATCH_SIZE, drop_last=True) test_batch_feature_value = aby3.batch(test_feature_value_reader, BATCH_SIZE, drop_last=True) test_batch_label = aby3.batch(test_label_reader, BATCH_SIZE, drop_last=True) test_loader = fluid.io.DataLoader.from_generator( feed_list=[feat_idx, feat_value, label], capacity=BATCH_SIZE, drop_last=True) test_batch_sample = paddle.reader.compose(test_batch_feature_idx, test_batch_feature_value, test_batch_label) test_loader.set_batch_generator(test_batch_sample, places=place) for i in range(args.epoch_num): mpc_model_dir = './mpc_model/epoch{}/party{}'.format(i, role) mpc_model_filename = '__model__' infer(test_loader, role, exe, BATCH_SIZE, mpc_model_dir, mpc_model_filename)
# See the License for the specific language governing permissions and # limitations under the License. import env_set import numpy as np import paddle.fluid as fluid import paddle_fl.mpc as pfl_mpc role, server, port = env_set.TestOptions().values() pfl_mpc.init("aby3", int(role), "localhost", server, int(port)) batch_size = 3 # x is in cypher text type x = pfl_mpc.data(name='x', shape=[batch_size, 8], dtype='int64') # y is in cypher text type y = pfl_mpc.data(name='y', shape=[batch_size, 1], dtype='int64') y_pre = pfl_mpc.layers.fc(input=x, size=1, act=None) y_relu = pfl_mpc.layers.relu(input=y_pre) cost = pfl_mpc.layers.square_error_cost(input=y_relu, label=y) avg_loss = pfl_mpc.layers.mean(cost) optimizer = pfl_mpc.optimizer.SGD(learning_rate=0.001) optimizer.minimize(avg_loss) exe = fluid.Executor(place=fluid.CPUPlace()) exe.run(fluid.default_startup_program()) iters = 1