Remove FC Op, since it should be added in Python side

paddle/framework/CMakeLists.txt

@@ -48,9 +48,12 @@ if(WITH_PYTHON)
 cc_library(paddle_pybind SHARED
     SRCS pybind.cc
     DEPS pybind python backward
-    fc_op
     sgd_op
     add_op
+    mul_op
+    rowwise_add_op
+    sigmoid_op
+    softmax_op
     mean_op
     cross_entropy_op
     recurrent_op

paddle/framework/pybind.cc

@@ -31,7 +31,6 @@ namespace py = pybind11;
 
 USE_OP(add_two);
 USE_OP_CPU(onehot_cross_entropy);
-USE_OP_WITHOUT_KERNEL(fc);
 USE_OP(sgd);
 USE_OP(mul);
 USE_OP(mean);

paddle/operators/CMakeLists.txt

@@ -61,9 +61,6 @@ op_library(fill_zeros_like_op SRCS fill_zeros_like_op.cc fill_zeros_like_op.cu)
 
 op_library(sgd_op SRCS sgd_op.cc sgd_op.cu)
 
-op_library(fc_op
-    SRCS fc_op.cc
-    DEPS mul_op rowwise_add_op sigmoid_op softmax_op net_op)
 op_library(recurrent_op SRCS recurrent_op.cc rnn/recurrent_op_utils.cc
     DEPS op_desc tensor op_registry operator net_op)
 cc_test(recurrent_op_test SRCS recurrent_op_test.cc DEPS recurrent_op gtest mul_op add_op)

paddle/operators/fc_op.cc

-/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
-
-   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. */
-
-#include "paddle/operators/net_op.h"
-
-#include "paddle/framework/eigen.h"
-#include "paddle/framework/op_registry.h"
-
-namespace paddle {
-namespace operators {
-
-using OpRegistry = framework::OpRegistry;
-
-class FullyConnectedOp : public NetOp {
- public:
-  void Init() override {
-    AddOp(OpRegistry::CreateOp("mul",
-                               {
-                                   Input("X"), Input("W"),
-                               },
-                               {Output("before_act")}, {}));
-    auto b = Input("b");
-    if (b != framework::kEmptyVarName) {
-      AddOp(OpRegistry::CreateOp("rowwise_add",
-                                 {Output("before_act"), Input("b")},
-                                 {Output("before_act")}, {}));
-    }
-
-    auto activation = GetAttr<std::string>("activation");
-    AddOp(OpRegistry::CreateOp(activation, {Output("before_act")},
-                               {Output("Y")}, {}));
-    CompleteAddOp(false);
-  }
-};
-
-class FullyConnectedOpMaker : public framework::OpProtoAndCheckerMaker {
- public:
-  FullyConnectedOpMaker(framework::OpProto *proto,
-                        framework::OpAttrChecker *op_checker)
-      : OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "the input of fc operator");
-    AddInput("W", "the weight of fc operator");
-    AddInput("b", "the bias of fc operator");
-
-    AddOutput("Y", "the output of fc operator");
-    AddOutput("before_act", "the before activation output of fc operator")
-        .SetTemporary();
-    AddAttr<std::string>("activation", "The activation key for fc layer")
-        .SetDefault("sigmoid")
-        .InEnum({"sigmoid", "softmax"});
-
-    //! TODO(yuyang18): Complete comment;
-    AddComment("FullyConnected Operator");
-  }
-};
-}  // namespace operators
-}  // namespace paddle
-
-USE_OP(mul);
-USE_OP(rowwise_add);
-USE_OP(sigmoid);
-USE_OP(softmax);
-
-namespace ops = paddle::operators;
-REGISTER_OP(fc, ops::FullyConnectedOp, ops::FullyConnectedOpMaker);

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

 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)

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

-import paddle.v2.framework.core as core
-import unittest
-import numpy
-from paddle.v2.framework.op import Operator
-
-
-class TestFc(unittest.TestCase):
-    def test_fc(self):
-        scope = core.Scope()
-        place = core.CPUPlace()
-        x = scope.new_var("X")
-
-        x_tensor = x.get_tensor()
-        x_tensor.set_dims([1000, 784])
-        x_tensor.alloc_float(place)
-
-        w = scope.new_var("W")
-        w_tensor = w.get_tensor()
-        w_tensor.set_dims([784, 100])
-        w_tensor.alloc_float(place)
-
-        w_tensor.set(numpy.random.random((784, 100)).astype("float32"), place)
-
-        # Set a real numpy array here.
-        # x_tensor.set(numpy.array([]))
-
-        op = Operator("fc", X="X", Y="Y", W="W")
-
-        for out in op.outputs():
-            if scope.find_var(out) is None:
-                scope.new_var(out).get_tensor()
-
-        tensor = scope.find_var("Y").get_tensor()
-        op.infer_shape(scope)
-        self.assertEqual([1000, 100], tensor.shape())
-
-        ctx = core.DeviceContext.create(place)
-
-        op.run(scope, ctx)
-
-        # After complete all ops, check Y is expect or not.
-
-
-if __name__ == '__main__':
-    unittest.main()

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

@@ -3,6 +3,15 @@ from paddle.v2.framework.op import Operator
 import unittest
 
 
+def fc(X, W, Y):
+    ret_v = core.Net.create()
+
+    ret_v.add_op(Operator("mul", X="X", Y="W", Out="pre_activation"))
+    ret_v.add_op(Operator("sigmoid", X="pre_activation", Y=Y))
+    ret_v.complete_add_op(True)
+    return ret_v
+
+
 class TestNet(unittest.TestCase):
     def test_net_all(self):
         net = core.Net.create()
@@ -10,18 +19,18 @@ class TestNet(unittest.TestCase):
         net.add_op(op1)
 
         net2 = core.Net.create()
-        net2.add_op(Operator("fc", X="X", W="w", Y="fc.out"))
+        net2.add_op(fc(X="X", W="w", Y="fc.out"))
         net2.complete_add_op(True)
         net.add_op(net2)
         net.complete_add_op(True)
 
         expected = '''
-Op(plain_net), inputs:(@EMPTY@, X, Y, w), outputs:(@TEMP@fc@0, Out, fc.out).
+Op(plain_net), inputs:(W, X, Y), outputs:(Out, fc.out, pre_activation).
     Op(add_two), inputs:(X, Y), outputs:(Out).
-    Op(plain_net), inputs:(@EMPTY@, X, w), outputs:(@TEMP@fc@0, fc.out).
-        Op(fc), inputs:(X, w, @EMPTY@), outputs:(fc.out, @TEMP@fc@0).
-            Op(mul), inputs:(X, w), outputs:(@TEMP@fc@0).
-            Op(sigmoid), inputs:(@TEMP@fc@0), outputs:(fc.out).
+    Op(plain_net), inputs:(W, X), outputs:(fc.out, pre_activation).
+        Op(plain_net), inputs:(W, X), outputs:(fc.out, pre_activation).
+            Op(mul), inputs:(X, W), outputs:(pre_activation).
+            Op(sigmoid), inputs:(pre_activation), outputs:(fc.out).
 '''
         self.assertEqual(expected, "\n" + str(net))