Merge https://github.com/PaddlePaddle/PaddleFL

README.md

@@ -41,7 +41,7 @@ We **highly recommend** to run PaddleFL in Docker
 
 ```sh
 #Pull and run the docker
-docker pull hub.baidubce.com/paddlefl/paddle_fl:latest
+docker pull paddlepaddle/paddlefl:latest
 docker run --name <docker_name> --net=host -it -v $PWD:/paddle <image id> /bin/bash
 
 #Install paddle_fl

README_cn.md

@@ -38,7 +38,7 @@ PaddleFL 中主要提供两种解决方案：**Data Parallel** 以及 **Federate
 
 ```sh
 #Pull and run the docker
-docker pull hub.baidubce.com/paddlefl/paddle_fl:latest
+docker pull paddlepaddle/paddlefl:latest
 docker run --name <docker_name> --net=host -it -v $PWD:/paddle <image id> /bin/bash
 
 #Install paddle_fl

core/paddlefl_mpc/mpc_protocol/abstract_context.h

+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <algorithm>
+#include <memory>
+
+#include "core/paddlefl_mpc/mpc_protocol/abstract_network.h"
+#include "core/privc3/prng_utils.h"
+#include "paddle/fluid/platform/enforce.h"
+
+namespace paddle {
+
+namespace mpc {
+
+using block = psi::block;
+using PseudorandomNumberGenerator = psi::PseudorandomNumberGenerator;
+
+class AbstractContext {
+public:
+  AbstractContext(size_t party, std::shared_ptr<AbstractNetwork> network) {
+    set_party(party);
+    set_network(network);
+  };
+  AbstractContext(const AbstractContext &other) = delete;
+
+  AbstractContext &operator=(const AbstractContext &other) = delete;
+
+  void set_party(size_t party) {
+    _party = party;
+  }
+
+  void set_num_party(size_t num_party) {
+    _num_party = num_party;
+  }
+
+  void set_network(std::shared_ptr<AbstractNetwork> network) {
+    _network = network;
+  }
+
+  AbstractNetwork *network() { return _network.get(); }
+
+  void set_random_seed(const block &seed, size_t idx) {
+    PADDLE_ENFORCE_LE(idx, _num_party,
+                     "prng idx should be less and equal to %d.",
+                     _num_party);
+    get_prng(idx).set_seed(seed);
+  }
+
+  size_t party() const { return _party; }
+
+  size_t pre_party() const {
+    return (_party + _num_party - 1) % _num_party;
+  }
+
+  size_t next_party() const {
+    return (_party + 1) % _num_party;
+  }
+
+  // generate random from prng[0] or prng[1]
+  // @param next: use bool type for idx 0 or 1
+  template <typename T> T gen_random(bool next) {
+    return get_prng(next).get<T>();
+  }
+
+  template <typename T, template <typename> class Tensor>
+  void gen_random(Tensor<T> &tensor, bool next) {
+    std::for_each(
+        tensor.data(), tensor.data() + tensor.numel(),
+        [this, next](T &val) { val = this->template gen_random<T>(next); });
+  }
+
+  template <typename T> T gen_random_private() { return get_prng(2).get<T>(); }
+
+  template <typename T, template <typename> class Tensor>
+  void gen_random_private(Tensor<T> &tensor) {
+    std::for_each(
+        tensor.data(), tensor.data() + tensor.numel(),
+        [this](T &val) { val = this->template gen_random_private<T>(); });
+  }
+
+  template <typename T> T gen_zero_sharing_arithmetic() {
+    return get_prng(0).get<T>() - get_prng(1).get<T>();
+  }
+
+  template <typename T, template <typename> class Tensor>
+  void gen_zero_sharing_arithmetic(Tensor<T> &tensor) {
+    std::for_each(tensor.data(), tensor.data() + tensor.numel(),
+                  [this](T &val) {
+                    val = this->template gen_zero_sharing_arithmetic<T>();
+                  });
+  }
+
+  template <typename T> T gen_zero_sharing_boolean() {
+    return get_prng(0).get<T>() ^ get_prng(1).get<T>();
+  }
+
+  template <typename T, template <typename> class Tensor>
+  void gen_zero_sharing_boolean(Tensor<T> &tensor) {
+    std::for_each(
+        tensor.data(), tensor.data() + tensor.numel(),
+        [this](T &val) { val = this->template gen_zero_sharing_boolean<T>(); });
+  }
+
+protected:
+  virtual PseudorandomNumberGenerator& get_prng(size_t idx) = 0;
+
+private:
+  size_t _num_party;
+  size_t _party;
+  std::shared_ptr<AbstractNetwork> _network;
+};
+
+} // namespace mpc
+
+} //namespace paddle

core/paddlefl_mpc/mpc_protocol/aby3_operators.h

@@ -21,7 +21,8 @@ limitations under the License. */
 #include "context_holder.h"
 #include "mpc_operators.h"
 #include "paddle/fluid/framework/tensor.h"
-#include "core/privc3/circuit_context.h"
+#include "core/privc3/boolean_tensor.h"
+#include "core/privc3/aby3_context.h"
 #include "core/privc3/fixedpoint_tensor.h"
 #include "core/privc3/boolean_tensor.h"
 #include "core/privc3/paddle_tensor.h"
