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)
+add_library(recurrent_network_op recurrent_network_op.cc)
+cc_test(recurrent_network_op_test SRCS recurrent_network_op_test.cc)

paddle/framework/recurrent_network_op.cc

@@ -0,0 +1,103 @@
+#include "paddle/framework/recurrent_network_op.h"
+#include "paddle/framework/tensor.h"
+
+namespace paddle {
+namespace framework {
+
+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);
+  CreateMemories(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
+    // copy pre-memory
+    for (const auto& attr : memory_attrs_) {
+      Variable* pre_memory_var = step_scope->CreateVariable(attr.pre_var);
+      // copy boot_var to current memory in first step
+      if (step_id == 0) {
+        Variable* boot_var = step_scope->GetVariable(attr.boot_var);
+        *pre_memory_var->GetMutable<Tensor>() = *boot_var->GetMutable<Tensor>();
+        // copy varible of memory in previous scope to current pre-memory
+      } else {
+        Variable* pre_state_var = scopes[step_id - 1]->GetVariable(attr.var);
+        *pre_memory_var->GetMutable<Tensor>() =
+            *pre_state_var->GetMutable<Tensor>();
+      }
+    }
+
+    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::CreateMemories(Scope* scope) const {
+  Variable* scopes_var = scope->CreateVariable(step_scopes_name_);
+  auto scopes = scopes_var->GetMutable<std::vector<Scope*>>();
+  PADDLE_ENFORCE(!scopes->empty(), "step scopes should be created before.");
+
+  PADDLE_ENFORCE(!memory_attrs_.empty(),
+                 "memory attributes should be provided.");
+  for (size_t i = 0; i < scopes->size(); i++) {
+    for (const auto& attr : memory_attrs_) {
+      // check boot var exists
+      PADDLE_ENFORCE(scope->HasVariable(attr.boot_var),
+                     "boot var %s not in context scope", attr.boot_var);
+      // create the memory in this scope
+      scope->CreateVariable(attr.var);
+      // create pre-memory in this scope
+      scope->CreateVariable(attr.pre_var);
+      // TODO reference pre-memory to the memory in previous scope if Variance
+      // supports reference
+    }
+  }
+}
+
+}  // namespace framework
+}  // namespace paddle

paddle/framework/recurrent_network_op.h

@@ -0,0 +1,160 @@
+/* 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/enforce.h"
+#include "paddle/framework/scope.h"
+#include "paddle/framework/variable.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() {}
+  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
+// --------------------------------------------------------------------
+
+class RecurrentOp : public OperatorBase {
+ public:
+  RecurrentOp(NetDesc& net_desc)
+      : name_(net_desc.name_),
+        net_name_(net_desc.name_ + "__net__"),
+        step_scopes_name_(net_desc.name_ + "__step_scopes_") {}
+
+  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) const;
+
+ private:
+  /*
+   * these are defined in BaseOperator
+   *
+   * std::vector<std::string> inputs_;
+   * std::vector<std::string> outputs_;
+   */
+
+  // Memory of a RNN (same as the role of `Momory` in PaddlePaddle)
+  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;
+  };
+
+  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_`.
+  const std::string net_name_;
+  // name of steps' scopes which is stored in father scope with a unique key
+  // specified by `step_scopes_name_`.
+  const std::string step_scopes_name_;
+
+  const NetDesc step_net_desc_;
+};
+
+class RecurrentGradientOp;
+
+}  // namespace framework
+}  // namespace paddle

paddle/framework/recurrent_network_op_test.cc

@@ -0,0 +1,20 @@
+/*
+  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 {}  // namespace framework
+
+}  // namespace paddle

paddle/framework/tensor.h

@@ -42,6 +42,7 @@ class Tensor {
         || holder_->Size() < product(dims) * sizeof(T)) {
       holder_.reset(new PlaceholderImpl<T>(place, product(dims) * sizeof(T)));
     }
+    dims_ = dims;
     return static_cast<T*>(holder_->Ptr());
   }
 
@@ -51,6 +52,8 @@ class Tensor {
     return mutable_data<T>(dims, paddle::platform::get_place());
   }
 
+  const DDim& dims() const { return dims_; }
+
  private:
   // Placeholder hides type T, so it doesn't appear as a template
   // parameter of Variable.
@@ -91,6 +94,7 @@ class Tensor {
     size_t size_;                    // size of the memory block.
   };
 
+  DDim dims_;
   std::shared_ptr<Placeholder> holder_;  // holds the memory block if allocated.
 };
 

paddle/framework/variable.h

@@ -29,6 +29,11 @@ class Variable {
     return *static_cast<const T*>(holder_->Ptr());
   }
 
+  template <typename T>
+  void Reset(T* p) {
+    holder_.reset(new PlaceholderImpl<T>(p));
+  }
+
   template <typename T>
   T* GetMutable() {
     if (!IsType<T>()) {