[WIP] Backward

paddle/framework/CMakeLists.txt

@@ -17,6 +17,7 @@ cc_test(op_desc_test SRCS op_desc_test.cc DEPS op_desc protobuf)
 cc_library(operator SRCS operator.cc DEPS op_desc device_context tensor)
 cc_test(operator_test SRCS operator_test.cc DEPS operator op_registry)
 
+# cc_library(fc_op SRCS fully_connected_op.cc DEPS operator)
 cc_library(op_registry SRCS op_registry.cc DEPS op_proto op_desc enforce)
 cc_test(op_registry_test SRCS op_registry_test.cc DEPS op_registry operator)
 
@@ -26,5 +27,6 @@ add_custom_target(framework_py_proto_init ALL COMMAND ${CMAKE_COMMAND} -E touch
 add_dependencies(framework_py_proto framework_py_proto_init)
 
 proto_library(net_proto SRCS net_proto.proto DEPS op_proto)
+# cc_library(net SRCS net.cc DEPS operator net_proto op_registry fc_op)
 cc_library(net SRCS net.cc DEPS operator net_proto op_registry)
 cc_test(net_op_test SRCS net_op_test.cc DEPS net)

paddle/framework/fully_connected_op.h

@@ -0,0 +1,54 @@
+/* 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 <iostream>
+#include "paddle/framework/op_registry.h"
+
+namespace paddle {
+namespace framework {
+class FCOp : public OperatorBase {
+ public:
+  void Run(const ScopePtr& scope,
+           const platform::DeviceContext& dev_ctx) const override {
+    std::cout << "FC" << std::endl;
+  };
+  void InferShape(const ScopePtr& scope) const override{};
+};
+
+class FCOpProtoAndCheckerMaker : public OpProtoAndCheckerMaker {
+ public:
+  FCOpProtoAndCheckerMaker(OpProto* proto, OpAttrChecker* op_checker)
+      : OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("x", "input data");
+    AddInput("w", "weights");
+    AddInput("b", "bias");
+    AddOutput("y", "output data");
+    AddComment("Fully connnect op");
+  }
+};
+
+class FCGradientOp : public OperatorBase {
+  void Run(const ScopePtr& scope,
+           const platform::DeviceContext& dev_ctx) const override {
+    std::cout << "FCGrad" << std::endl;
+  };
+  void InferShape(const ScopePtr& scope) const override{};
+};
+
+// class FCGradientOpProtoAndCheckerMaker : public OpProtoAndCheckerMaker {};
+REGISTER_OP(my_fc, FCOp, FCOpProtoAndCheckerMaker);
+REGISTER_GRADIENT_OP(my_fc_grad, FCGradientOp);
+
+}  // namespace framework
+}  // namespace paddle

paddle/framework/net.cc

@@ -15,10 +15,24 @@
 */
 
 #include "paddle/framework/net.h"
+#include "paddle/framework/op_registry.h"
 
 namespace paddle {
 namespace framework {
 
+std::shared_ptr<PlainNet> AddBackwardOp(std::shared_ptr<PlainNet> ForwardOps) {
+  // NetPtr->reset(new PlainNet);
+  // NetPtr grad_ops = new PlainNet;
+  std::shared_ptr<PlainNet> grad_ops;
+  grad_ops.reset(new PlainNet);
+  for (auto& op : ForwardOps->ops_) {
+    auto op_grad = OpRegistry::CreateGradOp(op);
+    grad_ops->AddOp(op_grad);
+  }
+  grad_ops->CompleteAddOp();
+  return grad_ops;
+}
+
 void PlainNet::CompleteAddOp() {
   std::unordered_set<std::string> input_set;
   std::unordered_set<std::string> output_set;

paddle/framework/net.h

@@ -101,5 +101,7 @@ class PlainNet : public Net {
   }
 };
 
+std::shared_ptr<PlainNet> AddBackwardOp(std::shared_ptr<PlainNet> ForwardOps);
+
 }  // namespace framework
 }  // namespace paddle

paddle/framework/net_op_test.cc

@@ -2,19 +2,19 @@
 #include <paddle/framework/net.h>
 #include <paddle/framework/op_registry.h>
 #include <paddle/framework/operator.h>
+#include "paddle/framework/fully_connected_op.h"
 
-namespace pd = paddle::framework;
+namespace paddle {
+namespace framework {
 
 static int infer_shape_cnt = 0;
 static int run_cnt = 0;
 
-class TestOp : public pd::OperatorBase {
+class TestOp : public OperatorBase {
  public:
-  void InferShape(const paddle::framework::ScopePtr& scope) const override {
-    ++infer_shape_cnt;
-  }
-  void Run(const paddle::framework::ScopePtr& scope,
-           const paddle::platform::DeviceContext& dev_ctx) const override {
+  void InferShape(const ScopePtr& scope) const override { ++infer_shape_cnt; }
+  void Run(const ScopePtr& scope,
+           const platform::DeviceContext& dev_ctx) const override {
     ++run_cnt;
   }
 };
@@ -33,7 +33,7 @@ void AssertSameVectorWithoutOrder(const std::vector<T>& expected,
 }
 
 TEST(OpKernel, all) {
-  auto net = std::make_shared<paddle::framework::PlainNet>();
+  auto net = std::make_shared<PlainNet>();
   ASSERT_NE(net, nullptr);
 
   auto op1 = std::make_shared<TestOp>();
@@ -55,13 +55,29 @@ TEST(OpKernel, all) {
   ASSERT_EQ(1UL, tmp_idx.size());
   ASSERT_EQ("y", net->outputs_[tmp_idx[0]]);
 
-  auto scope = std::make_shared<pd::Scope>();
-  paddle::platform::CPUDeviceContext dev_ctx;
+  auto scope = std::make_shared<Scope>();
+  platform::CPUDeviceContext dev_ctx;
 
   net->InferShape(scope);
   net->Run(scope, dev_ctx);
   ASSERT_EQ(2, infer_shape_cnt);
   ASSERT_EQ(2, run_cnt);
 
-  ASSERT_THROW(net->AddOp(op2), paddle::framework::EnforceNotMet);
+  ASSERT_THROW(net->AddOp(op2), EnforceNotMet);
 }
+
+TEST(AddBackwardOp, TestGradOp) {
+  auto net = std::make_shared<PlainNet>();
+  ASSERT_NE(net, nullptr);
+  auto op1 = std::make_shared<FCOp>();
+  op1->inputs_ = {"x", "w1", "b1"};
+  op1->outputs_ = {"y"};
+  net->AddOp(op1);
+  auto grad_ops = AddBackwardOp(net);
+  for (auto& op : grad_ops->ops_) {
+    op->DebugString();
+  }
+}
+
+}  // namespace framework
+}  // namespace paddle