Merge branch 'develop' into feature/change_op_creation

CMakeLists.txt

@@ -36,8 +36,8 @@ include(simd)
 ################################ Configurations #######################################
 option(WITH_GPU         "Compile PaddlePaddle with NVIDIA GPU"          ${CUDA_FOUND})
 option(WITH_AVX         "Compile PaddlePaddle with AVX intrinsics"      ${AVX_FOUND})
-option(WITH_MKLDNN      "Compile PaddlePaddle with mkl-dnn support."    OFF)
-option(WITH_MKLML       "Compile PaddlePaddle with mklml package."      OFF)
+option(WITH_MKLDNN      "Compile PaddlePaddle with mkl-dnn support."    ${AVX_FOUND})
+option(WITH_MKLML       "Compile PaddlePaddle with mklml package."      ${AVX_FOUND})
 option(WITH_DSO         "Compile PaddlePaddle with dynamic linked CUDA" ON)
 option(WITH_TESTING     "Compile PaddlePaddle with unit testing"        ON)
 option(WITH_SWIG_PY     "Compile PaddlePaddle with inference api"       ON)

cmake/configure.cmake

@@ -74,8 +74,6 @@ if(WITH_MKLDNN)
         set(OPENMP_FLAGS "-fopenmp")
         set(CMAKE_C_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS ${OPENMP_FLAGS})
         set(CMAKE_CXX_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS ${OPENMP_FLAGS})
-        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -L${MKLDNN_IOMP_DIR} -liomp5 -Wl,--as-needed")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${MKLDNN_IOMP_DIR} -liomp5 -Wl,--as-needed")
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENMP_FLAGS}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENMP_FLAGS}")
     else()

cmake/external/any.cmake

