recurrent_op.cc 7.2 KB
Newer Older
Y
Yan Chunwei 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* 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. */

15
#include "paddle/operators/recurrent_op.h"
Y
Yan Chunwei 已提交
16 17 18 19 20

#include <cstring>
#include <sstream>

#include "paddle/framework/op_registry.h"
Y
Yan Chunwei 已提交
21
#include "paddle/operators/net_op.h"
Y
Yan Chunwei 已提交
22 23 24 25

namespace paddle {
namespace operators {

D
dongzhihong 已提交
26 27 28
using Scope = framework::Scope;
using Variable = framework::Variable;
using Tensor = framework::Tensor;
29
using LoDTensor = framework::LoDTensor;
D
dongzhihong 已提交
30

Q
qiaolongfei 已提交
31 32
void RecurrentAlgorithm::Run(const Scope& scope,
                             const platform::DeviceContext& dev_ctx) const {
Q
qiaolongfei 已提交
33 34
  auto* input0 = scope.FindVar(arg_->inlinks[0]);
  PADDLE_ENFORCE_NOT_NULL(input0);
Q
qiaolongfei 已提交
35 36
  size_t seq_len = input0->GetMutable<LoDTensor>()->dims()[0];
  PADDLE_ENFORCE_GT(seq_len, 0);
Q
qiaolongfei 已提交
37

Q
qiaolongfei 已提交
38
  CreateScopes(scope, seq_len);
Q
qiaolongfei 已提交
39
  auto& step_scopes = GetStepScopes(scope);
Q
qiaolongfei 已提交
40
  rnn::SegmentInputs(step_scopes, arg_->inlinks, seq_len);
Q
qiaolongfei 已提交
41
  InitMemories(step_scopes[0]);
Q
qiaolongfei 已提交
42

Q
qiaolongfei 已提交
43 44 45
  for (size_t step_id = 0; step_id < seq_len; step_id++) {
    if (step_id > 0) {
      rnn::LinkMemories(step_scopes, arg_->memories, step_id, -1);
Y
Yan Chunwei 已提交
46
    }
Q
qiaolongfei 已提交
47
    (*stepnet_)->Run(*step_scopes[step_id], dev_ctx);
Y
Yan Chunwei 已提交
48
  }
Q
qiaolongfei 已提交
49
  rnn::ConcatOutputs(step_scopes, arg_->outlinks, seq_len);
Y
Yan Chunwei 已提交
50 51
}

Q
qiaolongfei 已提交
52 53
void RecurrentAlgorithm::CreateScopes(const Scope& scope,
                                      size_t seq_len) const {
Y
Yan Chunwei 已提交
54
  // TODO(superjom) Only two scopes are needed for inference, this case will be
Y
Yan Chunwei 已提交
55
  // supported later.
Q
qiaolongfei 已提交
56
  auto* step_scopes_var = scope.FindVar(arg_->step_scopes);
Y
Yan Chunwei 已提交
57
  PADDLE_ENFORCE(step_scopes_var != nullptr, "");
Q
qiaolongfei 已提交
58
  auto* step_scopes = step_scopes_var->GetMutable<std::vector<Scope*>>();
Y
Yan Chunwei 已提交
59 60

  // Now all variables in scope must be created outside of op.
Y
Yan Chunwei 已提交
61 62
  PADDLE_ENFORCE_NOT_NULL(stepnet_);
  PADDLE_ENFORCE(!(*stepnet_)->Outputs().empty(), "stepnet_ op has no outputs");
Y
Yan Chunwei 已提交
63

Q
qiaolongfei 已提交
64 65
  if (seq_len > step_scopes->size()) {
    for (size_t i = step_scopes->size(); i < seq_len; ++i) {
Y
Yu Yang 已提交
66
      auto& step_scope = scope.NewScope();
Y
Yan Chunwei 已提交
67

Y
Yan Chunwei 已提交
68
      // create step net's temp inputs
Y
Yan Chunwei 已提交
69
      for (auto& input : (*stepnet_)->Inputs()) {
70
        // the weight are located in parent scope
Y
Yu Yang 已提交
71 72
        for (auto& var_name : input.second) {
          if (!step_scope.FindVar(var_name)) {
73
            step_scope.NewVar(var_name)->GetMutable<LoDTensor>();
Y
Yu Yang 已提交
74 75
          }
        }
Y
Yan Chunwei 已提交
76
      }
Y
Yan Chunwei 已提交
77
      // create stepnet's outputs
Y
Yan Chunwei 已提交
78
      for (const auto& output : (*stepnet_)->Outputs()) {
Y
Yu Yang 已提交
79 80 81
        for (auto& var_name : output.second) {
          step_scope.NewVar(var_name);
        }
Y
Yan Chunwei 已提交
82
      }
Y
Yu Yang 已提交
83
      step_scopes->emplace_back(&step_scope);
Y
Yan Chunwei 已提交
84 85 86 87
    }
  }
}

Q
qiaolongfei 已提交
88
void RecurrentAlgorithm::InitMemories(Scope* step_scope) const {
Y
Yan Chunwei 已提交
89
  for (auto& attr : arg_->memories) {
90
    auto* pre_mem = step_scope->NewVar(attr.pre_var)->GetMutable<LoDTensor>();
Y
Yu Yang 已提交
91
    PADDLE_ENFORCE(step_scope->FindVar(attr.boot_var) != nullptr,
92
                   "memory [%s]'s boot variable [%s] not exists", attr.var,
Y
Yan Chunwei 已提交
93
                   attr.boot_var);
94 95
    auto* boot_mem =
        step_scope->FindVar(attr.boot_var)->GetMutable<LoDTensor>();
Q
qiaolongfei 已提交
96 97 98
    pre_mem->Resize(boot_mem->dims());
    PADDLE_ENFORCE_EQ(pre_mem->dims().size(), 2);
    pre_mem->ShareDataWith<float>(*boot_mem);
Y
Yan Chunwei 已提交
99 100 101
  }
}

102
const rnn::ArgumentName RecurrentOp::kArgName{
S
superjom 已提交
103
    "step_net", "step_scopes",  "inlinks",      "outlinks",
104 105 106
    "memories", "pre_memories", "boot_memories"};

const rnn::ArgumentName RecurrentGradientOp::kArgName{
S
superjom 已提交
107 108
    "step_net", "step_scopes@GRAD", "outlinks@GRAD",     "inlinks@GRAD",
    "memories", "pre_memories",     "boot_memories@GRAD"};
Y
Yan Chunwei 已提交
109

Y
Yu Yang 已提交
110
RecurrentOp::RecurrentOp(const std::string& type,
Y
Yu Yang 已提交
111 112
                         const framework::VariableNameMap& inputs,
                         const framework::VariableNameMap& outputs,
Y
Yu Yang 已提交
113 114
                         const framework::AttributeMap& attrs)
    : OperatorBase(type, inputs, outputs, attrs) {
Y
Yan Chunwei 已提交
115 116
  rnn::InitArgument(kArgName, &arg_, *this);
  alg_.Init(&arg_, &stepnet_);
Y
Yan Chunwei 已提交
117 118
}

D
dongzhihong 已提交
119 120
class RecurrentAlgorithmProtoAndCheckerMaker
    : public framework::OpProtoAndCheckerMaker {
121
 public:
D
dongzhihong 已提交
122 123
  RecurrentAlgorithmProtoAndCheckerMaker(framework::OpProto* proto,
                                         framework::OpAttrChecker* op_checker)
Y
Yan Chunwei 已提交
124 125 126
      : OpProtoAndCheckerMaker(proto, op_checker) {
    const auto& name = RecurrentOp::kArgName;
    // inputs and outputs stored in proto
D
dangqingqing 已提交
127 128
    AddInput(name.inlinks,
             "the inputs that need to be segmented for each step.")
Y
Yu Yang 已提交
129
        .AsDuplicable();
Y
Yu Yang 已提交
130
    AddInput(name.boot_memories, "variables to initialize memories.")
Y
Yu Yang 已提交
131
        .AsDuplicable();
Y
Yan Chunwei 已提交
132

D
dangqingqing 已提交
133
    AddOutput(name.outlinks, "the outputs that need to concated for all steps.")
Y
Yu Yang 已提交
134
        .AsDuplicable();
Y
Yan Chunwei 已提交
135 136 137 138 139 140 141 142 143 144 145 146
    AddOutput(name.step_scopes, "step scopes");

    // Attributes stored in AttributeMap
    AddAttr<std::vector<std::string>>(name.pre_memories,
                                      "names of pre-memories");
    AddAttr<std::vector<std::string>>(name.memories, "names of memories");

    AddComment("This is a recurrent group operator.");
  }
};

void RecurrentGradientAlgorithm::Run(
Y
Yu Yang 已提交
147
    const Scope& scope, const platform::DeviceContext& dev_ctx) const {
Q
qiaolongfei 已提交
148 149 150
  auto* input0 = scope.FindVar(arg_->inlinks[0]);
  PADDLE_ENFORCE_NOT_NULL(input0);
  size_t seq_len = input0->GetMutable<LoDTensor>()->dims()[0];
Q
qiaolongfei 已提交
151
  auto& step_scopes = GetStepScopes(scope);
Q
qiaolongfei 已提交
152 153 154
  rnn::SegmentInputs(step_scopes, arg_->inlinks, seq_len);
  for (int step_id = seq_len - 1; step_id >= 0; --step_id) {
    if (step_id != seq_len - 1) {
Q
qiaolongfei 已提交
155
      rnn::LinkMemories(step_scopes, arg_->memories, step_id, 1);
Y
Yan Chunwei 已提交
156
    }
Y
Yan Chunwei 已提交
157
    (*stepnet_)->Run(*step_scopes[step_id], dev_ctx);
Y
Yan Chunwei 已提交
158
  }
Q
qiaolongfei 已提交
159
  rnn::ConcatOutputs(step_scopes, arg_->outlinks, seq_len);
Q
qiaolongfei 已提交
160
  LinkBootMemoryGradients(step_scopes[0]);
Y
Yan Chunwei 已提交
161 162 163
}

void RecurrentGradientAlgorithm::LinkBootMemoryGradients(
Q
qiaolongfei 已提交
164
    Scope* step_scope) const {
Y
Yan Chunwei 已提交
165
  for (auto& attr : arg_->memories) {
D
dangqingqing 已提交
166
    PADDLE_ENFORCE(step_scope->FindVar(attr.var) != nullptr,
167
                   "memory variable [%s] does not exists", attr.var);
Y
Yu Yang 已提交
168
    PADDLE_ENFORCE(step_scope->FindVar(attr.boot_var) != nullptr,
169
                   "boot variable [%s] does not exists", attr.boot_var);
170 171 172
    auto* mem_grad = step_scope->NewVar(attr.var)->GetMutable<LoDTensor>();
    auto* boot_mem_grad =
        step_scope->NewVar(attr.boot_var)->GetMutable<LoDTensor>();
Q
qiaolongfei 已提交
173 174
    boot_mem_grad->Resize(mem_grad->dims());
    boot_mem_grad->ShareDataWith<float>(*mem_grad);
Q
qiaolongfei 已提交
175 176 177
  }
}

Y
Yu Yang 已提交
178
RecurrentGradientOp::RecurrentGradientOp(
Y
Yu Yang 已提交
179 180
    const std::string& type, const framework::VariableNameMap& inputs,
    const framework::VariableNameMap& outputs,
Y
Yu Yang 已提交
181 182
    const framework::AttributeMap& attrs)
    : OperatorBase(type, inputs, outputs, attrs) {
S
superjom 已提交
183
  rnn::InitArgument(kArgName, &arg_, *this, true /*is grad*/);
Y
Yan Chunwei 已提交
184
  alg_.Init(&arg_, &stepnet_);
Y
Yan Chunwei 已提交
185 186 187 188 189
}

}  // namespace operators
}  // namespace paddle

S
superjom 已提交
190 191 192
REGISTER_OP(recurrent, paddle::operators::RecurrentOp,
            paddle::operators::RecurrentAlgorithmProtoAndCheckerMaker,
            recurrent_grad, paddle::operators::RecurrentGradientOp);