@@ -30,7 +31,7 @@ namespace paddle {
 namespace mpc {
 
 using paddle::framework::Tensor;
-using aby3::CircuitContext;
+using aby3::ABY3Context;
 // TODO: decide scaling factor
 const size_t ABY3_SCALING_FACTOR = FIXED_POINTER_SCALING_FACTOR;
 using FixedTensor = aby3::FixedPointTensor<int64_t, ABY3_SCALING_FACTOR>;

core/paddlefl_mpc/mpc_protocol/aby3_protocol.cc

@@ -48,7 +48,7 @@ void Aby3Protocol::init_with_store(
   mesh_net->init();
 
   _network = std::move(mesh_net);
-  _circuit_ctx = std::make_shared<CircuitContext>(role, _network);
+  _circuit_ctx = std::make_shared<ABY3Context>(role, _network);
   _operators = std::make_shared<Aby3OperatorsImpl>();
   _is_initialized = true;
 }
@@ -63,7 +63,7 @@ std::shared_ptr<AbstractNetwork> Aby3Protocol::network() {
   return _network;
 }
 
-std::shared_ptr<CircuitContext> Aby3Protocol::mpc_context() {
+std::shared_ptr<AbstractContext> Aby3Protocol::mpc_context() {
   PADDLE_ENFORCE(_is_initialized, PROT_INIT_ERR);
   return _circuit_ctx;
 }

core/paddlefl_mpc/mpc_protocol/aby3_protocol.h

@@ -24,12 +24,13 @@
 #include "mesh_network.h"
 #include "mpc_operators.h"
 #include "mpc_protocol.h"
-#include "core/privc3/circuit_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/abstract_context.h"
+#include "core/privc3/aby3_context.h"
 
 namespace paddle {
 namespace mpc {
 
-using CircuitContext = aby3::CircuitContext;
+using ABY3Context = aby3::ABY3Context;
 
 class Aby3Protocol : public MpcProtocol {
 public:
@@ -46,14 +47,14 @@ public:
 
   std::shared_ptr<AbstractNetwork> network() override;
 
-  std::shared_ptr<CircuitContext> mpc_context() override;
+  std::shared_ptr<AbstractContext> mpc_context() override;
 
 private:
   bool _is_initialized = false;
   const std::string PROT_INIT_ERR = "The protocol is not yet initialized.";
   std::shared_ptr<MpcOperators> _operators;
   std::shared_ptr<AbstractNetwork> _network;
-  std::shared_ptr<CircuitContext> _circuit_ctx;
+  std::shared_ptr<AbstractContext> _circuit_ctx;
 };
 
 } // mpc

core/paddlefl_mpc/mpc_protocol/context_holder.cc

@@ -24,7 +24,7 @@
 namespace paddle {
 namespace mpc {
 
-thread_local std::shared_ptr<CircuitContext> ContextHolder::current_mpc_ctx;
+thread_local std::shared_ptr<AbstractContext> ContextHolder::current_mpc_ctx;
 
 thread_local const ExecutionContext *ContextHolder::current_exec_ctx;
 

core/paddlefl_mpc/mpc_protocol/context_holder.h

@@ -22,20 +22,20 @@
 #pragma once
 
 #include "paddle/fluid/framework/operator.h"
-#include "core/privc3/circuit_context.h"
+#include "core/privc3/aby3_context.h"
 #include "core/privc3/paddle_tensor.h"
 
 namespace paddle {
 namespace mpc {
 
-using CircuitContext = aby3::CircuitContext;
+using ABY3Context = aby3::ABY3Context;
 using ExecutionContext = paddle::framework::ExecutionContext;
 
 class ContextHolder {
 public:
   template <typename Operation>
   static void run_with_context(const ExecutionContext *exec_ctx,
-                               std::shared_ptr<CircuitContext> mpc_ctx,
+                               std::shared_ptr<AbstractContext> mpc_ctx,
                                Operation op) {
 
     // set new ctxs
@@ -60,7 +60,7 @@ public:
     _s_current_tensor_factory = old_factory;
   }
 
-  static std::shared_ptr<CircuitContext> mpc_ctx() { return current_mpc_ctx; }
+  static std::shared_ptr<AbstractContext> mpc_ctx() { return current_mpc_ctx; }
 
   static const ExecutionContext *exec_ctx() { return current_exec_ctx; }
 
@@ -77,7 +77,7 @@ public:
   }
 
 private:
-  thread_local static std::shared_ptr<CircuitContext> current_mpc_ctx;
+  thread_local static std::shared_ptr<AbstractContext> current_mpc_ctx;
 
   thread_local static const ExecutionContext *current_exec_ctx;
 

core/paddlefl_mpc/mpc_protocol/mpc_instance_test.cc

@@ -19,7 +19,6 @@
 
 #include "aby3_protocol.h"
 #include "mpc_protocol_factory.h"
-#include "core/privc3/circuit_context.h"
 #include "gtest/gtest.h"
 
 namespace paddle {

core/paddlefl_mpc/mpc_protocol/mpc_protocol.h

@@ -21,7 +21,7 @@
 #include "gloo/rendezvous/hash_store.h"
 #include "mpc_config.h"
 #include "mpc_operators.h"
-#include "core/privc3/circuit_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/abstract_context.h"
 
 namespace paddle {
 namespace mpc {
@@ -44,7 +44,7 @@ public:
 
   virtual std::shared_ptr<AbstractNetwork> network() = 0;
 
-  virtual std::shared_ptr<aby3::CircuitContext> mpc_context() = 0;
+  virtual std::shared_ptr<AbstractContext> mpc_context() = 0;
 
 private:
   const std::string _name;

core/paddlefl_mpc/mpc_protocol/mpc_protocol_test.cc

@@ -17,7 +17,6 @@
 #include "aby3_protocol.h"
 #include "mpc_config.h"
 #include "mpc_protocol_factory.h"
-#include "core/privc3/circuit_context.h"
 #include "gtest/gtest.h"
 
 namespace paddle {

core/paddlefl_mpc/operators/mpc_op.h

@@ -19,7 +19,7 @@ limitations under the License. */
 #include "paddle/fluid/framework/operator.h"
 #include "core/paddlefl_mpc/mpc_protocol/mpc_instance.h"
 #include "core/paddlefl_mpc/mpc_protocol/context_holder.h"
-#include "core/privc3/circuit_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/abstract_context.h"
 
 namespace paddle {
 namespace operators {
@@ -32,7 +32,7 @@ public:
         PADDLE_ENFORCE_NOT_NULL(mpc::MpcInstance::mpc_instance()->mpc_protocol(),
                                 "Mpc protocol is not yet initialized in executor");
 
-        std::shared_ptr<aby3::CircuitContext> mpc_ctx(mpc::MpcInstance::mpc_instance()->mpc_protocol()->mpc_context());
+        std::shared_ptr<mpc::AbstractContext> mpc_ctx(mpc::MpcInstance::mpc_instance()->mpc_protocol()->mpc_context());
         mpc::ContextHolder::template run_with_context<>(&ctx, mpc_ctx,
                 [&] { ComputeImpl(ctx); });
     }

core/privc/privc_context.h

+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <algorithm>
+#include <algorithm>
+#include <memory>
+
+#include "core/paddlefl_mpc/mpc_protocol/abstract_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/abstract_network.h"
+#include "prng_utils.h"
+
+namespace aby3 {
+
+using AbstractNetwork = paddle::mpc::AbstractNetwork;
+using AbstractContext = paddle::mpc::AbstractContext;
+
+class PrivCContext : public AbstractContext {
+public:
+  PrivCContext(size_t party, std::shared_ptr<AbstractNetwork> network,
+                 block seed = g_zero_block):
+                 AbstractContext::AbstractContext(party, network) {
+    set_num_party(2);
+
+    if (psi::equals(seed, psi::g_zero_block)) {
+      seed = psi::block_from_dev_urandom();
+    }
+    set_random_seed(seed, 0);
+  }
+
+  PrivCContext(const PrivCContext &other) = delete;
+
+  PrivCContext &operator=(const PrivCContext &other) = delete;
+
+protected:
+  PseudorandomNumberGenerator& get_prng(size_t idx) override {
+    return _prng;
+  }
+private:
+  PseudorandomNumberGenerator _prng;
+};
+
+} // namespace aby3

core/privc3/aby3_context.h

+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <algorithm>
+#include <algorithm>
+#include <memory>
+
+#include "core/paddlefl_mpc/mpc_protocol/abstract_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/abstract_network.h"
+#include "prng_utils.h"
+
+namespace aby3 {
+
+using AbstractNetwork = paddle::mpc::AbstractNetwork;
+using AbstractContext = paddle::mpc::AbstractContext;
+
+class ABY3Context : public AbstractContext {
+public:
+  ABY3Context(size_t party, std::shared_ptr<AbstractNetwork> network,
+                 block seed = g_zero_block,
+                 block seed2 = g_zero_block) :
+                 AbstractContext::AbstractContext(party, network) {
+    set_num_party(3);
+
+    if (psi::equals(seed, psi::g_zero_block)) {
+      seed = psi::block_from_dev_urandom();
+    }
+
+    if (psi::equals(seed2, psi::g_zero_block)) {
+      seed2 = psi::block_from_dev_urandom();
+    }
+    set_random_seed(seed, 0);
+    // seed2 is private
+    set_random_seed(seed2, 2);
+
+    // 3 for 3-party computation
+    size_t party_pre = pre_party();
+    size_t party_next = next_party();
+
+    if (party == 1) {
+      block recv_seed = this->network()->template recv<block>(party_next);
+      this->network()->template send(party_pre, seed);
+      seed = recv_seed;
+    } else {
+      this->network()->template send(party_pre, seed);
+      seed = this->network()->template recv<block>(party_next);
+    }
+
+    set_random_seed(seed, 1);
+  }
+
+  ABY3Context(const ABY3Context &other) = delete;
+
+  ABY3Context &operator=(const ABY3Context &other) = delete;
+protected:
+  PseudorandomNumberGenerator& get_prng(size_t idx) override {
+    return _prng[idx];
+  }
+private:
+  PseudorandomNumberGenerator _prng[3];
+};
+
+} // namespace aby3

core/privc3/boolean_tensor.h

@@ -122,9 +122,9 @@ public:
     void onehot_from_cmp();
 
 private:
-    static inline std::shared_ptr<CircuitContext> aby3_ctx() {
-        return paddle::mpc::ContextHolder::mpc_ctx();
-    }
+  static inline std::shared_ptr<AbstractContext> aby3_ctx() {
+    return paddle::mpc::ContextHolder::mpc_ctx();
+  }
 
     static inline std::shared_ptr<TensorAdapterFactory> tensor_factory() {
         return paddle::mpc::ContextHolder::tensor_factory();

core/privc3/boolean_tensor_impl.h

@@ -15,6 +15,7 @@
 #pragma once
 
 #include <algorithm>
+#include "core/privc3/ot.h"
 
 namespace aby3 {
 
@@ -268,7 +269,7 @@ void BooleanTensor<T>::ppa(const BooleanTensor* rhs,
 }
 
 template<typename T, size_t N>
-void a2b(CircuitContext* aby3_ctx,
+void a2b(AbstractContext* aby3_ctx,
          TensorAdapterFactory* tensor_factory,
          const FixedPointTensor<T, N>* a,
          BooleanTensor<T>* b,
@@ -432,9 +433,9 @@ void BooleanTensor<T>::mul(const TensorAdapter<T>* rhs,
         m[0]->add(tmp[0], m[0]);
         m[1]->add(tmp[0], m[1]);
 
-        aby3_ctx()->template ot(idx0, idx1, idx2, null_arg[0],
-                                const_cast<const aby3::TensorAdapter<T>**>(m),
-                                tmp, null_arg[0]);
+        ObliviousTransfer::ot(idx0, idx1, idx2, null_arg[0],
+                    const_cast<const aby3::TensorAdapter<T>**>(m),
+                    tmp, null_arg[0]);
 
         // ret0 = s2
         // ret1 = s1
@@ -445,18 +446,18 @@ void BooleanTensor<T>::mul(const TensorAdapter<T>* rhs,
         // ret0 = s1
         aby3_ctx()->template gen_zero_sharing_arithmetic(*(ret->mutable_share(0)));
         // ret1 = a * b + s0
-        aby3_ctx()->template ot(idx0, idx1, idx2, share(1),
-                                const_cast<const aby3::TensorAdapter<T>**>(null_arg),
-                                tmp, ret->mutable_share(1));
+        ObliviousTransfer::ot(idx0, idx1, idx2, share(1),
+                    const_cast<const aby3::TensorAdapter<T>**>(null_arg),
+                    tmp, ret->mutable_share(1));
         aby3_ctx()->network()->template send(idx0, *(ret->share(0)));
         aby3_ctx()->network()->template send(idx2, *(ret->share(1)));
     } else if (party() == idx2) {
         // ret0 = a * b + s0
         aby3_ctx()->template gen_zero_sharing_arithmetic(*(ret->mutable_share(1)));
         // ret1 = s2
-        aby3_ctx()->template ot(idx0, idx1, idx2, share(0),
-                                const_cast<const aby3::TensorAdapter<T>**>(null_arg),
-                                tmp, null_arg[0]);
+        ObliviousTransfer::ot(idx0, idx1, idx2, share(0),
+                    const_cast<const aby3::TensorAdapter<T>**>(null_arg),
+                    tmp, null_arg[0]);
 
         aby3_ctx()->network()->template send(idx0, *(ret->share(1)));
 

core/privc3/boolean_tensor_test.cc

@@ -27,19 +27,20 @@
 #include "boolean_tensor.h"
 #include "fixedpoint_tensor.h"
 #include "paddle_tensor.h"
-#include "circuit_context.h"
+#include "aby3_context.h"
 #include "core/paddlefl_mpc/mpc_protocol/mesh_network.h"
 
 namespace aby3 {
 
 using paddle::framework::Tensor;
+using AbstractContext = paddle::mpc::AbstractContext;
 
 class BooleanTensorTest : public ::testing::Test {
 public:
     paddle::platform::CPUDeviceContext _cpu_ctx;
 
     std::shared_ptr<paddle::framework::ExecutionContext> _exec_ctx;
-    std::shared_ptr<CircuitContext> _mpc_ctx[3];
+    std::shared_ptr<AbstractContext> _mpc_ctx[3];
 
     std::shared_ptr<gloo::rendezvous::HashStore> _store;
 
@@ -83,7 +84,7 @@ public:
     void gen_mpc_ctx(size_t idx) {
         auto net = gen_network(idx);
         net->init();
-        _mpc_ctx[idx] = std::make_shared<CircuitContext>(idx, net);
+        _mpc_ctx[idx] = std::make_shared<ABY3Context>(idx, net);
     }
 
     std::shared_ptr<TensorAdapter<int64_t>> gen1() {

core/privc3/circuit_context.h

-// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include <algorithm>
-#include <memory>
-
-#include "core/paddlefl_mpc/mpc_protocol/abstract_network.h"
-#include "prng_utils.h"
-
-namespace aby3 {
-
-using AbstractNetwork = paddle::mpc::AbstractNetwork;
-
-class CircuitContext {
-public:
-    CircuitContext(size_t party,
-                   std::shared_ptr<AbstractNetwork> network,
-                   const block& seed = g_zero_block,
-                   const block& seed2 = g_zero_block) {
-        init(party, network, seed, seed2);
-    }
-
-    CircuitContext(const CircuitContext& other) = delete;
-
-    CircuitContext& operator=(const CircuitContext& other) = delete;
-
-    void init(size_t party,
-              std::shared_ptr<AbstractNetwork> network,
-              block seed,
-              block seed2) {
-        set_party(party);
-        set_network(network);
-
-        if (equals(seed, g_zero_block)) {
-            seed = block_from_dev_urandom();
-        }
-
-        if (equals(seed2, g_zero_block)) {
-            seed2 = block_from_dev_urandom();
-        }
-        set_random_seed(seed, 0);
-        // seed2 is private
-        set_random_seed(seed2, 2);
-
-        // 3 for 3-party computation
-        size_t party_pre = (this->party() - 1 + 3) % 3;
-        size_t party_next = (this->party() + 1) % 3;
-
-        if (party == 1) {
-            block recv_seed = this->network()->template recv<block>(party_next);
-            this->network()->template send(party_pre, seed);
-            seed = recv_seed;
-        } else {
-            this->network()->template send(party_pre, seed);
-            seed = this->network()->template recv<block>(party_next);
-        }
-
-        set_random_seed(seed, 1);
-    }
-
-    void set_party(size_t party) {
-        if (party >= 3) {
-            // exception handling
-        }
-        _party = party;
-    }
-
-    void set_network(std::shared_ptr<AbstractNetwork> network) {
-        _network = network;
-    }
-
-    AbstractNetwork* network() {
-        return _network.get();
-    }
-
-    void set_random_seed(const block& seed, size_t idx) {
-        if (idx >= 3) {
-            // exception handling
-        }
-        _prng[idx].set_seed(seed);
-    }
-
-    size_t party() const {
-        return _party;
-    }
-
-    size_t pre_party() const {
-        return (_party + 3 - 1) % 3;
-    }
-
-    size_t next_party() const {
-        return (_party + 1) % 3;
-    }
-
-    template <typename T>
-    T gen_random(bool next) {
-        return _prng[next].get<T>();
-    }
-
-    template<typename T, template <typename> class Tensor>
-    void gen_random(Tensor<T>& tensor, bool next) {
-        std::for_each(tensor.data(), tensor.data() + tensor.numel(),
-                      [this, next](T& val) {
-                          val = this->template gen_random<T>(next);
-                      });
-    }
-
-    template <typename T>
-    T gen_random_private() {
-        return _prng[2].get<T>();
-    }
-
-    template<typename T, template <typename> class Tensor>
-    void gen_random_private(Tensor<T>& tensor) {
-        std::for_each(tensor.data(), tensor.data() + tensor.numel(),
-                      [this](T& val) {
-                          val = this->template gen_random_private<T>();
-                      });
-    }
-
-    template <typename T>
-    T gen_zero_sharing_arithmetic() {
-        return _prng[0].get<T>() - _prng[1].get<T>();
-    }
-
-    template<typename T, template <typename> class Tensor>
-    void gen_zero_sharing_arithmetic(Tensor<T>& tensor) {
-        std::for_each(tensor.data(), tensor.data() + tensor.numel(),
-                      [this](T& val) {
-                          val = this->template gen_zero_sharing_arithmetic<T>();
-                      });
-    }
-
-    template <typename T>
-    T gen_zero_sharing_boolean() {
-        return _prng[0].get<T>() ^ _prng[1].get<T>();
-    }
-
-    template<typename T, template <typename> class Tensor>
-    void gen_zero_sharing_boolean(Tensor<T>& tensor) {
-        std::for_each(tensor.data(), tensor.data() + tensor.numel(),
-                      [this](T& val) {
-                          val = this->template gen_zero_sharing_boolean<T>();
-                      });
-    }
-
-    template<typename T, template <typename> class Tensor>
-    void ot(size_t sender, size_t receiver, size_t helper,
-            const Tensor<T>* choice, const Tensor<T>* m[2],
-            Tensor<T>* buffer[2], Tensor<T>* ret) {
-        // TODO: check tensor shape equals
-        const size_t numel = buffer[0]->numel();
-        if (party() == sender) {
-            bool common = helper == next_party();
-            this->template gen_random(*buffer[0], common);
-            this->template gen_random(*buffer[1], common);
-            for (size_t i = 0; i < numel; ++i) {
-                buffer[0]->data()[i] ^= m[0]->data()[i];
-                buffer[1]->data()[i] ^= m[1]->data()[i];
-            }
-            network()->template send(receiver, *buffer[0]);
-            network()->template send(receiver, *buffer[1]);
-
-        } else if (party() == helper) {
-            bool common = sender == next_party();
-
-            this->template gen_random(*buffer[0], common);
-            this->template gen_random(*buffer[1], common);
-
-            for (size_t i = 0; i < numel; ++i) {
-                buffer[0]->data()[i] = choice->data()[i] & 1 ?
-                    buffer[1]->data()[i] : buffer[0]->data()[i];
-            }
-            network()->template send(receiver, *buffer[0]);
-        } else if (party() == receiver) {
-            network()->template recv(sender, *buffer[0]);
-            network()->template recv(sender, *buffer[1]);
-            network()->template recv(helper, *ret);
-            size_t i = 0;
-            std::for_each(ret->data(), ret->data() + numel, [&buffer, &i, choice, ret](T& in) {
-                          bool c = choice->data()[i] & 1;
-                          in ^= buffer[c]->data()[i];
-                          ++i;}
-                          );
-        }
-    }
-
-private:
-    size_t _party;
-
-    std::shared_ptr<AbstractNetwork> _network;
-
-    PseudorandomNumberGenerator _prng[3];
-
-};
-
-} // namespace aby3

core/privc3/fixedpoint_tensor.h

@@ -16,7 +16,9 @@
 
 #include <vector>
 
-#include "circuit_context.h"
+#include "boolean_tensor.h"
+#include "aby3_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/context_holder.h"
 #include "paddle_tensor.h"
 #include "boolean_tensor.h"
 #include "core/paddlefl_mpc/mpc_protocol/context_holder.h"
@@ -195,9 +197,8 @@ public:
                         size_t scaling_factor);
 
 private:
-
-    static inline std::shared_ptr<CircuitContext> aby3_ctx() {
-        return paddle::mpc::ContextHolder::mpc_ctx();
+    static inline std::shared_ptr<AbstractContext> aby3_ctx() {
+      return paddle::mpc::ContextHolder::mpc_ctx();
     }
 
     static inline std::shared_ptr<TensorAdapterFactory> tensor_factory() {

core/privc3/fixedpoint_tensor_test.cc

@@ -20,21 +20,23 @@ limitations under the License. */
 #include "paddle/fluid/framework/operator.h"
 #include "paddle/fluid/framework/scope.h"
 
+#include "aby3_context.h"
 #include "core/paddlefl_mpc/mpc_protocol/mesh_network.h"
 #include "core/paddlefl_mpc/mpc_protocol/context_holder.h"
 #include "fixedpoint_tensor.h"
 
 namespace aby3 {
 
-    using g_ctx_holder = paddle::mpc::ContextHolder;
-    using Fix64N16 = FixedPointTensor<int64_t, 16>;
+using g_ctx_holder = paddle::mpc::ContextHolder;
+using Fix64N16 = FixedPointTensor<int64_t, 16>;
+using AbstractContext = paddle::mpc::AbstractContext;
 
 class FixedTensorTest : public ::testing::Test {
 public:
 
     paddle::platform::CPUDeviceContext _cpu_ctx;
     std::shared_ptr<paddle::framework::ExecutionContext> _exec_ctx;
-    std::shared_ptr<CircuitContext> _mpc_ctx[3];
+    std::shared_ptr<AbstractContext> _mpc_ctx[3];
     std::shared_ptr<gloo::rendezvous::HashStore> _store;
     std::thread _t[3];
     std::shared_ptr<TensorAdapterFactory> _s_tensor_factory;
@@ -71,7 +73,7 @@ public:
     void gen_mpc_ctx(size_t idx) {
         auto net = gen_network(idx);
         net->init();
-        _mpc_ctx[idx] = std::make_shared<CircuitContext>(idx, net);
+        _mpc_ctx[idx] = std::make_shared<ABY3Context>(idx, net);
     }
 
     std::shared_ptr<TensorAdapter<int64_t>> gen(std::vector<size_t> shape) {

core/privc3/ot.h

+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "core/paddlefl_mpc/mpc_protocol/abstract_context.h"
+#include "core/paddlefl_mpc/mpc_protocol/context_holder.h"
+
+namespace aby3 {
+
+class ObliviousTransfer {
+  public:
+  template<typename T, template <typename> class Tensor>
+  static inline void ot(size_t sender, size_t receiver, size_t helper,
+                  const Tensor<T>* choice, const Tensor<T>* m[2],
+                  Tensor<T>* buffer[2], Tensor<T>* ret) {
+    // TODO: check tensor shape equals
+    auto aby3_ctx = paddle::mpc::ContextHolder::mpc_ctx();
+    const size_t numel = buffer[0]->numel();
+    if (aby3_ctx->party() == sender) {
+      bool common = helper == aby3_ctx->next_party();
+      aby3_ctx->template gen_random(*buffer[0], common);
+      aby3_ctx->template gen_random(*buffer[1], common);
+      for (size_t i = 0; i < numel; ++i) {
+        buffer[0]->data()[i] ^= m[0]->data()[i];
+        buffer[1]->data()[i] ^= m[1]->data()[i];
+      }
+      aby3_ctx->network()->template send(receiver, *buffer[0]);
+      aby3_ctx->network()->template send(receiver, *buffer[1]);
+
+    } else if (aby3_ctx->party() == helper) {
+      bool common = sender == aby3_ctx->next_party();
+
+      aby3_ctx->template gen_random(*buffer[0], common);
+      aby3_ctx->template gen_random(*buffer[1], common);
+
+      for (size_t i = 0; i < numel; ++i) {
+        buffer[0]->data()[i] = choice->data()[i] & 1 ?
+            buffer[1]->data()[i] : buffer[0]->data()[i];
+      }
+      aby3_ctx->network()->template send(receiver, *buffer[0]);
+    } else if (aby3_ctx->party() == receiver) {
+      aby3_ctx->network()->template recv(sender, *buffer[0]);
+      aby3_ctx->network()->template recv(sender, *buffer[1]);
+      aby3_ctx->network()->template recv(helper, *ret);
+      size_t i = 0;
+      std::for_each(ret->data(), ret->data() + numel, [&buffer, &i, choice, ret](T& in) {
+                    bool c = choice->data()[i] & 1;
+                    in ^= buffer[c]->data()[i];
+                    ++i;}
+                    );
+    }
+  }
+};
+
+} // namespace aby3

core/psi/prng.cc

@@ -21,7 +21,6 @@ namespace psi {
 PseudorandomNumberGenerator::PseudorandomNumberGenerator(const block &seed)
     : _ctr(0), _now_byte(0) {
   set_seed(seed);
-  refill_buffer();
 }
 
 void PseudorandomNumberGenerator::set_seed(const block &b) {
@@ -59,4 +58,10 @@ void PseudorandomNumberGenerator::get_array(void *res, size_t len) {
   }
 }
 
+template <>
+bool PseudorandomNumberGenerator::get<bool>() {
+    uint8_t data;
+    get_array(&data, sizeof(data));
+    return data & 1;
+}
 } // namespace smc

python/paddle_fl/mpc/__init__.py

@@ -69,5 +69,6 @@ from .version import version
 from .layers import mpc_math_op_patch
 from . import input
 from . import initializer
+from . import metrics
 
 mpc_math_op_patch.monkey_patch_mpc_variable()

python/paddle_fl/mpc/data_utils/__init__.py

@@ -17,7 +17,10 @@ Import data_utils module.
 
 from . import aby3
 from . import alignment
+from . import one_hot_encoding
 from .alignment import *
+from .one_hot_encoding import *
 
 __all__ = []
 __all__ += alignment.__all__
+__all__ += one_hot_encoding.__all__

python/paddle_fl/mpc/data_utils/aby3.py

@@ -299,8 +299,8 @@ def transpile(program=None):
                 # process initialized params that should be 0
                 set_tensor_value = np.array([param_tensor, param_tensor]).astype(np.int64)
                 param.get_tensor().set(set_tensor_value, place)
-            else:
-                param.get_tensor().set(np.array(param.get_tensor()).astype('float64'), place)
+            #else:
+            #    param.get_tensor().set(np.array(param.get_tensor()).astype('float64'), place)
 
     # trigger sync to replace old ops.
     op_num = global_block.desc.op_size()
@@ -327,7 +327,7 @@ def _transpile_type_and_shape(block):
         if var.name != "feed" and var.name != "fetch":
             mpc_vars_names.add(var.name)
             if var_name in plain_vars:
-                var.desc.set_dtype(fluid.framework.convert_np_dtype_to_dtype_(np.float64))
+                # var.desc.set_dtype(fluid.framework.convert_np_dtype_to_dtype_(np.float64))
                 continue
             # set mpc param shape = [2, old_shape]
             encrypted_var_shape = (ABY3_SHARE_DIM,) + var.shape
@@ -338,7 +338,7 @@ def _transpile_type_and_shape(block):
     for op in block.ops:
         if _is_supported_op(op.type):
             if op.type == 'fill_constant':
-                op._set_attr(name='shape', val=(2L, 1L))
+                op._set_attr(name='shape', val=(2, 1))
                 # set default MPC value for fill_constant OP
                 op._set_attr(name='value', val=MPC_ONE_SHARE)
                 op._set_attr(name='dtype', val=3)
@@ -389,8 +389,8 @@ def encrypt_model(program, mpc_model_dir=None, model_filename=None):
                     param.get_tensor()._set_dims(mpc_var.shape)
                     set_tensor_value = get_aby3_shares(param_tensor_shares, idx)
                     param.get_tensor().set(set_tensor_value, place)
-                else:
-                    param.get_tensor().set(np.array(param.get_tensor()).astype('float64'), place)
+                #else:
+                #    param.get_tensor().set(np.array(param.get_tensor()).astype('float64'), place)
 
                 param_share_dir = os.path.join(
                     mpc_model_dir, MODEL_SHARE_DIR + "_" + str(idx))
@@ -468,7 +468,7 @@ def decrypt_model(mpc_model_dir, plain_model_path, mpc_model_filename=None, plai
             else:
                 plain_var_shape = mpc_var.shape[1:]
                 mpc_var.desc.set_shape(plain_var_shape)
-                mpc_var.desc.set_dtype(fluid.framework.convert_np_dtype_to_dtype_(np.float32))
+                #mpc_var.desc.set_dtype(fluid.framework.convert_np_dtype_to_dtype_(np.float32))
 
     # remove init op
     first_mpc_op = global_block.ops[0]
@@ -482,7 +482,7 @@ def decrypt_model(mpc_model_dir, plain_model_path, mpc_model_filename=None, plai
             new_type = str(mpc_op.type)[len(MPC_OP_PREFIX):]
             mpc_op.desc.set_type(new_type)
         elif mpc_op.type == 'fill_constant':
-            mpc_op._set_attr(name='shape', val=(1L))
+            mpc_op._set_attr(name='shape', val=(1))
             mpc_op._set_attr(name='value', val=1.0)
             mpc_op._set_attr(name='dtype', val=5)
 

python/paddle_fl/mpc/data_utils/one_hot_encoding.py

+
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+This module provide one hot encoding tools, implemented by OT (Oblivious Transfer)-based
+PSI (Private Set Intersection) algorithm.
+"""
+from multiprocessing.connection import Client, Listener
+import mpc_data_utils as mdu
+
+__all__ = ['one_hot_encoding_map', ]
+
+
+def one_hot_encoding_map(input_set, host_addr, is_client=True):
+    """
+    A protocol to get agreement between 2 parties for encoding one
+    discrete feature to one hot vector via OT-PSI.
+
+    Args:
+        input_set (set:str): The set of possible feature value owned by this
+        party. Element of set is str, convert before pass in.
+
+        host_addr (str): The info of host_addr,e.g., ip:port
+
+        is_receiver (bool): True if this party plays as socket client
+        otherwise, plays as socket server
+
+    Return Val: dict, int.
+        dict key: feature values in input_set,
+        dict value: corresponding idx in one hot vector.
+
+        int: length of one hot vector for this feature.
+
+    Examples:
+        .. code-block:: python
+
+            import paddle_fl.mpc.data_utils
+            import sys
+
+            is_client = sys.argv[1] == "1"
+
+            a = set([str(x) for x in range(7)])
+            b = set([str(x) for x in range(5, 10)])
+
+            addr = "127.0.0.1:33784"
+
+            ins = a if is_client else b
+
+            x, y = paddle_fl.mpc.data_utils.one_hot_encoding_map(ins, addr, is_client)
+            # y = 10
+            # x['5'] = 0, x['6'] = 1
+            # for those feature val owned only by one party, dict val shall
+            not be conflicting.
+            print(x, y)
+    """
+
+    ip = host_addr.split(":")[0]
+    port = int(host_addr.split(":")[1])
+
+    if is_client:
+        intersection = input_set
+        intersection = mdu.recv_psi(ip, port, intersection)
+        intersection = sorted(list(intersection))
+        # Only the receiver can obtain the result.
+        # Send result to other parties.
+    else:
+        ret_code = mdu.send_psi(port, input_set)
+        if ret_code != 0:
+            raise RuntimeError("Errors occurred in PSI send lib, "
+                               "error code = {}".format(ret_code))
+
+    if not is_client:
+        server = Listener((ip, port))
+    conn = Client((ip, port)) if is_client else server.accept()
+
+
+    if is_client:
+        conn.send(intersection)
+
+        diff_size_local = len(input_set) - len(intersection)
+        conn.send(diff_size_local)
+        diff_size_remote = conn.recv()
+
+    else:
+        intersection = conn.recv()
+
+        diff_size_local = len(input_set) - len(intersection)
+
+        diff_size_remote = conn.recv()
+        conn.send(diff_size_local)
+
+    conn.close()
+    if not is_client:
+        server.close()
+
+    ret = dict()
+
+    cnt = 0
+
+    for x in intersection:
+        ret[x] = cnt
+        cnt += 1
+    if is_client:
+        cnt += diff_size_remote
+    for x in [x for x in input_set if x not in intersection]:
+        ret[x] = cnt
+        cnt += 1
+
+    return ret, len(intersection) + diff_size_local + diff_size_remote

python/paddle_fl/mpc/examples/lenet_with_mnist/train_lenet.py

@@ -17,6 +17,7 @@ MNIST CNN Demo (LeNet5)
 
 import sys
 import os
+import errno
 import numpy as np
 import time
 import logging
@@ -117,7 +118,12 @@ def infer():
     """
     mpc_infer_data_dir = "./mpc_infer_data/"
     if not os.path.exists(mpc_infer_data_dir):
-        os.mkdir(mpc_infer_data_dir)
+        try:
+            os.mkdir(mpc_infer_data_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
     prediction_file = mpc_infer_data_dir + "mnist_debug_prediction"
     prediction_file_part = prediction_file + ".part{}".format(role)
 

python/paddle_fl/mpc/examples/logistic_with_mnist/train_fc_sigmoid.py

@@ -17,6 +17,7 @@ MNIST Demo
 
 import sys
 import os
+import errno
 
 import numpy as np
 import time
@@ -99,9 +100,15 @@ print('Mpc Training of Epoch={} Batch_size={}, epoch_cost={:.4f} s'
       .format(epoch_num, BATCH_SIZE, (end_time - start_time)))
 
 # prediction
+
 mpc_infer_data_dir = "./mpc_infer_data/"
 if not os.path.exists(mpc_infer_data_dir):
-    os.mkdir(mpc_infer_data_dir)
+    try:
+        os.mkdir(mpc_infer_data_dir)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+
 prediction_file = mpc_infer_data_dir + "mnist_debug_prediction.part{}".format(role)
 if os.path.exists(prediction_file):
     os.remove(prediction_file)

python/paddle_fl/mpc/examples/logistic_with_mnist/train_fc_softmax.py

@@ -17,6 +17,8 @@ MNIST CNN Demo (LeNet5)
 
 import sys
 import os
+import errno
+
 import numpy as np
 import time
 import logging
@@ -91,7 +93,12 @@ def infer():
     """
     mpc_infer_data_dir = "./mpc_infer_data/"
     if not os.path.exists(mpc_infer_data_dir):
-        os.mkdir(mpc_infer_data_dir)
+        try:
+            os.mkdir(mpc_infer_data_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
     prediction_file = mpc_infer_data_dir + "mnist_debug_prediction"
     prediction_file_part = prediction_file + ".part{}".format(role)
 

python/paddle_fl/mpc/examples/model_decryption/README.md

+## Instructions for PaddleFL-MPC Model Decryption Demo
+
+([简体中文](./README_CN.md)|English)
+
+### 1. Introduction
+
+User can decrypt encrypted model (three model shares) with Paddle-MPC. The decrypted model can be used for training and prediction.
+
+### 2. Usages
+
+How to decrypt and use prediction model:
+
+1. **Decrypt Model**：user decrypts encryped model with api `aby3.decrypt_model`.
+
+   ```python
+   aby3.decrypt_model(mpc_model_dir=mpc_model_dir,
+                      plain_model_path=decrypted_paddle_model_dir,
+                      mpc_model_filename=mpc_model_filename,
+                      plain_model_filename=paddle_model_filename)
+   ```
+
+2. **Predict**：user predicts plaintext data with decrypted model.
+
+  1) Load decrypted model with api `fluid.io.load_inference_model`.
+  
+  ```python
+  infer_prog, feed_names, fetch_targets = fluid.io.load_inference_model(executor=exe,
+                                                                        dirname=decrypted_paddle_model_dir,
+                                                                        model_filename=paddle_model_filename)
+  ```
+  
+  2) Predict plaintext data with decrypted model.
+  
+  ```python
+  results = exe.run(infer_prog,
+                    feed={feed_names[0]: np.array(infer_feature)},
+                    fetch_list=fetch_targets)
+  ```
+
+### 3. Demo
+
+Script `decrypt_inference_model.py` shows model decryption and prediction. Note that, encryption model should be saved in specified directory before running the script. Script `../model_encryption/predict/train_and_encrypt_model.py` can be used to generate encryption model.

python/paddle_fl/mpc/examples/model_decryption/README_CN.md

+## 模型解密使用手册
+
+(简体中文|[English](./README.md))
+
+### 1. 介绍
+
+基于paddle-mpc提供的功能，用户可以实现对MPC密文模型的解密，得到明文模型，然后可以使用明文模型进行再训练/预测。具体地，用户从各方获取密文模型（基于多方训练/更新得到的密文模型）之后，通过调用解密接口可以得到明文模型，该明文模型和paddle模型的功能完全一致。
+
+### 2. 使用方法
+
+由于针对训练、更新和预测模型的解密步骤基本是一致的，所以这里以预测模型的解密为例，介绍模型解密使用的主要步骤。
+
+1. **解密模型**：模型解密需求方从各方获取保存的密文预测模型（即模型分片），使用paddle-mpc提供的模型解密接口`aby3.decrypt_model`解密恢复出明文预测模型。
+
+   假设获取到的三个密文模型分片存放于`mpc_model_dir`目录，使用`aby3.decrypt_model`进行解密，分别指定密文模型的路径和名字，明文模型的存放路径和名字：
+
+   ```python
+   aby3.decrypt_model(mpc_model_dir=mpc_model_dir,
+                      plain_model_path=decrypted_paddle_model_dir,
+                      mpc_model_filename=mpc_model_filename,
+                      plain_model_filename=paddle_model_filename)
+   ```
+
+2. **预测**：使用解密后的预测模型对待预测的数据进行预测，输出预测结果。
+
+  该步骤同paddle预测模型的使用方法一致，首先使用`fluid.io.load_inference_model`加载明文预测模型：
+  
+  ```python
+  infer_prog, feed_names, fetch_targets = fluid.io.load_inference_model(executor=exe,
+                                                                        dirname=decrypted_paddle_model_dir,
+                                                                        model_filename=paddle_model_filename)
+  ```
+  
+  然后进行预测，得到预测结果：
+  
+  ```python
+  results = exe.run(infer_prog,
+                    feed={feed_names[0]: np.array(infer_feature)},
+                    fetch_list=fetch_targets)
+  ```
+
+### 3. 使用示例
+
+脚本`decrypt_and_inference.py`提供了对UCI Housing房价预测模型进行解密并使用的示例，可直接运行`decrypt_inference_model.py`脚本得到预测结果。**需要注意的是**，`decrypt_inference_model.py`脚本中待解密的模型设置为`../model_encryption/predict/train_and_encrypt_model.py`脚本内指定的模型，因此，执行脚本前请确保对应路径下已经存在密文预测模型。
+

python/paddle_fl/mpc/examples/model_decryption/decrypt_and_inference.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Decrypt MPC inference model into paddle model and make prediction.
+"""
+import numpy as np
+import paddle
+import paddle.fluid as fluid
+from paddle_fl.mpc.data_utils import aby3
+
+mpc_model_dir = '../model_encryption/predict/tmp/mpc_models_to_predict'
+mpc_model_filename = 'model_to_predict'
+
+decrypted_paddle_model_dir = './tmp/paddle_inference_model'
+paddle_model_filename = 'decrypted_model'
+
+
+def infer():
+    """
+    Predict with decrypted model.
+    """
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    # Step 1. load decrypted model.
+    infer_prog, feed_names, fetch_targets = fluid.io.load_inference_model(executor=exe,
+                                                                          dirname=decrypted_paddle_model_dir,
+                                                                          model_filename=paddle_model_filename)
+    # Step 2. make prediction
+    batch_size = 10
+    infer_reader = fluid.io.batch(
+        paddle.dataset.uci_housing.test(), batch_size=batch_size)
+    infer_data = next(infer_reader())
+    infer_feat = np.array(
+        [data[0] for data in infer_data]).astype("float32")
+    assert feed_names[0] == 'x'
+    results = exe.run(infer_prog,
+                      feed={feed_names[0]: np.array(infer_feat)},
+                      fetch_list=fetch_targets)
+    print("infer results: (House Price)")
+    for idx, val in enumerate(results[0]):
+        print("%d: %.2f" % (idx, val))
+
+
+if __name__ = '__main__':
+    # decrypt mpc model
+    aby3.decrypt_model(mpc_model_dir=mpc_model_dir,
+                       plain_model_path=decrypted_paddle_model_dir,
+                       mpc_model_filename=mpc_model_filename,
+                       plain_model_filename=paddle_model_filename)
+    print('Successfully decrypt inference model. The decrypted model is saved in: {}'
+          .format(decrypted_paddle_model_dir))
+
+    # infer with decrypted model
+    infer()

python/paddle_fl/mpc/examples/model_encryption/README.md

+## Instructions for PaddleFL-MPC Model Encryption Demo
+
+([简体中文](./README_CN.md)|English)
+
+### 1. Introduction
+
+This document introduces how to run encrypt PaddlePaddle  model, then train or update encrypted model, or predict encrypted data with encrypted model. Model encryption is suitable for protecting training/prediction data and model.
+
+### 2. Scenarios
+
+Model encryption demo contains three scenarios:
+
+*  **Transpile Model and Train**
+
+Each party loads an empty PaddlePadlde model and transpile it into encrypted and empty model. Each party feeds encrypted data to train the encrypted model. Each party can get one share for the encrypted model. PaddlePaddle model can be reconstructed with three encrypted model shares.
+
+*  **Encrypt Pre-trained Model and Update**
+
+Pre-trained model is encryption and distributed to multipel parties. Parties update the encrypted model with encrypted data. PaddlePaddle model can be reconstructed with three encrypted model shares.
+
+*  **Encrypt Pre-trained Model and Predict**
+
+Pre-trained model is encryption and distributed to multipel parties. Parties predict encrypted data with the encrypted model. Prediction output can be reconstructed with three encrypted prediction output shares.
+
+### 3. Usage
+
+#### 3.1 Train a New Model
+
+<img src='images/model_training.png' width = "500" height = "550" align="middle"/>
+
+This figure shows model encryption and training with Paddle-MPC.
+
+1). **Load PaddlePaddle Model**: Users init mpc context with mpc_init OP, then load or define PaddlePaddle network.
+
+   ```python
+   pfl_mpc.init("aby3", role, ip, server, port)
+   [_, _, _, loss] = network.model_network()
+   exe.run(fluid.default_startup_program())
+   ```
+
+2). **Transpile Model**: Users use api `aby3.transpile` to encrypt curent PaddlePaddle model to encrypted model.
+
+   ```python
+   aby3.transpile()
+   ```
+
+3). **Train Model**: Users train encrypted model with encrypted data.
+
+   ```python
+   for epoch_id in range(epoch_num):
+       for mpc_sample in loader():
+           mpc_loss = exe.run(feed=mpc_sample, fetch_list=[loss.name])
+   ```
+
+4). **Save Model**：Users save encrypted model using `aby3.save_trainable_model`.
+
+   ```python
+   aby3.save_trainable_model(exe=exe,
+                             model_dir=model_save_dir,
+                             model_filename=model_filename)
+   ```
+
+5). **Decrypt Model**：PaddlePaddle model can be reconstructed with three model shares (encrypted model). 
+
+#### 3.2 Update Model
+
+<img src='images/model_updating.png' width = "500" height = "380" align="middle"/>
+
+This figure shows how to update pre-trained model with Paddle-MPC.
+
+1). **Pre-train Model**: PaddlePaddle model is trained with plaintext data.
+
+2). **Encrypt Model**: User encrypts pre-trained model with api `aby3.encrypt_model` and distributes three model shares to three parties.
+
+   ```python
+   # Step 1. Load pre-trained model.
+   main_prog, _, _ = fluid.io.load_inference_model(executor=exe,
+                                                   dirname=paddle_model_dir,
+                                                   model_filename=model_filename)
+   # Step 2. Encrypt pre-trained model.
+   aby3.encrypt_model(program=main_prog,
+                      mpc_model_dir=mpc_model_dir,
+                      model_filename=model_filename)
+   ```
+
+3). **Update Model**：Users init mpc context with mpc_init OP, then load encrypted model with `aby3.load_mpc_model`. Users update the encrypted model with encrypted data.
+
+   ```python
+   # 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
+   for epoch_id in range(epoch_num):
+       for mpc_sample in loader():
+           mpc_loss = exe.run(feed=mpc_sample, fetch_list=[loss.name])
+   ```
+
+4). **Decrypt Model**：User can decrypt model with three model shares. 
+
+#### 3.3 Model Inference
+
+<img src='images/model_infer.png' width = "500" height = "380" align="middle"/>
+
+This figure shows how to predict encryted data with encrypted model.
+
+1). **Train Model**：User trains PaddlePaddle model with plaintext data.
+
+2). **Encrypt Model**: User encrypts model with api `aby3.encrypt_model` and distributes model shares to three users. The api is same with `Update Model`.
+
+3). **Predict/Infer**: Users initialize mpc context with `mpc_init OP`, then load encrypted model with api `aby3.load_mpc_model`. Users predict encryped data with encryted model.
+
+   ```python
+   # Step 1. initialize MPC environment and load MPC model to predict
+   pfl_mpc.init("aby3", role, ip, server, port)
+   infer_prog, feed_names, fetch_targets = 
+   						aby3.load_mpc_model(exe=exe,
+                                   mpc_model_dir=mpc_model_dir,                                                    															  mpc_model_filename=mpc_model_filename, inference=True)
+   
+   # Step 2. MPC predict
+   prediction = exe.run(program=infer_prog, feed={feed_names[0]: np.array(mpc_sample)}, fetch_list=fetch_targets)
+   
+   # Step 3. save prediction results
+   with open(pred_file, 'ab') as f:
+       f.write(np.array(prediction).tostring())
+   ```
+
+4. **Decrypt Model**：User can decrypt model with the model shares. 
+
+### 4. Usage Demo
+
+**Train Model**: Instructions for model encryption and training with PaddleFL-MPC using UCI Housing dataset: [Here](./train).
+**Update Model**: Instructions for pre-trained model encryption and update with Paddle-MPC using UCI Housing dataset: [Here](./update).
+**Predict Model**: Instructions for pre-trained model encryption and prediction with Paddle-MPC using UCI Housing dataset: [Here](./predict).
+

python/paddle_fl/mpc/examples/model_encryption/README_CN.md

+## 模型加密使用手册
+
+(简体中文|[English](./README.md))
+
+### 1. 介绍
+
+基于Paddle-MPC提供的功能，用户可以实现对明文PaddlePaddle模型的加密，然后根据具体需求在加密的模型上使用密文数据进行模型的训练、更新或预测。因此，模型加密可以用于同时保护用户的训练数据和模型的场景。
+
+### 2. 使用场景
+
+根据用户的不同需求，模型加密的使用场景主要包括以下三种：
+
+*  **模型加密后训练**
+
+  多方用户使用各自数据联合进行已有空白模型的训练。在该场景下，各方用户可直接加载模型库中的空白网络模型或自定义的空白网络模型并对其进行加密，各方使用密文训练数据联合进行密文空白模型的训练和保存。训练完成后，各方只拥有密文模型，即明文模型的分片，在需要时可以基于模型分片解密恢复出完整的明文模型。
+
+*  **预训练模型加密后再更新**
+
+  多方用户使用各自新数据联合对现有的预训练模型进行更新。在该场景下，预训练的明文模型经过加密后分发给多方用户，各方用户使用新的密文训练数据联合进行密文模型的更新和保存。更新完成后，各方只拥有明文完整模型的分片，在需要时可以基于模型分片解密恢复出完整的明文模型。
+
+*  **预训练模型加密后预测**
+
+  多方用户使用预测模型对各自数据进行联合预测。在该场景下，明文预测模型经过加密后分发给多方用户，各方用户使用密文模型对密文数据作出联合预测。预测完成后，各方只拥有预测结果的分片，在需要时可以基于分片数据解密恢复出明文预测结果。
+
+### 3. 使用方法
+
+#### 3.1 加密训练新模型
+
+<img src='images/model_training.png' width = "500" height = "550" align="middle"/>
+
+使用Paddle-MPC进行模型加密训练的过程示意图如上，主要方法步骤如下：
+
+1). **加载明文模型**：各方用户使用mpc_init OP初始化MPC环境，然后直接加载模型库中的网络模型或自定义的网络模型并完成参数的初始化。具体API用例为：
+
+   ```python
+   pfl_mpc.init("aby3", role, ip, server, port)
+   [_, _, _, loss] = network.model_network()
+   exe.run(fluid.default_startup_program())
+   ```
+
+2). **模型转换**（加密）：各方使用Paddle-MPC提供的模型转换接口`aby3.transpile`，将明文模型转换（加密）成密文模型。具体API用例为：
+
+   ```python
+   aby3.transpile()
+   ```
+
+3). **联合训练**：各方使用密文训练数据联合进行密文模型的训练。具体API用例为：
+
+   ```python
+   for epoch_id in range(epoch_num):
+       for mpc_sample in loader():
+           mpc_loss = exe.run(feed=mpc_sample, fetch_list=[loss.name])
+   ```
+
+4). **模型保存**：训练完成后，各方使用`aby3.save_trainable_model`接口保存训练好的密文模型。具体API用例为：
+
+   ```python
+   aby3.save_trainable_model(exe=exe,
+                             model_dir=model_save_dir,
+                             model_filename=model_filename)
+   ```
+
+5). **模型解密**：如有需要，模型解密需求方从各方获取保存的密文模型，使用Paddle-MPC提供的模型解密功能解密恢复出明文模型。具体可参考`model_decryption`目录中的介绍。
+
+#### 3.2 模型更新
+
+<img src='images/model_updating.png' width = "500" height = "380" align="middle"/>
+
+使用Paddle-MPC进行模型加密更新的过程示意图如上，主要方法步骤如下：
+
+1). **模型预训练**：使用明文数据完成明文模型的预训练，得到预训练模型并保存。该步骤由预训练模型拥有方执行，是进行模型加密前的预训练操作。
+
+2). **模型加密**：预训练模型拥有方使用Paddle-MPC提供的模型加密接口`aby3.encrypt_model`将预训练模型进行加密。加密得到的三个密文模型（即明文模型分片）分别发送给三个模型更新方保存。具体API用例为：
+
+   ```python
+   # Step 1. Load pre-trained model.
+   main_prog, _, _ = fluid.io.load_inference_model(executor=exe,
+                                                   dirname=paddle_model_dir,
+                                                   model_filename=model_filename)
+   # Step 2. Encrypt pre-trained model.
+   aby3.encrypt_model(program=main_prog,
+                      mpc_model_dir=mpc_model_dir,
+                      model_filename=model_filename)
+   ```
+
+3). **联合更新**：更新模型的三方使用mpc_init OP初始化MPC环境，然后使用Paddle-MPC提供的模型加载接口`aby3.load_mpc_model`加载保存的密文模型，基于密文模型和密文数据进行密文模型的更新并保存更新后的密文模型。具体API用例为：
+
+   ```python
+   # 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
+   for epoch_id in range(epoch_num):
+       for mpc_sample in loader():
+           mpc_loss = exe.run(feed=mpc_sample, fetch_list=[loss.name])
+   ```
+
+4). **模型解密**：如有需要，模型解密需求方从各方获取保存的密文模型，使用Paddle-MPC提供的模型解密功能解密恢复出明文模型。
+
+#### 3.3 模型预测
+
+<img src='images/model_infer.png' width = "500" height = "380" align="middle"/>
+
+使用Paddle-MPC进行模型加密预测的过程示意图如上，主要方法步骤如下：
+
+1). **模型训练**：使用明文数据完成明文预测模型的训练和保存。该步骤由预测模型拥有方执行。
+
+2). **模型加密**：预测模型拥有方使用Paddle-MPC提供的模型加密接口`aby3.encrypt_model`将预测模型进行加密。加密得到的三个密文模型（即明文模型分片）分别发送给三个预测方保存。具体API用例同模型更新中的介绍。
+
+3). **联合预测**：执行预测的三方使用mpc_init OP初始化MPC环境，然后使用Paddle-MPC提供的模型加载接口`aby3.load_mpc_model`加载密文预测模型，基于密文预测模型和密文数据进行预测并保存密文预测结果。具体API用例为：
+
+   ```python
+   # Step 1. initialize MPC environment and load MPC model to predict
+   pfl_mpc.init("aby3", role, ip, server, port)
+   infer_prog, feed_names, fetch_targets = 
+   						aby3.load_mpc_model(exe=exe,
+                                   mpc_model_dir=mpc_model_dir,                                                    															  mpc_model_filename=mpc_model_filename, inference=True)
+   
+   # Step 2. MPC predict
+   prediction = exe.run(program=infer_prog, feed={feed_names[0]: np.array(mpc_sample)}, fetch_list=fetch_targets)
+   
+   # Step 3. save prediction results
+   with open(pred_file, 'ab') as f:
+       f.write(np.array(prediction).tostring())
+   ```
+
+4). **结果解密**：预测结果请求方从各方获取保存的密文预测结果，使用Paddle-mpc提供的数据解密功能解密恢复出明文预测结果。
+
+### 4. 使用示例
+
+**模型训练**: 使用UCI Housing房价预测模型加密训练的示例，请见[这里](./train)。
+**模型更新**: 使用UCI Housing房价预测模型加密更新的示例，请见[这里](./update)。
+**模型预测**: 使用UCI Housing房价预测模型加密预测的示例，请见[这里](./predict)。
+
+  
+
+

python/paddle_fl/mpc/examples/model_encryption/network.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+This module provides a linear regression network.
+"""
+import paddle
+import paddle.fluid as fluid
+
+UCI_BATCH_SIZE = 10
+BATCH_SIZE = 10
+TRAIN_EPOCH = 20
+PADDLE_UPDATE_EPOCH = 10
+MPC_UPDATE_EPOCH = TRAIN_EPOCH - PADDLE_UPDATE_EPOCH
+
+def uci_network():
+    """
+    Build a network for uci housing.
+
+    """
+    x = fluid.data(name='x', shape=[UCI_BATCH_SIZE, 13], dtype='float32')
+    y = fluid.data(name='y', shape=[UCI_BATCH_SIZE, 1], dtype='float32')
+    param_attr = paddle.fluid.param_attr.ParamAttr(name="fc_0.w_0",
+                                                   initializer=fluid.initializer.ConstantInitializer(0.0))
+    bias_attr = paddle.fluid.param_attr.ParamAttr(name="fc_0.b_0")
+    y_pre = fluid.layers.fc(input=x, size=1, param_attr=param_attr, bias_attr=bias_attr)
+    # add infer_program
+    infer_program = fluid.default_main_program().clone(for_test=False)
+    cost = fluid.layers.square_error_cost(input=y_pre, label=y)
+    avg_loss = fluid.layers.mean(cost)
+    optimizer = fluid.optimizer.SGD(learning_rate=0.001)
+    optimizer.minimize(avg_loss)
+    return_list = [x, y, y_pre, avg_loss]
+    return return_list

python/paddle_fl/mpc/examples/model_encryption/predict/README.md

+## Instructions for Pre-trained Model Encryption and Prediction with Paddle-MPC
+
+([简体中文](./README_CN.md)|English)
+
+This document introduces how to encrypt pre-trained plaintext model and predict encrypted data with the encrypted model based on Paddle-MPC.
+
+### 1. Train PaddlePaddle Model, Encrypt, and Save
+
+Train plaintext PaddlePaddle model, encrypt, and save it with the following script.
+
+```bash
+python train_and_encrypt_model.py
+```
+
+### 2. Prepare Data
+
+Run script `../process_data.py` to generate encrypted prediction input data.
+
+### 3. Predict with MPC Model
+
+Predict encrypted data using encrypted model with the following script.
+
+```bash
+bash run_standalone.sh predict_with_mpc_model.py
+```
+
+### 4. Decrypt Prediction Output Data
+
+Decrypt predition output data with the following script.
+
+```bash
+python decrypt_mpc_prediction.py
+```
+

python/paddle_fl/mpc/examples/model_encryption/predict/README_CN.md

+## UCI房价预测模型加密预测
+
+(简体中文|[English](./README.md))
+
+### 1. 训练明文模型并加密保存
+
+使用如下命令完成明文模型的训练、加密和保存：
+
+```bash
+python train_and_encrypt_model.py
+```
+
+### 2. 准备用于预测的加密数据
+
+执行脚本`../process_data.py`加密待预测的数据。
+
+### 3. 加密预测
+
+使用如下命令完成密文模型预测：
+
+```bash
+bash run_standalone.sh predict_with_mpc_model.py
+```
+
+### 4. 解密loss数据验证密文模型预测过程
+
+使用如下命令对保存的预测结果进行解密查看：
+
+```bash
+python decrypt_mpc_prediction.py 
+```
+

python/paddle_fl/mpc/examples/model_encryption/predict/decrypt_mpc_prediction.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Decrypt MPC training loss.
+"""
+import sys
+sys.path.append('..')
+import process_data
+
+print("********decrypted uci_loss*********")
+LOSS_SIZE = 1
+process_data.load_decrypt_data("./tmp/uci_prediction", (LOSS_SIZE,))

python/paddle_fl/mpc/examples/model_encryption/predict/predict_with_mpc_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+MPC prediction.
+"""
+import sys
+import time
+
+import numpy as np
+import paddle.fluid as fluid
+import paddle_fl.mpc as pfl_mpc
+from paddle_fl.mpc.data_utils import aby3
+
+sys.path.append('..')
+import process_data
+import network
+
+
+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("aby3", role, ip, server, port)
+    infer_prog, feed_names, fetch_targets = aby3.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)))
+
+
+if __name__ == '__main__':
+    role, server, port = int(sys.argv[1]), sys.argv[2], int(sys.argv[3])
+    mpc_model_dir = './tmp/mpc_models_to_predict/model_share_{}'.format(role)
+    mpc_model_filename = 'model_to_predict'
+    load_mpc_model_and_predict(role=role,
+                               ip='localhost',
+                               server=server,
+                               port=port,
+                               mpc_model_dir=mpc_model_dir,
+                               mpc_model_filename=mpc_model_filename)

python/paddle_fl/mpc/examples/model_encryption/predict/train_and_encrypt_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Prepare work before MPC model inference, which includes create paddle
+model to inference, and encrypt paddle model into MPC model.
+"""
+import paddle
+import paddle.fluid as fluid
+import sys
+import time
+from paddle_fl.mpc.data_utils import aby3
+
+sys.path.append('..')
+import network
+
+
+def train_infer_model(model_dir, model_filename):
+    """
+    Original Training: train and save paddle inference model.
+
+    """
+    # Step 1. load paddle net
+    [x, y, y_pre, loss] = network.uci_network()
+
+    # Step 2. train
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    exe.run(fluid.default_startup_program())
+    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+    train_reader = paddle.batch(
+        paddle.dataset.uci_housing.train(), batch_size=network.BATCH_SIZE, drop_last=True)
+    start_time = time.time()
+    for epoch_id in range(network.TRAIN_EPOCH):
+        step = 0
+        for data in train_reader():
+            avg_loss = exe.run(feed=feeder.feed(data), fetch_list=[loss.name])
+            if step % 50 == 0:
+                print('Epoch={}, Step={}, Loss={}'.format(epoch_id, step, avg_loss[0]))
+            step += 1
+    end_time = time.time()
+    print('For Prediction: Paddle Training of Epoch={} Batch_size={}, cost time in seconds:{}'
+          .format(network.TRAIN_EPOCH, network.BATCH_SIZE, (end_time - start_time)))
+    # Step 3. save inference model
+    fluid.io.save_inference_model(executor=exe,
+                                  main_program=fluid.default_main_program(),
+                                  dirname=model_dir,
+                                  model_filename=model_filename,
+                                  feeded_var_names=[x.name],
+                                  target_vars=[y_pre])
+
+
+def encrypt_paddle_model(paddle_model_dir, mpc_model_dir, model_filename):
+    """
+    Load, encrypt and save model.
+
+    """
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    # Step 1. Load inference model.
+    main_prog, _, _ = fluid.io.load_inference_model(executor=exe,
+                                                    dirname=paddle_model_dir,
+                                                    model_filename=model_filename)
+    # Step 2. Encrypt inference model.
+    aby3.encrypt_model(program=main_prog,
+                       mpc_model_dir=mpc_model_dir,
+                       model_filename=model_filename)
+
+if __name__ == '__main__':
+    model_to_predict_dir = './tmp/paddle_model_to_predict'
+    model_to_predict_name = 'model_to_predict'
+    train_infer_model(model_dir=model_to_predict_dir,
+                      model_filename=model_to_predict_name)
+    print('Successfully train and save paddle model to predict. The model is saved in: {}.'
+          .format(model_to_predict_dir))
+
+    mpc_model_to_predict_dir = './tmp/mpc_models_to_predict'
+    encrypt_paddle_model(paddle_model_dir=model_to_predict_dir,
+                         mpc_model_dir=mpc_model_to_predict_dir,
+                         model_filename=model_to_predict_name)
+    print('Successfully encrypt paddle model to predict. The encrypted models are saved in: {}.'
+          .format(mpc_model_to_predict_dir))

python/paddle_fl/mpc/examples/model_encryption/process_data.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+This module provides utils for model processing.
+"""
+import os
+import numpy as np
+import six
+import paddle
+import paddle.fluid as fluid
+from paddle_fl.mpc.data_utils import aby3
+
+#BATCH_SIZE = 10
+#TRAIN_EPOCH = 20
+#PADDLE_UPDATE_EPOCH = 10
+#MPC_UPDATE_EPOCH = TRAIN_EPOCH - PADDLE_UPDATE_EPOCH
+
+
+def get_mpc_dataloader(feature_file, label_file, feature_shape, label_shape,
+                   feature_name, label_name, role, batch_size):
+    """
+    Read feature and label training data from files.
+
+    """
+    x = fluid.default_main_program().global_block().var(feature_name)
+    y = fluid.default_main_program().global_block().var(label_name)
+    feature_reader = aby3.load_aby3_shares(feature_file, id=role, shape=feature_shape)
+    label_reader = aby3.load_aby3_shares(label_file, id=role, shape=label_shape)
+    batch_feature = aby3.batch(feature_reader, batch_size, drop_last=True)
+    batch_label = aby3.batch(label_reader, batch_size, drop_last=True)
+    # async data loader
+    loader = fluid.io.DataLoader.from_generator(feed_list=[x, y], capacity=batch_size)
+    batch_sample = paddle.reader.compose(batch_feature, batch_label)
+    place = fluid.CPUPlace()
+    loader.set_batch_generator(batch_sample, places=place)
+    return loader
+
+
+def get_mpc_test_dataloader(feature_file, feature_shape, role, batch_size):
+    """
+    Read feature test data for prediction.
+
+    """
+    feature_reader = aby3.load_aby3_shares(feature_file, id=role, shape=feature_shape)
+    batch_feature = aby3.batch(feature_reader, batch_size, drop_last=True)
+    return batch_feature
+
+
+def load_decrypt_data(filepath, shape):
+    """
+    Load the encrypted data and reconstruct.
+
+    """
+    part_readers = []
+    for id in six.moves.range(3):
+        part_readers.append(
+            aby3.load_aby3_shares(
+                filepath, id=id, shape=shape))
+    aby3_share_reader = paddle.reader.compose(part_readers[0], part_readers[1],
+                                              part_readers[2])
+
+    for instance in aby3_share_reader():
+        p = aby3.reconstruct(np.array(instance))
+        print(p)
+
+
+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")
+
+
+if __name__ == '__main__':
+    mpc_data_dir = "./mpc_data/"
+    if not os.path.exists(mpc_data_dir):
+        os.mkdir(mpc_data_dir)
+    generate_encrypted_data(mpc_data_dir)

python/paddle_fl/mpc/examples/model_encryption/train/README.md

+## Instructions for PaddleFL-MPC Model Encryption and Training
+
+([简体中文](./README_CN.md)|English)
+
+This document introduces how to transpile empty PaddlePaddle model and train the encrypted model based on Paddle-MPC.
+
+### 1. Prepare Data
+
+Run script `../process_data.py` to generate encrypted training and testing data.
+
+### 2. Transpile Model, Train, and Save
+
+Transpile empty PaddlePaddle model into encrypted and empty model, train the encrypted model, and save the trained encrypted model with the following script.
+
+```bash
+bash run_standalone.sh encrypt_and_train_model.py
+```
+
+### 3. Decrypt Loss Data
+
+Decrypt the loss data to test the correctness of mpc training with the following script.
+
+```bash
+python decrypt_mpc_loss.py
+```
+

python/paddle_fl/mpc/examples/model_encryption/train/README_CN.md

+## UCI房价预测模型加密训练
+
+(简体中文|[English](./README.md))
+
+本示例简单介绍了基于PaddleFL-MPC对明文空白模型加密后再训练的使用说明。
+
+### 1. 准备加密数据
+
+执行脚本`../process_data.py`完成训练数据的加密处理。
+
+### 2. 加密空白明文模型并训练保存
+
+使用如下命令完成模型的加密、训练与保存:
+
+```bash
+bash run_standalone.sh encrypt_and_train_model.py
+```
+
+### 3. 解密loss数据验证密文模型训练过程正确性
+
+使用如下命令对训练过程中保存的loss数据进行解密查看，验证训练的正确性：
+
+```bash
+python decrypt_mpc_loss.py
+```
+

python/paddle_fl/mpc/examples/model_encryption/train/decrypt_mpc_loss.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Decrypt MPC training loss.
+"""
+import sys
+sys.path.append('..')
+import process_data
+
+print("********decrypted uci_loss*********")
+LOSS_SIZE = 1
+process_data.load_decrypt_data("./tmp/uci_mpc_loss", (LOSS_SIZE,))

python/paddle_fl/mpc/examples/model_encryption/train/encrypt_and_train_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+MPC training.
+"""
+import numpy as np
+import os
+import sys
+import time
+
+import paddle.fluid as fluid
+import paddle_fl.mpc as pfl_mpc
+from paddle_fl.mpc.data_utils import aby3
+
+sys.path.append('..')
+import network
+import process_data
+
+
+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))
+
+
+role, server, port = int(sys.argv[1]), sys.argv[2], int(sys.argv[3])
+model_save_dir = './tmp/mpc_models_trained/trained_model_share_{}'.format(role)
+trained_model_name = 'mpc_trained_model'
+encrypt_model_and_train(role=role,
+                        ip='localhost',
+                        server=server,
+                        port=port,
+                        model_save_dir=model_save_dir,
+                        model_filename=trained_model_name)

python/paddle_fl/mpc/examples/model_encryption/update/README.md

+## Instructions for Pre-trained Model Encryption and Update with Paddle-MPC
+
+([简体中文](./README_CN.md)|English)
+
+This document introduces how to encrypt pre-trained plaintext model and update it based on Paddle-MPC.
+
+### 1. Train PaddlePaddle Model, Encrypt, and Save
+
+Train plaintext PaddlePaddle model, encrypt, and save with the following script.
+
+```bash
+python train_and_encrypt_model.py
+```
+
+### 2. Prepare Data
+
+Run script `../process_data.py` to generate encrypted training and testing data for updating encrypted model.
+
+### 3. Update MPC Model
+
+Update mpc model with the following script.
+
+```bash
+bash run_standalone.sh update_mpc_model.py
+```
+
+### 4. Decrypt Loss Data
+
+Decrypt the loss data to test the correctness of encrypted model updating by running the following script.
+
+```bash
+python decrypt_mpc_loss.py
+```
+

python/paddle_fl/mpc/examples/model_encryption/update/README_CN.md

+## UCI房价预测模型加密更新
+
+(简体中文|[English](./README.md))
+
+本示例介绍基于PaddleFL-MPC对预训练明文模型加密后再训练更新的使用说明。
+
+### 1. 训练明文模型并加密保存
+
+使用如下命令训练明文模型并加密保存：
+
+```bash
+python train_and_encrypt_model.py
+```
+
+### 2. 准备用于更新模型的加密数据
+
+执行脚本`../process_data.py`生成更新模型所需的加密数据。
+
+### 3. 更新密文模型
+
+使用如下命令训练更新密文模型并保存：
+
+```bash
+bash run_standalone.sh update_mpc_model.py
+```
+
+### 4. 解密loss数据验证密文模型更新过程的正确性
+
+使用如下命令对更新过程中保存的loss数据进行解密查看，验证更新过程的正确性：
+
+```bash
+python decrypt_mpc_loss.py 
+```
+

python/paddle_fl/mpc/examples/model_encryption/update/decrypt_mpc_loss.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Decrypt MPC training loss.
+"""
+import sys
+sys.path.append('..')
+import process_data
+
+print("********decrypted uci_loss*********")
+LOSS_SIZE = 1
+process_data.load_decrypt_data("./tmp/uci_mpc_loss", (LOSS_SIZE,))

python/paddle_fl/mpc/examples/model_encryption/update/train_and_encrypt_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Prepare work before MPC model updating, which includes create paddle
+model to update, and encrypt paddle model into MPC model.
+"""
+import paddle
+import paddle.fluid as fluid
+import time
+import sys
+from paddle_fl.mpc.data_utils import aby3
+
+sys.path.append('..')
+import network
+
+
+def original_train(model_dir, model_filename):
+    """
+    Original Training: train and save pre-trained paddle model
+
+    """
+    # Step 1. load paddle net
+    [x, y, _, loss] = network.uci_network()
+
+    # Step 2. train
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    exe.run(fluid.default_startup_program())
+    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+    train_reader = paddle.batch(
+        paddle.dataset.uci_housing.train(), batch_size=network.BATCH_SIZE, drop_last=True)
+    start_time = time.time()
+    for epoch_id in range(network.PADDLE_UPDATE_EPOCH):
+        step = 0
+        for data in train_reader():
+            avg_loss = exe.run(feed=feeder.feed(data), fetch_list=[loss.name])
+            if step % 50 == 0:
+                print('Epoch={}, Step={}, Loss={}'.format(epoch_id, step, avg_loss[0]))
+            step += 1
+    end_time = time.time()
+    print('Paddle Training of Epoch={} Batch_size={}, cost time in seconds:{}'
+          .format(network.PADDLE_UPDATE_EPOCH, network.BATCH_SIZE, (end_time - start_time)))
+
+    # Step 3. save model to update
+    aby3.save_trainable_model(exe=exe,
+                              program=fluid.default_main_program(),
+                              model_dir=model_dir,
+                              model_filename=model_filename)
+
+
+def encrypt_paddle_model(paddle_model_dir, mpc_model_dir, model_filename):
+    """
+    Load, encrypt and save model.
+
+    """
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    # Step 1. Load pre-trained model.
+    main_prog, _, _ = fluid.io.load_inference_model(executor=exe,
+                                                    dirname=paddle_model_dir,
+                                                    model_filename=model_filename)
+    # Step 2. Encrypt pre-trained model.
+    aby3.encrypt_model(program=main_prog,
+                       mpc_model_dir=mpc_model_dir,
+                       model_filename=model_filename)
+
+
+if __name__ == '__main__':
+
+    # train paddle model
+    model_to_update_dir = './tmp/paddle_model_to_update'
+    model_to_update_name = 'model_to_update'
+    original_train(model_dir=model_to_update_dir,
+                   model_filename=model_to_update_name)
+    print('Successfully train and save paddle model for update. The model is saved in: {}.'
+          .format(model_to_update_dir))
+
+    # encrypt paddle model
+    mpc_model_to_update_dir = './tmp/mpc_models_to_update'
+    encrypt_paddle_model(paddle_model_dir=model_to_update_dir,
+                         mpc_model_dir=mpc_model_to_update_dir,
+                         model_filename=model_to_update_name)
+    print('Successfully encrypt paddle model for update. The encrypted models are saved in: {}.'
+          .format(mpc_model_to_update_dir))

python/paddle_fl/mpc/examples/model_encryption/update/update_mpc_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+MPC updating.
+"""
+import os
+import sys
+import time
+
+import numpy as np
+import paddle.fluid as fluid
+import paddle_fl.mpc as pfl_mpc
+from paddle_fl.mpc.data_utils import aby3
+
+sys.path.append('..')
+import network
+import process_data
+
+
+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))
+
+
+if __name__ == '__main__':
+    role, server, port = int(sys.argv[1]), sys.argv[2], int(sys.argv[3])
+    mpc_model_dir = './tmp/mpc_models_to_update/model_share_{}'.format(role)
+    mpc_model_filename = 'model_to_update'
+    updated_model_dir = './tmp/mpc_models_updated/updated_model_share_{}'.format(role)
+    load_uci_update(role=role,
+                    ip='localhost',
+                    server=server,
+                    port=port,
+                    mpc_model_dir=mpc_model_dir,
+                    mpc_model_filename=mpc_model_filename,
+                    updated_model_dir=updated_model_dir)

python/paddle_fl/mpc/examples/uci_demo/run_standalone.sh

-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-#!/bin/bash
-#
-# A tools to faciliate the parallel running of fluid_encrypted test scrips.
-# A test script is EXPECTED to accepted arguments in the following format:
-#
-# SCRIPT_NAME $ROLE $SERVER $PORT
-#   ROLE:    the role of the running party
-#   SERVER:  the address of the party discovering service
-#   PORT:    the port of the party discovering service
-#
-# This tool will try to fill the above three argument to the test script,
-# so that totally three processes running the script will be started, to
-# simulate run of three party in a standalone machine.
-#
-# Usage of this script:
-#
-# bash run_standalone.sh TEST_SCRIPT_NAME
-#
-
-# modify the following vars according to your environment
-PYTHON=${PYTHON}
-REDIS_HOME=${PATH_TO_REDIS_BIN}
-SERVER=${LOCALHOST}
-PORT=${REDIS_PORT}
-echo "redis home in ${REDIS_HOME}, server is ${SERVER}, port is ${PORT}"
-
-function usage(){
-    echo 'run_standalone.sh SCRIPT_NAME [ARG...]'
-    exit 0
-}
-
-if [ $# -lt 1 ]; then
-    usage
-fi
-
-SCRIPT=$1
-if [ ! -f $SCRIPT ]; then
-    echo 'Could not find script of '$SCRIPT
-    exit 1
-fi
-
-REDIS_BIN=$REDIS_HOME/redis-cli
-if [ ! -f $REDIS_BIN ]; then
-    echo 'Could not find redis cli in '$REDIS_HOME
-    exit 1
-fi
-
-# clear the redis cache
-$REDIS_BIN -h $SERVER -p $PORT flushall
-
-# remove temp data generated in last time
-LOSS_FILE="/tmp/uci_loss.*"
-PRED_FILE="/tmp/uci_prediction.*"
-ls ${LOSS_FILE}
-if [ $? -eq 0 ]; then
-        rm -rf $LOSS_FILE
-fi
-
-ls ${PRED_FILE}
-if [ $? -eq 0 ]; then
-        rm -rf $PRED_FILE
-fi
-
-TRAINING_FILE="/tmp/house_feature.part*"
-ls ${TRAINING_FILE}
-if [ $? -ne 0 ]; then
-    echo "There is no data in /tmp, please prepare data with "python prepare.py" firstly"
-    exit 1
-else
-    echo "There are data for uci:"
-    echo "`ls ${TRAINING_FILE}`"
-fi
-
-# kick off script with roles of 1 and 2, and redirect output to /dev/null
-for role in {1..2}; do
-    $PYTHON $SCRIPT $role $SERVER $PORT 2>&1 >/dev/null &
-done
-
-# for party of role 0, run in a foreground mode and show the output
-$PYTHON $SCRIPT 0 $SERVER $PORT
-

python/paddle_fl/mpc/metrics.py

@@ -50,8 +50,6 @@ class KSstatistic(MetricBase):
 
             import paddle_fl.mpc
             import numpy as np
-            # init the KSstatistic
-            ks = paddle_fl.mpc.metrics.KSstatistic('ks')
 
             # suppose that batch_size is 128
             batch_num = 100
@@ -65,6 +63,10 @@ class KSstatistic(MetricBase):
                 preds = np.concatenate((class0_preds, class1_preds), axis=1)
 
                 labels = np.random.randint(2, size = (batch_size, 1))
+
+                # init the KSstatistic for each batch
+                # to get global ks statistic, init ks before for-loop
+                ks = paddle_fl.mpc.metrics.KSstatistic('ks')
                 ks.update(preds = preds, labels = labels)
 
                 # shall be some score closing to 0.1 as the preds are randomly assigned

python/paddle_fl/mpc/tests/unittests/test_datautils_align.py

@@ -17,14 +17,16 @@ This module test align in aby3 module.
 """
 
 import unittest
-from multiprocessing import Process
+import multiprocessing as mp
 
 import paddle_fl.mpc.data_utils.alignment as alignment
 
 
+
 class TestDataUtilsAlign(unittest.TestCase):
 
-    def run_align(self, input_set, party_id, endpoints, is_receiver):
+    @staticmethod
+    def run_align(input_set, party_id, endpoints, is_receiver, ret_list):
         """
         Call align function in data_utils.
         :param input_set:
@@ -37,7 +39,7 @@ class TestDataUtilsAlign(unittest.TestCase):
                                  party_id=party_id,
                                  endpoints=endpoints,
                                  is_receiver=is_receiver)
-        self.assertEqual(result, {'0'})
+        ret_list.append(result)
 
     def test_align(self):
         """
@@ -49,14 +51,27 @@ class TestDataUtilsAlign(unittest.TestCase):
         set_1 = {'0', '10', '11', '111'}
         set_2 = {'0', '30', '33', '333'}
 
-        party_0 = Process(target=self.run_align, args=(set_0, 0, endpoints, True))
-        party_1 = Process(target=self.run_align, args=(set_1, 1, endpoints, False))
-        party_2 = Process(target=self.run_align, args=(set_2, 2, endpoints, False))
+        mp.set_start_method('spawn')
+
+        manager = mp.Manager()
+        ret_list = manager.list()
+
+        party_0 = mp.Process(target=self.run_align, args=(set_0, 0, endpoints, True, ret_list))
+        party_1 = mp.Process(target=self.run_align, args=(set_1, 1, endpoints, False, ret_list))
+        party_2 = mp.Process(target=self.run_align, args=(set_2, 2, endpoints, False, ret_list))
 
         party_1.start()
         party_2.start()
         party_0.start()
+
         party_0.join()
+        party_1.join()
+        party_2.join()
+
+        self.assertEqual(3, len(ret_list))
+        self.assertEqual(ret_list[0], ret_list[1])
+        self.assertEqual(ret_list[0], ret_list[2])
+        self.assertEqual({'0'}, ret_list[0])
 
 
 if __name__ == '__main__':

python/paddle_fl/mpc/tests/unittests/test_op_conv.py

@@ -156,17 +156,18 @@ def create_test_padding_VALID_class(parent):
             self.pad = [1, 1]
             self.padding_algorithm = "VALID"
         def test_check_grad(self):
-            error = 0.09
-            if parent.__name__ in ["TestConv2dOp_AsyPadding",
-                    "TestWithStride_AsyPadding"]:
-                error = 0.14
-            elif parent.__name__ in ["TestWithInput1x1Filter1x1_AsyPadding"]:
-                error = 0.66
-            place = core.CPUPlace()
-            self.check_grad_with_place(
-                place, {'Input', 'Filter'},
-                'Output',
-                max_relative_error=error)
+            pass
+        #    error = 0.09
+        #    if parent.__name__ in ["TestConv2dOp_AsyPadding",
+        #            "TestWithStride_AsyPadding"]:
+        #        error = 0.14
+        #    elif parent.__name__ in ["TestWithInput1x1Filter1x1_AsyPadding"]:
+        #        error = 0.66
+        #    place = core.CPUPlace()
+        #    self.check_grad_with_place(
+        #        place, {'Input', 'Filter'},
+        #        'Output',
+        #        max_relative_error=error)
 
     cls_name = "{0}_{1}".format(parent.__name__, "PaddingVALIDOp")
     TestPaddingVALIDCase.__name__ = cls_name
@@ -224,21 +225,23 @@ class TestConv2dOp(OpTest):
             'Output',
             max_relative_error=0.07)
 
-    def test_check_grad_no_filter(self):
-        place =  core.CPUPlace()
-        self.check_grad_with_place(
-            place, ['Input'],
-            'Output',
-            max_relative_error=0.07,
-            no_grad_set=set(['Filter']))
-
-    def test_check_grad_no_input(self):
-        place =  core.CPUPlace()
-        self.check_grad_with_place(
-            place, ['Filter'],
-            'Output',
-            max_relative_error=0.06,
-            no_grad_set=set(['Input']))
+    # skip cases for fast ut
+    # to test correctness, uncomment test cases
+    #def test_check_grad_no_filter(self):
+    #    place =  core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, ['Input'],
+    #        'Output',
+    #        max_relative_error=0.07,
+    #        no_grad_set=set(['Filter']))
+
+    #def test_check_grad_no_input(self):
+    #    place =  core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, ['Filter'],
+    #        'Output',
+    #        max_relative_error=0.06,
+    #        no_grad_set=set(['Input']))
 
     def init_test_case(self):
         self.pad = [0, 0]
@@ -270,6 +273,9 @@ class TestWithPad(TestConv2dOp):
         f_c = self.input_size[1] // self.groups
         self.filter_size = [6, f_c, 3, 3]
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithStride(TestConv2dOp):
     def init_test_case(self):
@@ -280,6 +286,9 @@ class TestWithStride(TestConv2dOp):
         f_c = self.input_size[1] // self.groups
         self.filter_size = [6, f_c, 3, 3]
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithGroup(TestConv2dOp):
     def init_test_case(self):
@@ -291,6 +300,9 @@ class TestWithGroup(TestConv2dOp):
         f_c = self.input_size[1] // self.groups
         self.filter_size = [18, f_c, 3, 3]
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWith1x1(TestConv2dOp):
     def init_test_case(self):
@@ -305,19 +317,20 @@ class TestWith1x1(TestConv2dOp):
         self.groups = 3
 
     def test_check_grad(self):
-        place = core.CPUPlace()
-        self.check_grad_with_place(
-            place, {'Input', 'Filter'},
-            'Output',
-            max_relative_error=0.6)
-
-    def test_check_grad_no_filter(self):
-        place =  core.CPUPlace()
-        self.check_grad_with_place(
-            place, ['Input'],
-            'Output',
-            max_relative_error=0.9,
-            no_grad_set=set(['Filter']))
+        pass
+    #    place = core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, {'Input', 'Filter'},
+    #        'Output',
+    #        max_relative_error=0.6)
+
+    #def test_check_grad_no_filter(self):
+    #    place =  core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, ['Input'],
+    #        'Output',
+    #        max_relative_error=0.9,
+    #        no_grad_set=set(['Filter']))
 
 class TestWithDilation(TestConv2dOp):
     def init_test_case(self):
@@ -334,6 +347,9 @@ class TestWithDilation(TestConv2dOp):
     def init_group(self):
         self.groups = 3
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithInput1x1Filter1x1(TestConv2dOp):
     def init_test_case(self):
@@ -348,11 +364,8 @@ class TestWithInput1x1Filter1x1(TestConv2dOp):
         self.groups = 3
 
     def test_check_grad(self):
-        place = core.CPUPlace()
-        self.check_grad_with_place(
-            place, {'Input', 'Filter'},
-            'Output',
-            max_relative_error=0.75)
+        pass
+
 
 class TestConv2dOp_v2(OpTest):
     def setUp(self):
@@ -403,28 +416,28 @@ class TestConv2dOp_v2(OpTest):
         self.check_output_with_place(
             place, atol=1e-3)
 
-    def test_check_grad(self):
-        place = core.CPUPlace()
-        self.check_grad_with_place(
-            place, {'Input', 'Filter'},
-            'Output',
-            max_relative_error=0.14)
-
-    def test_check_grad_no_filter(self):
-        place = core.CPUPlace()
-        self.check_grad_with_place(
-            place, ['Input'],
-            'Output',
-            max_relative_error=0.13,
-            no_grad_set=set(['Filter']))
-
-    def test_check_grad_no_input(self):
-        place = core.CPUPlace()
-        self.check_grad_with_place(
-            place, ['Filter'],
-            'Output',
-            max_relative_error=0.7,
-            no_grad_set=set(['Input']))
+    #def test_check_grad(self):
+    #    place = core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, {'Input', 'Filter'},
+    #        'Output',
+    #        max_relative_error=0.14)
+
+    #def test_check_grad_no_filter(self):
+    #    place = core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, ['Input'],
+    #        'Output',
+    #        max_relative_error=0.13,
+    #        no_grad_set=set(['Filter']))
+
+    #def test_check_grad_no_input(self):
+    #    place = core.CPUPlace()
+    #    self.check_grad_with_place(
+    #        place, ['Filter'],
+    #        'Output',
+    #        max_relative_error=0.7,
+    #        no_grad_set=set(['Input']))
 
     def init_test_case(self):
         self.pad = [0, 0]
@@ -465,6 +478,9 @@ class TestConv2dOp_AsyPadding(TestConv2dOp_v2):
             'Output',
             max_relative_error=0.09)
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithPad_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -478,6 +494,9 @@ class TestWithPad_AsyPadding(TestConv2dOp_v2):
         self.pad = [2, 1, 3, 2]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithStride_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -491,6 +510,9 @@ class TestWithStride_AsyPadding(TestConv2dOp_v2):
         self.pad = [2, 1, 3, 2]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithGroup_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -502,6 +524,9 @@ class TestWithGroup_AsyPadding(TestConv2dOp_v2):
         f_c = self.input_size[1] // self.groups
         self.filter_size = [24, f_c, 4, 3]
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWith1x1_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -518,6 +543,9 @@ class TestWith1x1_AsyPadding(TestConv2dOp_v2):
         self.pad = [2, 2, 4, 0]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithDepthWise3x3_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -537,6 +565,9 @@ class TestWithDepthWise3x3_AsyPadding(TestConv2dOp_v2):
         self.pad = [1, 3, 2, 1]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithDepthWise5x5_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -553,6 +584,9 @@ class TestWithDepthWise5x5_AsyPadding(TestConv2dOp_v2):
         self.pad = [0, 1, 1, 0]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithDepthWise7x7_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -569,6 +603,9 @@ class TestWithDepthWise7x7_AsyPadding(TestConv2dOp_v2):
         self.pad = [1, 3, 4, 1]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithDilation_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -588,6 +625,9 @@ class TestWithDilation_AsyPadding(TestConv2dOp_v2):
         self.pad = [0, 1, 3, 0]
         self.padding_algorithm = "EXPLICIT"
 
+    def test_check_grad(self):
+        pass
+
 
 class TestWithInput1x1Filter1x1_AsyPadding(TestConv2dOp_v2):
     def init_test_case(self):
@@ -605,19 +645,7 @@ class TestWithInput1x1Filter1x1_AsyPadding(TestConv2dOp_v2):
         self.padding_algorithm = "EXPLICIT"
 
     def test_check_grad(self):
-        place = core.CPUPlace()
-        self.check_grad_with_place(
-            place, {'Input', 'Filter'},
-            'Output',
-            max_relative_error=0.7)
-
-    def test_check_grad_no_filter(self):
-        place =  core.CPUPlace()
-        self.check_grad_with_place(
-            place, ['Input'],
-            'Output',
-            max_relative_error=0.7,
-            no_grad_set=set(['Filter']))
+        pass
 
 
 #---------- test SAME VALID -----------

python/paddle_fl/paddle_fl/core/trainer/fl_trainer.py

@@ -124,6 +124,21 @@ class FLTrainer(object):
         with open(model_path + ".pdmodel", "wb") as f:
             f.write(self._main_program.desc.serialize_to_string())
 
+    def save_serving_model(self, model_path, client_conf_path):
+        feed_vars = {}
+        target_vars = {}
+        for target in self._target_names:
+            tmp_target = self._main_program.block(0)._find_var_recursive(
+                target)
+            target_vars[target] = tmp_target
+
+        for feed in self._feed_names:
+            tmp_feed = self._main_program.block(0)._find_var_recursive(feed)
+            feed_vars[feed] = tmp_feed
+
+        serving_io.save_model(model_path, client_conf_path, feed_vars,
+                              target_vars, self._main_program)
+
     def stop(self):
         # ask for termination with master endpoint
         # currently not open sourced, will release the code later

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/client.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+from paddle_serving_client import Client
+
+client = Client()
+client.load_client_config("imdb_client_conf/serving_client_conf.prototxt")
+client.connect(["127.0.0.1:9292"])
+
+data_dict = {}
+
+for i in range(3):
+    data_dict[str(i)] = np.random.rand(1, 5).astype('float32')
+
+fetch_map = client.predict(
+    feed={"0": data_dict['0'],
+          "1": data_dict['1'],
+          "2": data_dict['2']},
+    fetch=["fc_2.tmp_2"])
+
+print("fetched result: ", fetch_map)

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/fl_master.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle.fluid as fluid
+import paddle_fl.paddle_fl as fl
+from paddle_fl.paddle_fl.core.master.job_generator import JobGenerator
+from paddle_fl.paddle_fl.core.strategy.fl_strategy_base import FLStrategyFactory
+
+
+class Model(object):
+    def __init__(self):
+        pass
+
+    def mlp(self, inputs, label, hidden_size=128):
+        self.concat = fluid.layers.concat(inputs, axis=1)
+        self.fc1 = fluid.layers.fc(input=self.concat, size=256, act='relu')
+        self.fc2 = fluid.layers.fc(input=self.fc1, size=128, act='relu')
+        self.predict = fluid.layers.fc(input=self.fc2, size=2, act='softmax')
+        self.sum_cost = fluid.layers.cross_entropy(
+            input=self.predict, label=label)
+        self.accuracy = fluid.layers.accuracy(input=self.predict, label=label)
+        self.loss = fluid.layers.reduce_mean(self.sum_cost)
+        self.startup_program = fluid.default_startup_program()
+
+inputs = [fluid.layers.data( \
+            name=str(slot_id), shape=[5],
+            dtype="float32")
+          for slot_id in range(3)]
+label = fluid.layers.data( \
+            name="label",
+            shape=[1],
+            dtype='int64')
+
+model = Model()
+model.mlp(inputs, label)
+
+job_generator = JobGenerator()
+optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+job_generator.set_optimizer(optimizer)
+job_generator.set_losses([model.loss])
+job_generator.set_startup_program(model.startup_program)
+job_generator.set_infer_feed_and_target_names([x.name for x in inputs],
+                                              [model.predict.name])
+
+build_strategy = FLStrategyFactory()
+build_strategy.fed_avg = True
+build_strategy.inner_step = 10
+strategy = build_strategy.create_fl_strategy()
+
+# endpoints will be collected through the cluster
+# in this example, we suppose endpoints have been collected
+endpoints = ["127.0.0.1:8181"]
+output = "fl_job_config"
+job_generator.generate_fl_job(
+    strategy, server_endpoints=endpoints, worker_num=2, output=output)
+# fl_job_config will  be dispatched to workers

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/fl_scheduler.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from paddle_fl.paddle_fl.core.scheduler.agent_master import FLScheduler
+
+worker_num = 2
+server_num = 1
+# Define the number of worker/server and the port for scheduler
+scheduler = FLScheduler(worker_num, server_num, port=9091)
+scheduler.set_sample_worker_num(worker_num)
+scheduler.init_env()
+print("init env done.")
+scheduler.start_fl_training()

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/fl_server.py

+#   Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle_fl.paddle_fl as fl
+import paddle.fluid as fluid
+from paddle_fl.paddle_fl.core.server.fl_server import FLServer
+from paddle_fl.paddle_fl.core.master.fl_job import FLRunTimeJob
+server = FLServer()
+server_id = 0
+job_path = "fl_job_config"
+job = FLRunTimeJob()
+job.load_server_job(job_path, server_id)
+job._scheduler_ep = "127.0.0.1:9091"  # IP address for scheduler
+server.set_server_job(job)
+server._current_ep = "127.0.0.1:8181"  # IP address for server
+server.start()

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/fl_trainer.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import paddle.fluid as fluid
+from paddle_fl.paddle_fl.core.trainer.fl_trainer import FLTrainerFactory
+from paddle_fl.paddle_fl.core.master.fl_job import FLRunTimeJob
+import numpy as np
+import paddle_serving_client.io as serving_io
+import sys
+import logging
+import time
+logging.basicConfig(
+    filename="test.log",
+    filemode="w",
+    format="%(asctime)s %(name)s:%(levelname)s:%(message)s",
+    datefmt="%d-%M-%Y %H:%M:%S",
+    level=logging.DEBUG)
+
+
+def reader():
+    for i in range(1000):
+        data_dict = {}
+        for i in range(3):
+            data_dict[str(i)] = np.random.rand(1, 5).astype('float32')
+        data_dict["label"] = np.random.randint(2, size=(1, 1)).astype('int64')
+        yield data_dict
+
+
+trainer_id = int(sys.argv[1])  # trainer id for each guest
+job_path = "fl_job_config"
+job = FLRunTimeJob()
+job.load_trainer_job(job_path, trainer_id)
+job._scheduler_ep = "127.0.0.1:9091"  # Inform the scheduler IP to trainer
+trainer = FLTrainerFactory().create_fl_trainer(job)
+trainer._current_ep = "127.0.0.1:{}".format(9000 + trainer_id)
+place = fluid.CPUPlace()
+trainer.start(place)
+print("scheduler_ep is {}, current_ep is {}".format(trainer._scheduler_ep,
+                                                    trainer._current_ep))
+"""
+feed_vars = {}
+target_vars = {}
+for target in trainer._target_names:
+    tmp_target = trainer._main_program.block(0)._find_var_recursive(target)
+    target_vars[target] = tmp_target
+
+for feed in trainer._feed_names:
+    tmp_feed = trainer._main_program.block(0)._find_var_recursive(feed)
+    feed_vars[feed] = tmp_feed
+"""
+epoch_id = 0
+while not trainer.stop():
+    if epoch_id > 10:
+        break
+    print("{} epoch {} start train".format(
+        time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
+        epoch_id))
+    train_step = 0
+    for data in reader():
+        trainer.run(feed=data, fetch=[])
+        train_step += 1
+        if train_step == trainer._step:
+            break
+    epoch_id += 1
+    if epoch_id % 5 == 0:
+        #        trainer.save_inference_program(output_folder)
+        trainer.save_serving_model("test", "imdb_client_conf")
+#        serving_io.save_model("test","imdb_client_conf", feed_vars, target_vars, trainer._main_program)

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/run.sh

+unset http_proxy
+unset https_proxy
+ps -ef | grep -E fl_ | grep -v grep | awk '{print $2}' | xargs kill -9
+
+log_dir=${1:-$(pwd)}
+mkdir -p ${log_dir}
+
+python fl_master.py > ${log_dir}/master.log &
+sleep 2
+python -u fl_scheduler.py > ${log_dir}/scheduler.log &
+sleep 5
+python -u fl_server.py > ${log_dir}/server0.log &
+sleep 2
+for ((i=0;i<2;i++))
+do 
+    python -u fl_trainer.py $i > ${log_dir}/trainer$i.log &
+    sleep 2
+done
+	

python/paddle_fl/paddle_fl/examples/deploy_serving_after_training/start_service.sh

+model_dir=$1
+python -m paddle_serving_server.serve --model $model_dir --thread 10 --port 9292 &