@@ -7,7 +7,7 @@ INCLUDE_DIRECTORIES(${ANY_SOURCE_DIR}/src/extern_lib_any)
 ExternalProject_Add(
     extern_lib_any
     ${EXTERNAL_PROJECT_LOG_ARGS}
-    GIT_REPOSITORY  "https://github.com/thelink2012/any.git"
+    GIT_REPOSITORY  "https://github.com/PaddlePaddle/any.git"
     GIT_TAG         "8fef1e93710a0edf8d7658999e284a1142c4c020"
     PREFIX          ${ANY_SOURCE_DIR}
     UPDATE_COMMAND  ""

cmake/external/gflags.cmake

@@ -28,7 +28,14 @@ INCLUDE_DIRECTORIES(${GFLAGS_INCLUDE_DIR})
 ExternalProject_Add(
     extern_gflags
     ${EXTERNAL_PROJECT_LOG_ARGS}
-    GIT_REPOSITORY  "https://github.com/gflags/gflags.git"
+    # TODO(yiwang): The annoying warnings mentioned in
+    # https://github.com/PaddlePaddle/Paddle/issues/3277 are caused by
+    # gflags.  I fired a PR https://github.com/gflags/gflags/pull/230
+    # to fix it.  Before it gets accepted by the gflags team, we use
+    # my personal fork, which contains above fix, temporarily.  Let's
+    # change this back to the official Github repo once my PR is
+    # merged.
+    GIT_REPOSITORY  "https://github.com/wangkuiyi/gflags.git"
     PREFIX          ${GFLAGS_SOURCES_DIR}
     UPDATE_COMMAND  ""
     CMAKE_ARGS      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}

cmake/external/openblas.cmake

@@ -69,8 +69,13 @@ ENDIF(NOT ${CBLAS_FOUND})
 MESSAGE(STATUS "BLAS library: ${CBLAS_LIBRARIES}")
 INCLUDE_DIRECTORIES(${CBLAS_INC_DIR})
 
-ADD_LIBRARY(cblas STATIC IMPORTED)
-SET_PROPERTY(TARGET cblas PROPERTY IMPORTED_LOCATION ${CBLAS_LIBRARIES})
+# FIXME(gangliao): generate cblas target to track all high performance
+# linear algebra libraries for cc_library(xxx SRCS xxx.c DEPS cblas)
+SET(dummyfile ${CMAKE_CURRENT_BINARY_DIR}/cblas_dummy.c)
+FILE(WRITE ${dummyfile} "const char * dummy = \"${dummyfile}\";")
+ADD_LIBRARY(cblas STATIC ${dummyfile})
+TARGET_LINK_LIBRARIES(cblas ${CBLAS_LIBRARIES})
+
 IF(NOT ${CBLAS_FOUND})
     ADD_DEPENDENCIES(cblas extern_openblas)
     LIST(APPEND external_project_dependencies cblas)

cmake/generic.cmake

@@ -403,3 +403,16 @@ function(py_proto_compile TARGET_NAME)
   protobuf_generate_python(py_srcs ${py_proto_compile_SRCS})
   add_custom_target(${TARGET_NAME} ALL DEPENDS ${py_srcs})
 endfunction()
+
+function(py_test TARGET_NAME)
+  if(WITH_TESTING)
+    set(options STATIC static SHARED shared)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(py_test "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})  
+    add_test(NAME ${TARGET_NAME}
+             COMMAND env PYTHONPATH=${PADDLE_PYTHON_PACKAGE_DIR}
+             python2 ${py_test_SRCS}
+             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  endif()
+endfunction()

paddle/api/test/CMakeLists.txt

@@ -1,2 +1,6 @@
-add_python_test(test_swig_api
-    testArguments.py testGradientMachine.py testMatrix.py testVector.py testTrain.py testTrainer.py)
+py_test(testTrain SRCS testTrain.py)
+py_test(testMatrix SRCS testMatrix.py)
+py_test(testVector SRCS testVector.py)
+py_test(testTrainer SRCS testTrainer.py)
+py_test(testArguments SRCS testArguments.py)
+py_test(testGradientMachine SRCS testGradientMachine.py)

paddle/framework/operator.cc

@@ -22,14 +22,14 @@ namespace framework {
 template <>
 Eigen::DefaultDevice& ExecutionContext::GetEigenDevice<
     platform::CPUPlace, Eigen::DefaultDevice>() const {
-  return *device_context_.get_eigen_device<Eigen::DefaultDevice>();
+  return *device_context_->get_eigen_device<Eigen::DefaultDevice>();
 }
 
 #ifndef PADDLE_ONLY_CPU
 template <>
 Eigen::GpuDevice&
 ExecutionContext::GetEigenDevice<platform::GPUPlace, Eigen::GpuDevice>() const {
-  return *device_context_.get_eigen_device<Eigen::GpuDevice>();
+  return *device_context_->get_eigen_device<Eigen::GpuDevice>();
 }
 #endif
 

paddle/framework/operator.h

@@ -252,7 +252,7 @@ struct EigenDeviceConverter<platform::GPUPlace> {
 class ExecutionContext : public OperatorContext {
  public:
   ExecutionContext(const OperatorBase* op, const Scope& scope,
-                   const platform::DeviceContext& device_context)
+                   const platform::DeviceContext* device_context)
       : OperatorContext(op, scope), device_context_(device_context) {}
 
   template <typename PlaceType,
@@ -260,9 +260,9 @@ class ExecutionContext : public OperatorContext {
                 typename EigenDeviceConverter<PlaceType>::EigenDeviceType>
   DeviceType& GetEigenDevice() const;
 
-  platform::Place GetPlace() const { return device_context_.GetPlace(); }
+  platform::Place GetPlace() const { return device_context_->GetPlace(); }
 
-  const platform::DeviceContext& device_context_;
+  const platform::DeviceContext* device_context_;
 };
 
 class OpKernel {
@@ -311,7 +311,7 @@ class OperatorWithKernel : public OperatorBase {
   void Run(const Scope& scope,
            const platform::DeviceContext& dev_ctx) const final {
     auto& opKernel = AllOpKernels().at(type_).at(OpKernelKey(dev_ctx));
-    opKernel->Compute(ExecutionContext(this, scope, dev_ctx));
+    opKernel->Compute(ExecutionContext(this, scope, &dev_ctx));
   }
 
   static std::unordered_map<std::string /* op_type */, OpKernelMap>&

python/paddle/v2/framework/tests/CMakeLists.txt

@@ -1,17 +1,23 @@
-add_python_test(test_framework
-    test_protobuf.py
-    test_scope.py
-    test_operator.py
-    test_default_scope_funcs.py
-    test_net.py
-    test_tensor.py
-    test_fc_op.py
-    test_add_two_op.py
-    test_sgd_op.py
-    test_mul_op.py
-    test_mean_op.py
-    test_sigmoid_op.py
-    test_softmax_op.py
-    test_rowwise_add_op.py
-    gradient_checker.py
-    )
+py_test(test_net SRCS test_net.py)
+
+py_test(test_fc_op SRCS test_fc_op.py)
+py_test(test_scope SRCS test_scope.py)
+
+py_test(test_tensor SRCS test_tensor.py)
+py_test(test_mul_op SRCS test_mul_op.py)
+
+py_test(test_network SRCS test_network.py)
+py_test(test_mean_op SRCS test_mean_op.py)
+
+py_test(test_protobuf SRCS test_protobuf.py)
+
+py_test(test_add_two_op SRCS test_add_two_op.py)
+py_test(test_sigmoid_op SRCS test_sigmoid_op.py)
+py_test(test_softmax_op SRCS test_softmax_op.py)
+
+py_test(gradient_checker SRCS gradient_checker.py)
+
+py_test(test_rowwise_add_op SRCS test_rowwise_add_op.py)
+
+py_test(test_default_scope_funcs SRCS test_default_scope_funcs.py)
+py_test(test_operator SRCS test_operator.py

python/paddle/v2/framework/tests/op_test_util.py

@@ -29,23 +29,28 @@ class OpTestMeta(type):
 
             for place in places:
                 for in_name in Operator.get_op_input_names(self.type):
-                    if hasattr(self, in_name):
+                    if hasattr(self, "inputs") and in_name in self.inputs
                         kwargs[in_name] = in_name
                         var = scope.new_var(in_name).get_tensor()
-                        arr = getattr(self, in_name)
+                        arr = self.inputs[in_name]
                         var.set_dims(arr.shape)
                         var.set(arr, place)
                     else:
                         kwargs[in_name] = "@EMPTY@"
 
                 for out_name in Operator.get_op_output_names(self.type):
-                    if hasattr(self, out_name):
-                        kwargs[out_name] = out_name
-                        scope.new_var(out_name).get_tensor()
+                    if not hasattr(self, "outputs"):
+                        raise ValueError(
+                            "The test op must set self.outputs dict.")
+                    if out_name not in self.outputs:
+                        raise ValueError("The %s is not in self.outputs dict." %
+                                         (out_name))
+                    kwargs[out_name] = out_name
+                    scope.new_var(out_name).get_tensor()
 
                 for attr_name in Operator.get_op_attr_names(self.type):
-                    if hasattr(self, attr_name):
-                        kwargs[attr_name] = getattr(self, attr_name)
+                    if hasattr(self, "attrs") and attr_name in self.attrs:
+                        kwargs[attr_name] = self.attrs[attr_name]
 
                 op = Operator(self.type, **kwargs)
 
@@ -56,7 +61,7 @@ class OpTestMeta(type):
 
                 for out_name in Operator.get_op_output_names(self.type):
                     actual = numpy.array(scope.find_var(out_name).get_tensor())
-                    expect = getattr(self, out_name)
+                    expect = self.outputs[out_name]
                     numpy.isclose(actual, expect)
 
         obj.test_all = test_all

python/paddle/v2/framework/tests/test_add_two_op.py

@@ -12,9 +12,11 @@ class TestAddOp(unittest.TestCase):
 
     def setUp(self):
         self.type = "add_two"
-        self.X = numpy.random.random((102, 105)).astype("float32")
-        self.Y = numpy.random.random((102, 105)).astype("float32")
-        self.Out = self.X + self.Y
+        self.inputs = {
+            'X': numpy.random.random((102, 105)).astype("float32"),
+            'Y': numpy.random.random((102, 105)).astype("float32")
+        }
+        self.outputs = {'Out': self.inputs['X'] + self.inputs['Y']}
 
 
 class TestAddGradOp(unittest.TestCase):

python/paddle/v2/framework/tests/test_cross_entropy_op.py

@@ -7,15 +7,17 @@ class TestSGD(unittest.TestCase):
     __metaclass__ = OpTestMeta
 
     def setUp(self):
+        # TODO this unit test is not passed
         self.type = "onehot_cross_entropy"
         batch_size = 100
         class_num = 10
-        self.X = numpy.random.random((batch_size, class_num)).astype("float32")
-        self.label = 5 * numpy.ones(batch_size).astype("int32")
+        X = numpy.random.random((batch_size, class_num)).astype("float32")
+        label = 5 * numpy.ones(batch_size).astype("int32")
+        self.inputs = {'X': X, 'label': label}
         Y = []
         for i in range(0, batch_size):
-            Y.append(-numpy.log(self.X[i][self.label[i]]))
-        self.Y = numpy.array(Y).astype("float32")
+            Y.append(-numpy.log(X[i][label[i]]))
+        self.outputs = {'Y': numpy.array(Y).astype("float32")}
 
 
 # TODO(superjom) add gradient check

python/paddle/v2/framework/tests/test_mean_op.py

@@ -8,8 +8,8 @@ class TestMeanOp(unittest.TestCase):
 
     def setUp(self):
         self.type = "mean"
-        self.X = np.random.random((32, 784)).astype("float32")
-        self.Out = np.mean(self.X)
+        self.inputs = {'X': np.random.random((32, 784)).astype("float32")}
+        self.outputs = {'Out': np.mean(self.inputs['X'])}
 
 
 if __name__ == '__main__':

python/paddle/v2/framework/tests/test_mul_op.py

@@ -8,9 +8,11 @@ class TestMulOp(unittest.TestCase):
 
     def setUp(self):
         self.type = "mul"
-        self.X = np.random.random((32, 84)).astype("float32")
-        self.Y = np.random.random((84, 100)).astype("float32")
-        self.Out = np.dot(self.X, self.Y)
+        self.inputs = {
+            'X': np.random.random((32, 84)).astype("float32"),
+            'Y': np.random.random((84, 100)).astype("float32")
+        }
+        self.outputs = {'Out': np.dot(self.inputs['X'], self.inputs['Y'])}
 
 
 if __name__ == '__main__':

python/paddle/v2/framework/tests/test_rowwise_add_op.py

@@ -8,9 +8,11 @@ class TestRowwiseAddOp(unittest.TestCase):
 
     def setUp(self):
         self.type = "rowwise_add"
-        self.X = np.random.random((32, 84)).astype("float32")
-        self.b = np.random.random(84).astype("float32")
-        self.Out = np.add(self.X, self.b)
+        self.inputs = {
+            'X': np.random.random((32, 84)).astype("float32"),
+            'b': np.random.random(84).astype("float32")
+        }
+        self.outputs = {'Out': np.add(self.inputs['X'], self.inputs['b'])}
 
 
 if __name__ == '__main__':

python/paddle/v2/framework/tests/test_sgd_op.py

@@ -8,10 +8,13 @@ class TestSGD(unittest.TestCase):
 
     def setUp(self):
         self.type = "sgd"
-        self.param = numpy.random.random((102, 105)).astype("float32")
-        self.grad = numpy.random.random((102, 105)).astype("float32")
-        self.learning_rate = 0.1
-        self.param_out = self.param - self.learning_rate * self.grad
+        w = numpy.random.random((102, 105)).astype("float32")
+        g = numpy.random.random((102, 105)).astype("float32")
+        lr = 0.1
+
+        self.inputs = {'param': w, 'grad': g}
+        self.attrs = {'learning_rate': lr}
+        self.outputs = {'param_out': w - lr * g}
 
 
 if __name__ == "__main__":

python/paddle/v2/framework/tests/test_sigmoid_op.py

@@ -8,8 +8,8 @@ class TestSigmoidOp(unittest.TestCase):
 
     def setUp(self):
         self.type = "sigmoid"
-        self.X = np.random.random((32, 100)).astype("float32")
-        self.Y = 1 / (1 + np.exp(-self.X))
+        self.inputs = {'X': np.random.random((32, 100)).astype("float32")}
+        self.outputs = {'Y': 1 / (1 + np.exp(-self.inputs['X']))}
 
 
 if __name__ == '__main__':

python/paddle/v2/framework/tests/test_softmax_op.py

@@ -19,8 +19,10 @@ class TestSoftmaxOp(unittest.TestCase):
 
     def setUp(self):
         self.type = "softmax"
-        self.X = np.random.random((32, 100)).astype("float32")
-        self.Y = np.apply_along_axis(stable_softmax, 1, self.X)
+        self.inputs = {'X': np.random.random((32, 100)).astype("float32")}
+        self.outputs = {
+            'Y': np.apply_along_axis(stable_softmax, 1, self.inputs['X'])
+        }
 
 
 class TestSoftmaxGradOp(unittest.TestCase):

python/paddle/v2/plot/tests/CMakeLists.txt

@@ -1,5 +1,5 @@
 if (NOT APPLE)
   # The Mac OS X backend will not be able to function correctly if Python is
   # not installed as a framework.
-  add_python_test(test_ploter test_ploter.py)
+  py_test(test_ploter SRCS test_ploter.py)
 endif()

python/paddle/v2/reader/tests/CMakeLists.txt

@@ -1 +1,2 @@
-add_python_test(reader_tests creator_test.py decorator_test.py)
+py_test(creator_test SRCS creator_test.py)
+py_test(decorator_test SRCS decorator_test.py)

python/paddle/v2/tests/CMakeLists.txt

@@ -1,2 +1,7 @@
-add_python_test(test_v2_api test_data_feeder.py test_op.py test_parameters.py
-test_layer.py test_rnn_layer.py test_topology.py test_image.py)
+py_test(test_op SRCS test_op.py)
+py_test(test_image SRCS test_image.py)
+py_test(test_layer SRCS test_layer.py)
+py_test(test_topology SRCS test_topology.py)
+py_test(test_rnn_layer SRCS test_rnn_layer.py)
+py_test(test_parameters SRCS test_parameters.py)
+py_test(test_data_feeder SRCS test_data_feeder.py)