add rnn op interfaces

paddle/framework/CMakeLists.txt

@@ -16,3 +16,5 @@ py_proto_compile(framework_py_proto SRCS attr_type.proto op_proto.proto op_desc.
 # Generate an empty __init__.py to make framework_py_proto as a valid python module.
 add_custom_target(framework_py_proto_init ALL COMMAND ${CMAKE_COMMAND} -E touch __init__.py)
 add_dependencies(framework_py_proto framework_py_proto_init)
+cc_library(recurrent_network_op SRCS recurrent_network_op.cc DEPS op_desc)
+#cc_test(recurrent_network_op_test SRCS recurrent_network_op_test.cc)

paddle/framework/op_desc.proto

@@ -51,6 +51,9 @@ message OpDesc {
     // type of this Operator, such as "add", "sub", "fc".
     required string type = 3;
 
+    // the name of this Operator.
+    required string name = 4;
+
     // Attributes of this Operator. e.g., scale=3.0 in cosine op.
-    repeated AttrDesc attrs = 4;
-};
+    repeated AttrDesc attrs = 5;
+};

paddle/framework/recurrent_network_op.cc

@@ -0,0 +1,145 @@
+#include <glog/logging.h>
+#include <cstring>
+
+#include "paddle/framework/recurrent_network_op.h"
+#include "paddle/framework/tensor.h"
+
+namespace paddle {
+namespace framework {
+
+// fake op implementations
+namespace fake {
+class FcOp : public OperatorBase {
+ public:
+  FcOp(NetDesc& net_desc) : name_(net_desc.name_) {}
+
+  virtual void InferShape(const Scope* scope) const override {
+    LOG(INFO) << "fc InferShape";
+  }
+
+  virtual void Run(OpRunContext* contex) const override {
+    LOG(INFO) << "fc Run";
+  }
+
+ private:
+  std::string name_;
+};
+
+class SGDOptimizerOp : public OperatorBase {
+ public:
+  SGDOptimizerOp(NetDesc& net_desc) : name_(net_desc.name_) {}
+
+  virtual void InferShape(const Scope* scope) const override {
+    LOG(INFO) << "optimizer InferShape";
+  }
+
+  virtual void Run(OpRunContext* contex) const override {
+    LOG(INFO) << "optimizer Run";
+  }
+
+ private:
+  std::string name_;
+};
+};  // namespace fake
+
+void RecurrentOp::Run(OpRunContext* contex) const {
+  auto scope = contex->scope;
+
+  if (!scope->HasVariable(net_name_)) {
+    CreateStepNet(scope);
+  }
+  Variable* net = scope->GetVariable(net_name_);
+  PADDLE_ENFORCE(net, "failed to get step net");
+
+  CreateScopes(scope);
+  SegmentInputs(scope);
+
+  Variable* step_scopes = scope->GetVariable(step_scopes_name_);
+  PADDLE_ENFORCE(step_scopes, "failed to get step scopes");
+  // forward
+  auto dims = Input(scope, 0)->GetMutable<Tensor>()->dims();
+  size_t seq_len = dims[1];
+  auto& scopes = *step_scopes->GetMutable<std::vector<Scope*>>();
+  for (size_t step_id = 0; step_id < seq_len; step_id++) {
+    Scope* step_scope = scopes[step_id];
+    // TODO replace memorys' copy with reference
+    LinkMemories(scope, scopes, step_id);
+
+    net->GetMutable<PlainNet>()->Run(step_scope);
+  }
+
+  // prepare outputs
+  ConcateOutputs(scope);
+}
+
+void RecurrentOp::CreateScopes(Scope* scope) const {
+  auto dims = Input(scope, 0)->GetMutable<Tensor>()->dims();
+  size_t seq_len = dims[1];
+  Variable* scopes_var = scope->GetVariable(step_scopes_name_);
+  // auto step_scopes =
+  // scopes_var->GetMutable<std::vector<std::shared_ptr<Scope>>>();
+  auto step_scopes = scopes_var->GetMutable<std::vector<Scope*>>();
+  // TODO Only two scopes are needed for inference, this case will be supported
+  // later.
+  if (seq_len > step_scopes->size()) {
+    for (size_t i = step_scopes->size(); i < seq_len; ++i) {
+      // step_scopes->push_back(std::make_shared<Scope>(
+      // std::shared_ptr<Scope>(scope)));
+      step_scopes->push_back(new Scope(std::shared_ptr<Scope>(scope)));
+    }
+  }
+}
+
+void RecurrentOp::CreateStepNet(Scope* scope) const {
+  Variable* var = scope->CreateVariable(net_name_);
+  auto step_net = GetAttr<std::string>("step_net");
+  // get the step net proto from the string.
+  // PADDLE_ENFORCE(
+  //   google::protobuf::TextFormat::ParseFromString(step_net,
+  //   &step_net_desc_));
+  // this is a fake net, it will be rewrite after the network has been merged.
+  var->Reset<PlainNet>(new PlainNet(step_net));
+}
+
+void RecurrentOp::LinkMemories(Scope* scope, std::vector<Scope*>& step_scopes,
+                               size_t step) const {
+  PADDLE_ENFORCE(step < step_scopes.size(),
+                 "step [%d] out of range of step scopes' size [%d]", step,
+                 step_scopes.size());
+  // copy boot memory
+  for (auto& attr : memory_attrs_) {
+    Scope* step_scope = step_scopes[step];
+
+    Tensor* boot_tensor{nullptr};
+    Variable* memory_var = step_scope->CreateVariable(attr.pre_var);
+    if (step == 0) {
+      PADDLE_ENFORCE(scope->HasVariable(attr.boot_var),
+                     "memory [%s]'s boot variable [%s] not exists", attr.var,
+                     attr.boot_var);
+      // update memory's ddim
+      boot_tensor = scope->CreateVariable(attr.boot_var)->GetMutable<Tensor>();
+      attr.dims = boot_tensor->dims();
+    }
+
+    // copy from boot memory
+    // TODO support more device
+    float* memory_tensor_val =
+        memory_var->GetMutable<Tensor>()->mutable_data<float>(
+            attr.dims, platform::CPUPlace());
+    if (step == 0) {
+      PADDLE_ENFORCE(boot_tensor, "boot_tensor should be retrieved before");
+      // copy from boot memory
+      std::memcpy(memory_tensor_val, boot_tensor->data<float>(),
+                  product(attr.dims));
+    } else {
+      // copy from previous step scope's memory to this scope's `pre-memory`
+      Tensor* pre_step_memory =
+          step_scopes[step - 1]->GetVariable(attr.var)->GetMutable<Tensor>();
+      std::memcpy(memory_tensor_val, pre_step_memory->data<float>(),
+                  product(attr.dims));
+    }
+  }
+}
+
+}  // namespace framework
+}  // namespace paddle

