Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into add_ut_for_trt

paddle/fluid/API.spec

@@ -54,8 +54,6 @@ paddle.fluid.DistributeTranspiler.get_pserver_programs ArgSpec(args=['self', 'en
 paddle.fluid.DistributeTranspiler.get_startup_program ArgSpec(args=['self', 'endpoint', 'pserver_program', 'startup_program'], varargs=None, keywords=None, defaults=(None, None))
 paddle.fluid.DistributeTranspiler.get_trainer_program ArgSpec(args=['self', 'wait_port'], varargs=None, keywords=None, defaults=(True,))
 paddle.fluid.DistributeTranspiler.transpile ArgSpec(args=['self', 'trainer_id', 'program', 'pservers', 'trainers', 'sync_mode', 'startup_program'], varargs=None, keywords=None, defaults=(None, '127.0.0.1:6174', 1, True, None))
-paddle.fluid.InferenceTranspiler.__init__ 
-paddle.fluid.InferenceTranspiler.transpile ArgSpec(args=['self', 'program', 'place', 'scope'], varargs=None, keywords=None, defaults=(None,))
 paddle.fluid.memory_optimize ArgSpec(args=['input_program', 'skip_opt_set', 'print_log', 'level'], varargs=None, keywords=None, defaults=(None, False, 0))
 paddle.fluid.release_memory ArgSpec(args=['input_program', 'skip_opt_set'], varargs=None, keywords=None, defaults=(None,))
 paddle.fluid.DistributeTranspilerConfig.__init__ 
@@ -338,8 +336,6 @@ paddle.fluid.transpiler.DistributeTranspiler.get_pserver_programs ArgSpec(args=[
 paddle.fluid.transpiler.DistributeTranspiler.get_startup_program ArgSpec(args=['self', 'endpoint', 'pserver_program', 'startup_program'], varargs=None, keywords=None, defaults=(None, None))
 paddle.fluid.transpiler.DistributeTranspiler.get_trainer_program ArgSpec(args=['self', 'wait_port'], varargs=None, keywords=None, defaults=(True,))
 paddle.fluid.transpiler.DistributeTranspiler.transpile ArgSpec(args=['self', 'trainer_id', 'program', 'pservers', 'trainers', 'sync_mode', 'startup_program'], varargs=None, keywords=None, defaults=(None, '127.0.0.1:6174', 1, True, None))
-paddle.fluid.transpiler.InferenceTranspiler.__init__ 
-paddle.fluid.transpiler.InferenceTranspiler.transpile ArgSpec(args=['self', 'program', 'place', 'scope'], varargs=None, keywords=None, defaults=(None,))
 paddle.fluid.transpiler.memory_optimize ArgSpec(args=['input_program', 'skip_opt_set', 'print_log', 'level'], varargs=None, keywords=None, defaults=(None, False, 0))
 paddle.fluid.transpiler.release_memory ArgSpec(args=['input_program', 'skip_opt_set'], varargs=None, keywords=None, defaults=(None,))
 paddle.fluid.transpiler.HashName.__init__ ArgSpec(args=['self', 'pserver_endpoints'], varargs=None, keywords=None, defaults=None)

paddle/fluid/framework/details/broadcast_op_handle_test.cc

@@ -96,8 +96,8 @@ struct TestBroadcastOpHandle {
     }
     param_scopes_[input_scope_idx]->Var("input");
 
-    std::unique_ptr<ir::Node> n(
-        new ir::Node("node0", ir::Node::Type::kOperation));
+    std::unique_ptr<ir::Node> n =
+        ir::CreateNodeForTest("node0", ir::Node::Type::kOperation);
     if (use_gpu_) {
 #ifdef PADDLE_WITH_CUDA
       op_handle_.reset(new BroadcastOpHandle(n.get(), local_scopes_, gpu_list_,
@@ -115,8 +115,8 @@ struct TestBroadcastOpHandle {
 #endif
     }
 
-    std::unique_ptr<ir::Node> v(
-        new ir::Node("node1", ir::Node::Type::kVariable));
+    std::unique_ptr<ir::Node> v =
+        ir::CreateNodeForTest("node1", ir::Node::Type::kVariable);
     auto* in_var_handle = new VarHandle(v.get(), 1, input_scope_idx, "input",
                                         gpu_list_[input_scope_idx]);
     vars_.emplace_back(in_var_handle);
@@ -124,8 +124,8 @@ struct TestBroadcastOpHandle {
 
     // add dummy var
 
-    std::unique_ptr<ir::Node> v2(
-        new ir::Node("node2", ir::Node::Type::kVariable));
+    std::unique_ptr<ir::Node> v2 =
+        ir::CreateNodeForTest("node2", ir::Node::Type::kVariable);
     vars_.emplace_back(new DummyVarHandle(v2.get()));
     DummyVarHandle* dummy_var_handle =
         static_cast<DummyVarHandle*>(vars_.back().get());
@@ -136,8 +136,8 @@ struct TestBroadcastOpHandle {
       if (!use_gpu_) {
         op_handle_->SetDeviceContext(gpu_list_[j], ctxs_[j].get());
       }
-      std::unique_ptr<ir::Node> v3(
-          new ir::Node("node3", ir::Node::Type::kVariable));
+      std::unique_ptr<ir::Node> v3 =
+          ir::CreateNodeForTest("node3", ir::Node::Type::kVariable);
       VarHandle* out_var_handle =
           new VarHandle(v3.get(), 2, j, "out", gpu_list_[j]);
       vars_.emplace_back(out_var_handle);
@@ -145,8 +145,8 @@ struct TestBroadcastOpHandle {
     }
 
     // add dummy var
-    std::unique_ptr<ir::Node> v4(
-        new ir::Node("node4", ir::Node::Type::kVariable));
+    std::unique_ptr<ir::Node> v4 =
+        ir::CreateNodeForTest("node4", ir::Node::Type::kVariable);
     vars_.emplace_back(new DummyVarHandle(v4.get()));
     DummyVarHandle* out_dummy_var_handle =
         static_cast<DummyVarHandle*>(vars_.back().get());

paddle/fluid/framework/details/fast_threaded_ssa_graph_executor.cc

@@ -54,7 +54,6 @@ FeedFetchList FastThreadedSSAGraphExecutor::Run(
   paddle::framework::FeedFetchList fetches;
   fetches.resize(fetch_tensors.size());
   std::unordered_map<std::string, std::vector<VarHandleBase *>> fetched_vars;
-  std::vector<std::unique_ptr<ir::Node>> fetch_nodes;
   std::vector<std::unique_ptr<FetchOpHandle>> fetch_ops;
 
   for (auto &fetch_var_name : fetch_tensors) {
@@ -75,9 +74,9 @@ FeedFetchList FastThreadedSSAGraphExecutor::Run(
 
     auto &vars = fetched_var_it->second;
 
-    fetch_nodes.emplace_back(new ir::Node("fetch", ir::Node::Type::kOperation));
-    auto *op = new FetchOpHandle(fetch_nodes.back().get(), &fetches, i,
-                                 &local_scopes_);
+    ir::Node *fetch_node =
+        graph_->CreateEmptyNode("fetch", ir::Node::Type::kOperation);
+    auto *op = new FetchOpHandle(fetch_node, &fetches, i, &local_scopes_);
     fetch_ops.emplace_back(op);
 
     for (auto &p : places_) {
@@ -116,9 +115,7 @@ FeedFetchList FastThreadedSSAGraphExecutor::Run(
     num_complete += num_comp;
   }
   // Wait FetchOps.
-  if (!fetch_ops.empty()) {
-    fetch_ops.clear();
-  }
+  ClearFetchOp(graph_.get(), &fetch_ops);
   return fetches;
 }
 void FastThreadedSSAGraphExecutor::RunOpAsync(

paddle/fluid/framework/details/gather_op_handle_test.cc

@@ -82,13 +82,15 @@ struct TestGatherOpHandle {
     }
     param_scopes_[input_scope_idx]->Var("out");
 
-    nodes.emplace_back(new ir::Node("node", ir::Node::Type::kOperation));
+    nodes.emplace_back(
+        ir::CreateNodeForTest("node", ir::Node::Type::kOperation).release());
     op_handle_.reset(
         new GatherOpHandle(nodes.back().get(), local_scopes_, gpu_list_));
     // add input
     for (size_t j = 0; j < gpu_list_.size(); ++j) {
       op_handle_->SetDeviceContext(gpu_list_[j], ctxs_[j].get());
-      nodes.emplace_back(new ir::Node("node1", ir::Node::Type::kVariable));
+      nodes.emplace_back(
+          ir::CreateNodeForTest("node1", ir::Node::Type::kVariable).release());
       auto* in_var_handle =
           new VarHandle(nodes.back().get(), 1, j, "input", gpu_list_[j]);
       vars_.emplace_back(in_var_handle);
@@ -96,7 +98,8 @@ struct TestGatherOpHandle {
     }
 
     // add dummy var
-    nodes.emplace_back(new ir::Node("node2", ir::Node::Type::kVariable));
+    nodes.emplace_back(
+        ir::CreateNodeForTest("node2", ir::Node::Type::kVariable).release());
     vars_.emplace_back(new DummyVarHandle(nodes.back().get()));
     DummyVarHandle* in_dummy_var_handle =
         static_cast<DummyVarHandle*>(vars_.back().get());
@@ -104,14 +107,16 @@ struct TestGatherOpHandle {
     op_handle_->AddInput(in_dummy_var_handle);
 
     // add output
-    nodes.emplace_back(new ir::Node("node3", ir::Node::Type::kVariable));
+    nodes.emplace_back(
+        ir::CreateNodeForTest("node3", ir::Node::Type::kVariable).release());
     auto* out_var_handle = new VarHandle(nodes.back().get(), 2, input_scope_idx,
                                          "out", gpu_list_[input_scope_idx]);
     vars_.emplace_back(out_var_handle);
     op_handle_->AddOutput(out_var_handle);
 
     // add dummy var
-    nodes.emplace_back(new ir::Node("node4", ir::Node::Type::kVariable));
+    nodes.emplace_back(
+        ir::CreateNodeForTest("node4", ir::Node::Type::kVariable).release());
     vars_.emplace_back(new DummyVarHandle(nodes.back().get()));
     DummyVarHandle* dummy_var_handle =
         static_cast<DummyVarHandle*>(vars_.back().get());

paddle/fluid/framework/details/ssa_graph_executor.cc

@@ -19,6 +19,19 @@ namespace framework {
 namespace details {
 SSAGraphExecutor::~SSAGraphExecutor() {}
 
+void ClearFetchOp(ir::Graph* graph,
+                  std::vector<std::unique_ptr<FetchOpHandle>>* fetch_ops) {
+  if (fetch_ops->empty()) return;
+
+  for (auto& op : *fetch_ops) {
+    for (auto& out_var : op->Node()->outputs) {
+      graph->RemoveNode(out_var);
+    }
+    graph->RemoveNode(op->Node());
+  }
+  fetch_ops->clear();
+}
+
 }  // namespace details
 }  // namespace framework
 }  // namespace paddle

paddle/fluid/framework/details/ssa_graph_executor.h

@@ -18,6 +18,7 @@
 #include <string>
 #include <vector>
 
+#include "paddle/fluid/framework/details/fetch_op_handle.h"
 #include "paddle/fluid/framework/feed_fetch_type.h"
 #include "paddle/fluid/framework/ir/graph.h"
 
@@ -36,6 +37,9 @@ class SSAGraphExecutor {
 
   virtual FeedFetchList Run(const std::vector<std::string>& fetch_tensors) = 0;
 };
+
+void ClearFetchOp(ir::Graph* graph,
+                  std::vector<std::unique_ptr<FetchOpHandle>>* fetch_ops);
 }  // namespace details
 }  // namespace framework
 }  // namespace paddle

paddle/fluid/framework/details/threaded_ssa_graph_executor.cc

@@ -69,12 +69,11 @@ FeedFetchList ThreadedSSAGraphExecutor::Run(
 
   // Step 2. Insert FetchOps
   std::vector<std::unique_ptr<FetchOpHandle>> fetch_ops;
-  std::vector<std::unique_ptr<ir::Node>> tmp_nodes;
   std::unordered_set<std::unique_ptr<VarHandleBase>> fetch_dependencies;
   FeedFetchList fetch_data(fetch_tensors.size());
 
-  InsertFetchOps(fetch_tensors, &fetch_ops, &tmp_nodes, &fetch_dependencies,
-                 &pending_ops, &pending_vars, &ready_vars, &fetch_data);
+  InsertFetchOps(fetch_tensors, &fetch_ops, &fetch_dependencies, &pending_ops,
+                 &pending_vars, &ready_vars, &fetch_data);
 
   auto run_all_ops = [&](std::unordered_set<OpHandleBase *> &set) {
     for (auto *op : set) {
@@ -136,9 +135,7 @@ FeedFetchList ThreadedSSAGraphExecutor::Run(
   PADDLE_ENFORCE(ready_ops.empty());
 
   // Wait FetchOps.
-  if (!fetch_ops.empty()) {
-    fetch_ops.clear();
-  }
+  ClearFetchOp(graph_.get(), &fetch_ops);
 
   return fetch_data;
 }
@@ -146,7 +143,6 @@ FeedFetchList ThreadedSSAGraphExecutor::Run(
 void ThreadedSSAGraphExecutor::InsertFetchOps(
     const std::vector<std::string> &fetch_tensors,
     std::vector<std::unique_ptr<FetchOpHandle>> *fetch_ops,
-    std::vector<std::unique_ptr<ir::Node>> *temp_nodes,
     std::unordered_set<std::unique_ptr<VarHandleBase>> *fetch_dependencies,
     std::unordered_map<OpHandleBase *, size_t> *pending_ops,
     std::unordered_set<VarHandleBase *> *pending_vars,
@@ -171,9 +167,9 @@ void ThreadedSSAGraphExecutor::InsertFetchOps(
 
     auto &vars = fetched_var_it->second;
 
-    temp_nodes->emplace_back(new ir::Node("fetch", ir::Node::Type::kOperation));
-    auto *op = new FetchOpHandle(temp_nodes->back().get(), fetch_data, i,
-                                 &local_scopes_);
+    ir::Node *fetch_node =
+        graph_->CreateEmptyNode("fetch", ir::Node::Type::kOperation);
+    auto *op = new FetchOpHandle(fetch_node, fetch_data, i, &local_scopes_);
     fetch_ops->emplace_back(op);
 
     for (auto &p : places_) {
@@ -184,8 +180,9 @@ void ThreadedSSAGraphExecutor::InsertFetchOps(
       op->AddInput(var);
     }
 
-    temp_nodes->emplace_back(new ir::Node("fetch", ir::Node::Type::kOperation));
-    auto *fetch_dummy = new DummyVarHandle(temp_nodes->back().get());
+    ir::Node *fetch_var =
+        graph_->CreateEmptyNode("fetch", ir::Node::Type::kVariable);
+    auto *fetch_dummy = new DummyVarHandle(fetch_var);
     op->AddOutput(fetch_dummy);
     fetch_dependencies->emplace(fetch_dummy);
     this->InsertPendingVar(pending_vars, ready_vars, fetch_dummy);

paddle/fluid/framework/details/threaded_ssa_graph_executor.h

@@ -73,7 +73,6 @@ class ThreadedSSAGraphExecutor : public SSAGraphExecutor {
   void InsertFetchOps(
       const std::vector<std::string> &fetch_tensors,
       std::vector<std::unique_ptr<FetchOpHandle>> *fetch_ops,
-      std::vector<std::unique_ptr<ir::Node>> *temp_nodes,
       std::unordered_set<std::unique_ptr<VarHandleBase>> *fetch_dependencies,
       std::unordered_map<OpHandleBase *, size_t> *pending_ops,
       std::unordered_set<VarHandleBase *> *pending_vars,

paddle/fluid/framework/ir/node.cc

@@ -19,6 +19,11 @@ namespace framework {
 namespace ir {
 constexpr char Node::kControlDepVarName[];
 int Node::count_ = 0;
+
+std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
+                                        Node::Type type) {
+  return std::unique_ptr<Node>(new Node(name, type));
+}
 }  // namespace ir
 }  // namespace framework
 }  // namespace paddle

paddle/fluid/framework/ir/node.h

@@ -24,32 +24,12 @@ namespace paddle {
 namespace framework {
 namespace ir {
 
+// Node should normally created by Graph::CreateXXXNode().
 class Node {
  public:
   enum class Type { kOperation, kVariable };
   static constexpr char kControlDepVarName[] = "__control_var";
 
-  explicit Node(const std::string& name, Type type)
-      : name_(name),
-        var_desc_(nullptr),
-        op_desc_(nullptr),
-        type_(type),
-        id_(count_++) {}
-
-  explicit Node(VarDesc* var_desc)
-      : name_(var_desc->Name()),
-        var_desc_(new VarDesc(*var_desc)),
-        op_desc_(nullptr),
-        type_(Type::kVariable),
-        id_(count_++) {}
-
-  explicit Node(OpDesc* op_desc)
-      : name_(op_desc->Type()),
-        var_desc_(nullptr),
-        op_desc_(new OpDesc(*op_desc, op_desc->Block())),
-        type_(Type::kOperation),
-        id_(count_++) {}
-
   Type NodeType() const { return type_; }
 
   std::string Name() const { return name_; }
@@ -81,11 +61,40 @@ class Node {
 
  private:
   friend class Graph;
+  friend std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
+                                                 Node::Type type);
+
+  explicit Node(const std::string& name, Type type)
+      : name_(name),
+        var_desc_(nullptr),
+        op_desc_(nullptr),
+        type_(type),
+        id_(count_++) {}
+
+  explicit Node(VarDesc* var_desc)
+      : name_(var_desc->Name()),
+        var_desc_(new VarDesc(*var_desc)),
+        op_desc_(nullptr),
+        type_(Type::kVariable),
+        id_(count_++) {}
+
+  explicit Node(OpDesc* op_desc)
+      : name_(op_desc->Type()),
+        var_desc_(nullptr),
+        op_desc_(new OpDesc(*op_desc, op_desc->Block())),
+        type_(Type::kOperation),
+        id_(count_++) {}
+
+  Node() = delete;
+
   static int count_;
   static void ResetId() { count_ = 0; }
   DISABLE_COPY_AND_ASSIGN(Node);
 };
 
+std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
+                                        Node::Type type);
+
 }  // namespace ir
 }  // namespace framework
 }  // namespace paddle

paddle/fluid/operators/array_to_lod_tensor_op.cc

@@ -25,7 +25,7 @@ namespace operators {
 
 using LoD = framework::LoD;
 
-class ArrayToLoDFunctor;
+struct ArrayToLoDFunctor;
 template <typename DeviceContext>
 struct ArrayToLoDFunctorImpl {
   const ArrayToLoDFunctor *prev_functor_;

paddle/scripts/paddle_build.sh

@@ -108,7 +108,15 @@ function cmake_gen() {
            fi
         fi
     fi
-
+    
+    if [ "$SYSTEM" == "Darwin" ]; then
+        WITH_DISTRIBUTE=${WITH_DISTRIBUTE:-ON}
+        WITH_AVX=${WITH_AVX:-ON}
+        INFERENCE_DEMO_INSTALL_DIR=${INFERENCE_DEMO_INSTALL_DIR:-~/.cache/inference_demo}
+    else
+        INFERENCE_DEMO_INSTALL_DIR=${INFERENCE_DEMO_INSTALL_DIR:-/root/.cache/inference_demo}
+    fi
+    
     cat <<EOF
     ========================================
     Configuring cmake in /paddle/build ...
@@ -136,7 +144,7 @@ function cmake_gen() {
         -DWITH_CONTRIB=${WITH_CONTRIB:-ON}
         -DWITH_INFERENCE=${WITH_INFERENCE:-ON}
         -DWITH_INFERENCE_API_TEST=${WITH_INFERENCE_API_TEST:-ON}
-        -DINFERENCE_DEMO_INSTALL_DIR=${INFERENCE_DEMO_INSTALL_DIR:-/root/.cache/inference_demo}
+        -DINFERENCE_DEMO_INSTALL_DIR=${INFERENCE_DEMO_INSTALL_DIR}
         -DWITH_ANAKIN=${WITH_ANAKIN:-OFF}
         -DPY_VERSION=${PY_VERSION:-2.7}
     ========================================
@@ -168,9 +176,10 @@ EOF
         -DWITH_CONTRIB=${WITH_CONTRIB:-ON} \
         -DWITH_INFERENCE=${WITH_INFERENCE:-ON} \
         -DWITH_INFERENCE_API_TEST=${WITH_INFERENCE_API_TEST:-ON} \
-        -DINFERENCE_DEMO_INSTALL_DIR=${INFERENCE_DEMO_INSTALL_DIR:-/root/.cache/inference_demo} \
+        -DINFERENCE_DEMO_INSTALL_DIR=${INFERENCE_DEMO_INSTALL_DIR} \
         -DWITH_ANAKIN=${WITH_ANAKIN:-OFF} \
         -DPY_VERSION=${PY_VERSION:-2.7}
+
 }
 
 function abort(){
@@ -232,8 +241,8 @@ function build_mac() {
     ============================================
 EOF
     make clean
-    sudo make -j 8
-    sudo make install -j 8
+    make -j 8
+    make install -j 8
 }
 
 function build_android() {

python/paddle/dataset/uci_housing.py

@@ -30,7 +30,7 @@ import paddle.dataset.common
 
 __all__ = ['train', 'test']
 
-URL = 'https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data'
+URL = 'http://paddlemodels.bj.bcebos.com/uci_housing/housing.data'
 MD5 = 'd4accdce7a25600298819f8e28e8d593'
 feature_names = [
     'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',

python/paddle/fluid/tests/book/test_image_classification.py

@@ -223,7 +223,7 @@ def infer(use_cuda, save_dirname=None):
 
         # Use inference_transpiler to speedup
         inference_transpiler_program = inference_program.clone()
-        t = fluid.InferenceTranspiler()
+        t = fluid.transpiler.InferenceTranspiler()
         t.transpile(inference_transpiler_program, place)
 
         # Construct feed as a dictionary of {feed_target_name: feed_target_data}

python/paddle/fluid/tests/unittests/CMakeLists.txt

@@ -30,15 +30,15 @@ list(REMOVE_ITEM TEST_OPS op_test) # op_test is a helper python file, not a test
 list(REMOVE_ITEM TEST_OPS decorators) # decorators is a helper python file, not a test
 
 if(APPLE)
-    message(WARNING "These tests has been disabled in OSX before being fixed: \n test_detection_map_op \n test_desc_clone \n test_debugger \n test_program_code \n test_dist_transformer \n test_dist_se_resnext")
+    if(NOT WITH_DISTRIBUTE)
+        list(REMOVE_ITEM TEST_OPS test_desc_clone)
+        list(REMOVE_ITEM TEST_OPS test_program_code)
+    endif(NOT WITH_DISTRIBUTE)
+    message(WARNING "These tests has been disabled in OSX before being fixed: \n test_detection_map_op \n test_dist_se_resnext")
     # this op is not support on mac
     list(REMOVE_ITEM TEST_OPS test_fusion_seqexpand_concat_fc_op)
     # TODO: add the unitest back when it fixed
     list(REMOVE_ITEM TEST_OPS test_detection_map_op)
-    list(REMOVE_ITEM TEST_OPS test_desc_clone)
-    list(REMOVE_ITEM TEST_OPS test_debugger)
-    list(REMOVE_ITEM TEST_OPS test_program_code)
-    list(REMOVE_ITEM TEST_OPS test_dist_transformer)
     list(REMOVE_ITEM TEST_OPS test_dist_se_resnext)
 endif()
 
@@ -73,11 +73,13 @@ py_test_modules(test_warpctc_op MODULES test_warpctc_op ENVS FLAGS_warpctc_dir=$
 if(WITH_DISTRIBUTE)
     py_test_modules(test_dist_train MODULES test_dist_train SERIAL)
     set_tests_properties(test_listen_and_serv_op PROPERTIES TIMEOUT 20)
-    set_tests_properties(test_dist_mnist PROPERTIES TIMEOUT 200)
-    set_tests_properties(test_dist_word2vec PROPERTIES TIMEOUT 200)
+    if(NOT APPLE)
+        set_tests_properties(test_dist_mnist PROPERTIES TIMEOUT 200)
+        set_tests_properties(test_dist_word2vec PROPERTIES TIMEOUT 200)
+        py_test_modules(test_dist_se_resnext MODULES test_dist_se_resnext SERIAL)
+    endif(NOT APPLE)
     py_test_modules(test_dist_transpiler MODULES test_dist_transpiler)
     py_test_modules(test_dist_transformer MODULES test_dist_transformer SERIAL)
-    py_test_modules(test_dist_se_resnext MODULES test_dist_se_resnext SERIAL)
 endif()
 py_test_modules(test_parallel_executor_crf MODULES test_parallel_executor_crf SERIAL)
 py_test_modules(test_parallel_executor_fetch_feed MODULES test_parallel_executor_fetch_feed SERIAL)

python/paddle/fluid/transpiler/__init__.py

@@ -20,6 +20,6 @@ from .memory_optimization_transpiler import memory_optimize, release_memory
 from .ps_dispatcher import HashName, RoundRobin
 
 __all__ = [
-    "DistributeTranspiler", "InferenceTranspiler", "memory_optimize",
-    "release_memory", "HashName", "RoundRobin", "DistributeTranspilerConfig"
+    "DistributeTranspiler", "memory_optimize", "release_memory", "HashName",
+    "RoundRobin", "DistributeTranspilerConfig"
 ]