paddle/framework/recurrent_network_op.h

@@ -0,0 +1,200 @@
+/* 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. */
+
+#pragma once
+
+#include <google/protobuf/text_format.h>
+#include "paddle/framework/attr_checker.h"
+#include "paddle/framework/ddim.h"
+#include "paddle/framework/enforce.h"
+#include "paddle/framework/scope.h"
+#include "paddle/framework/variable.h"
+
+// Remove when including operator.h
+#include "paddle/framework/attr_checker.h"
+#include "paddle/framework/op_desc.pb.h"
+
+namespace paddle {
+namespace framework {
+
+// --------------------------------------------------------------------
+// fake interfaces that has not be implemented by other modules.
+// TODO keep updating according to other modules' designs.
+struct OpRunContext {
+  Scope* scope;
+};
+
+// TODO replace this with Net's proto.
+struct NetDesc {
+  std::string name_;
+};
+
+class PlainNet {
+ public:
+  PlainNet() {}
+  PlainNet(const NetDesc& desc) {}
+  PlainNet(const std::string desc) {}
+  void Run(Scope* scope) {}
+};
+
+class OperatorBase {
+ public:
+  virtual ~OperatorBase() {}
+  void Init(const OpDesc& op_desc, AttributeMap& attrs) {}
+  virtual void Run(OpRunContext* context) const = 0;
+  virtual void InferShape(const Scope* scope) const = 0;
+  inline Variable* Input(Scope* scope, int index) const {
+    return scope->GetVariable(inputs_[index]);
+  };
+
+  template <typename T>
+  inline const T GetAttr(const std::string& name) const {
+    return boost::get<T>(attrs_.at(name));
+  }
+
+ protected:
+  std::vector<std::string> inputs_;
+  std::vector<std::string> outputs_;
+  AttributeMap attrs_;
+};
+// fake interfaces end
+// --------------------------------------------------------------------
+// TODO:
+// 1. No-padding computing for sequences with indifinite length in one batch.
+// 2. Hierarchical RNN for sequence with sub-sequence.
+// 3. Multi-inputs with indifinate length for RecurrentOp.
+class RecurrentOp : public OperatorBase {
+ public:
+  void Init(const OpDesc& op_desc, AttributeMap& attrs) {
+    OperatorBase::Init(op_desc, attrs);
+    name_ = op_desc.name();
+    net_name_ = op_desc.name() + "_net";
+    step_scopes_name_ = op_desc.name() + "_step_scopes";
+    auto memories = GetAttr<std::vector<std::string>>("memories");
+    auto boot_memories = GetAttr<std::vector<std::string>>("boot_memories");
+    PADDLE_ENFORCE(memories.size() == boot_memories.size(),
+                   "The size of memories and boot_memories is mismatched.");
+    for (size_t i = 0; i < memories.size(); ++i) {
+      MemoryAttr mem_attr;
+      mem_attr.var = memories[i];
+      mem_attr.boot_var = boot_memories[i];
+      memory_attrs_.push_back(mem_attr);
+    }
+  }
+
+  virtual void InferShape(const Scope* scope) const override;
+
+  /*
+   * Forward run the RNN.
+   *
+   * NOTE the context's scope is not given until `Run` called, so step scopes'
+   * father should be set/updated in this method.
+   */
+  virtual void Run(OpRunContext* contex) const override;
+
+ protected:
+  /*
+   * Prepare inputs for each stepnet.
+   */
+  void SegmentInputs(Scope* scope) const {};
+
+  /*
+   * Process outputs of stepnets and merge to variables.
+   */
+  void ConcateOutputs(Scope* scope) const {};
+
+  /*
+   * Create a `Net` which is shared across all steps.
+   */
+  void CreateStepNet(Scope* scope) const;
+
+  /*
+   * Create a scope for each step, the context's scope is shared across all
+   * the step scopes as the father scope. The step scopes will be stored in
+   * the father scope as a variable whose name is specified by
+   * `step_scopes_name_`.
+   *
+   * NOTE the scopes are reused by both the `Forward` and `Backward`, so just
+   * create once and expand its size if more steps need.
+   */
+  void CreateScopes(Scope* scope) const;
+
+  /*
+   * Create memories in each step scope.
+   */
+  // void CreateMemories(Scope* scope) const;
+
+  /*
+   * Link memory in previous step scope to current scope.
+   */
+  void LinkMemories(Scope* scope, std::vector<Scope*>& step_scopes,
+                    size_t step) const;
+
+ private:
+  /*
+   * Memory of a RNN (same as the role of `Momory` in PaddlePaddle).
+   *
+   * Memory attributes cached by this op, dims will be infered from
+   * boot memories in father scope. Other attributes are copied from Op's proto
+   * attributes.
+   */
+  struct MemoryAttr {
+    // name of current state variable
+    std::string var;
+    // name of previous step's state variable
+    std::string pre_var;
+    // name of the variables to init this memory (same role of `boot_layer` in
+    // PaddlePaddle), which is store in father's scope.
+    std::string boot_var;
+    // this dim will infered from boot memories's tensor in the first step.
+    DDim dims;
+  };
+
+  /*
+   * The attributes in protobuf about the memory description and the booted
+   * memory description are as follows. The number of booted memories should
+   * equal to the memories number.
+   *
+   *   arg {
+   *       name: “memories”
+   *       strings: "hidden”
+   *       strings: "state”
+   *   }
+   *   arg {
+   *       name: “boot_memories”
+   *       strings: "boot_hidden”
+   *       strings: "boot_state”
+   *   }
+   */
+  // TODO copy from OpBase's
+  mutable std::vector<MemoryAttr> memory_attrs_;
+
+  // this op's name, used as a unique key in father scope.
+  // TODO repace it with OpBase's interface if supported.
+  std::string name_;
+  // name of rnn op's step net, the step net will be shared by both `Forward`
+  // and `Backward`, so we store it as a variable in father's scope, with a
+  // unique key specified by `net_name_`.
+  std::string net_name_;
+  // name of steps' scopes which is stored in father scope with a unique key
+  // specified by `step_scopes_name_`.
+  std::string step_scopes_name_;
+
+  NetDesc step_net_desc_;
+};
+
+class RecurrentGradientOp;
+
+}  // namespace framework
+}  // namespace paddle

paddle/framework/recurrent_network_op_test.cc

@@ -0,0 +1,26 @@
+/*
+  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/framework/recurrent_network_op.h"
+#include "gtest/gtest.h"
+
+namespace paddle {
+namespace framework {
+
+class RecurrentOpTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() override {}
+};
+}  // namespace framework
+
+}  // namespace paddle