lstm_op.cc 11.7 KB
Newer Older
D
dangqingqing 已提交
1 2
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

D
dangqingqing 已提交
3 4 5
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
D
dangqingqing 已提交
6

D
dangqingqing 已提交
7
http://www.apache.org/licenses/LICENSE-2.0
D
dangqingqing 已提交
8

D
dangqingqing 已提交
9 10 11 12 13
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. */
D
dangqingqing 已提交
14

D
dangqingqing 已提交
15
#include "paddle/operators/lstm_op.h"
D
dangqingqing 已提交
16 17 18 19 20 21 22 23

namespace paddle {
namespace operators {

class LSTMOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

24
  void InferShape(framework::InferShapeContext* ctx) const override {
D
dangqingqing 已提交
25 26
    PADDLE_ENFORCE(ctx->HasInput("Input"),
                   "Input(Input) of LSTM should not be null.");
27 28 29 30 31
    PADDLE_ENFORCE(ctx->HasInput("Weight"),
                   "Input(Weight) of LSTM should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Bias"),
                   "Input(Bias) of LSTM should not be null.");

D
dangqingqing 已提交
32 33
    PADDLE_ENFORCE(ctx->HasOutput("Hidden"),
                   "Output(Hidden) of LSTM should not be null.");
34
    PADDLE_ENFORCE(ctx->HasOutput("Cell"),
D
dangqingqing 已提交
35
                   "Output(Cell) of LSTM should not be null.");
36 37 38 39
    PADDLE_ENFORCE(ctx->HasOutput("BatchGate"),
                   "Output(BatchGate) of LSTM should not be null.");
    PADDLE_ENFORCE(ctx->HasOutput("BatchCellPreAct"),
                   "Output(BatchGate) of LSTM should not be null.");
D
dangqingqing 已提交
40

D
dangqingqing 已提交
41 42
    auto in_dims = ctx->GetInputDim("Input");
    PADDLE_ENFORCE_EQ(in_dims.size(), 2, "Input(X)'s rank must be 2.");
D
dangqingqing 已提交
43 44 45 46 47 48 49 50 51 52 53 54

    if (ctx->HasInput("H0")) {
      PADDLE_ENFORCE(ctx->HasInput("C0"),
                     "Input(Cell) and Input(Hidden) of LSTM should not "
                     "be null at the same time.");
      auto h_dims = ctx->GetInputDim("H0");
      auto c_dims = ctx->GetInputDim("C0");
      PADDLE_ENFORCE(h_dims == c_dims,
                     "The dimension of Input(H0) and Input(C0) "
                     "should be the same.");
    }

D
dangqingqing 已提交
55
    int frame_size = in_dims[1] / 4;
D
dangqingqing 已提交
56 57 58 59 60 61 62 63 64 65 66
    auto w_dims = ctx->GetInputDim("Weight");
    PADDLE_ENFORCE_EQ(w_dims.size(), 2,
                      "The rank of Input(Weight) should be 2.");
    PADDLE_ENFORCE_EQ(w_dims[0], frame_size,
                      "The first dimension of Input(Weight) "
                      "should be %d.",
                      frame_size);
    PADDLE_ENFORCE_EQ(w_dims[1], 4 * frame_size,
                      "The second dimension of Input(Weight) "
                      "should be 4 * %d.",
                      frame_size);
67

D
dangqingqing 已提交
68 69 70 71
    auto b_dims = ctx->GetInputDim("Bias");
    PADDLE_ENFORCE_EQ(b_dims.size(), 2, "The rank of Input(Bias) should be 2.");
    PADDLE_ENFORCE_EQ(b_dims[0], 1,
                      "The first dimension of Input(Bias) should be 1.");
72 73

    if (ctx->Attrs().Get<bool>("use_peepholes")) {
D
dangqingqing 已提交
74 75 76 77 78 79 80
      PADDLE_ENFORCE_EQ(b_dims[1], 7 * frame_size,
                        "The second dimension of Input(Bias) should be "
                        "7 * %d if enable peepholes connection",
                        frame_size);
    } else {
      PADDLE_ENFORCE_EQ(b_dims[1], 4 * frame_size,
                        "The second dimension of Input(Bias) should be "
Y
Yu Yang 已提交
81
                        "4 * %d if disable peepholes connection",
D
dangqingqing 已提交
82 83
                        frame_size);
    }
84

D
dangqingqing 已提交
85 86 87 88 89
    framework::DDim out_dims({in_dims[0], frame_size});
    ctx->SetOutputDim("Hidden", out_dims);
    ctx->SetOutputDim("Cell", out_dims);
    ctx->SetOutputDim("BatchGate", in_dims);
    ctx->SetOutputDim("BatchCellPreAct", out_dims);
D
dangqingqing 已提交
90 91 92
    ctx->ShareLoD("Input", "Hidden");
    ctx->ShareLoD("Input", "Cell");
  }
93 94

 protected:
95
  framework::OpKernelType GetExpectedKernelType(
96
      const framework::ExecutionContext& ctx) const override {
Y
Yu Yang 已提交
97 98 99
    return framework::OpKernelType(
        framework::ToDataType(ctx.Input<framework::LoDTensor>("Input")->type()),
        ctx.device_context());
100
  }
D
dangqingqing 已提交
101 102 103 104
};

class LSTMOpMaker : public framework::OpProtoAndCheckerMaker {
 public:
105
  LSTMOpMaker(OpProto* proto, OpAttrChecker* op_checker)
D
dangqingqing 已提交
106 107 108 109
      : OpProtoAndCheckerMaker(proto, op_checker) {
    AddInput("Input",
             "(LoDTensor) the first input is a LodTensor, which support "
             "variable-time length input sequence. The underlying tensor in "
D
dangqingqing 已提交
110
             "this LoDTensor is a matrix with shape (T X 4D), where T is the "
D
dangqingqing 已提交
111 112 113 114
             "total time steps in this mini-batch, D is the hidden size.");
    AddInput("H0",
             "(Tensor, optional) the initial hidden state is an optional "
             "input. This is a tensor with shape (N x D), where N is the "
K
kexinzhao 已提交
115
             "batch size and D is the hidden size.")
116
        .AsDispensable();
D
dangqingqing 已提交
117 118 119
    AddInput("C0",
             "(Tensor, optional) the initial cell state is an optional "
             "input. This is a tensor with shape (N x D), where N is the "
Y
Yibing Liu 已提交
120
             "batch size. `H0` and `C0` can be NULL but only at the same time.")
121
        .AsDispensable();
D
dangqingqing 已提交
122 123
    AddInput("Weight",
             "(Tensor) the learnable hidden-hidden weights."
D
dangqingqing 已提交
124 125
             " - The shape is (D x 4D), where D is the hidden size. "
             " - Weight = {W_ch, W_ih, W_fh, W_oh}");
D
dangqingqing 已提交
126 127 128
    AddInput("Bias",
             "(Tensor) the learnable weights, which contains two parts: "
             "input-hidden bias weight and peephole connections weight if "
129 130
             "setting `use_peepholes` True. "
             "1. `use_peepholes = False` "
D
dangqingqing 已提交
131 132
             " - The shape is (1 x 4D). "
             " - Bias = {b_c, b_i, b_f, b_o}."
133
             "2. `use_peepholes = True` "
D
dangqingqing 已提交
134
             " - The shape is (1 x 7D). "
135
             " - Bias = {b_c, b_i, b_f, b_o, W_ic, W_fc, W_oc}.");
D
dangqingqing 已提交
136
    AddOutput("Hidden",
D
dangqingqing 已提交
137 138
              "(LoDTensor) the hidden state of LSTM operator. "
              "The shape is (T x D), and lod is the same with the `Input`.");
D
dangqingqing 已提交
139
    AddOutput("Cell",
D
dangqingqing 已提交
140 141
              "(LoDTensor) the cell state of LSTM operator. "
              "The shape is (T x D), and lod is the same with the `Input`.");
142 143
    AddOutput("BatchGate",
              "(LoDTensor) This LoDTensor contains input gate, forget gate "
Y
Yu Yang 已提交
144
              "and output gate after the nonlinear computation. This "
K
kexinzhao 已提交
145
              "LoDTensor has the same shape as the reorganized input, which "
D
dangqingqing 已提交
146
              "is also be called batch input. The LoD size is 2. The first "
147 148 149
              "LoD is the batch offsets and the second LoD contains the "
              "indexes, which denote the position of reorganized sequence "
              "in the raw input.")
D
dangqingqing 已提交
150
        .AsIntermediate();
D
dangqingqing 已提交
151
    AddOutput("BatchCellPreAct",
K
kexinzhao 已提交
152
              "(LoDTensor) This LoDTensor is obtained in the forward and used "
D
dangqingqing 已提交
153 154
              "in the backward.")
        .AsIntermediate();
155
    AddAttr<bool>("use_peepholes",
D
dangqingqing 已提交
156 157 158
                  "(bool, defalut: True) "
                  "whether to enable diagonal/peephole connections.")
        .SetDefault(true);
159
    AddAttr<bool>("is_reverse",
D
dangqingqing 已提交
160 161
                  "(bool, defalut: False) "
                  "whether to compute reversed LSTM.")
162
        .SetDefault(false);
D
dangqingqing 已提交
163
    AddAttr<std::string>(
164
        "gate_activation",
Y
Yu Yang 已提交
165
        "(string, default: sigmoid)"
D
dangqingqing 已提交
166
        "The activation for input gate, forget gate and output "
Y
Yu Yang 已提交
167
        "gate, `sigmoid` by default.")
D
dangqingqing 已提交
168 169
        .SetDefault("sigmoid")
        .InEnum({"sigmoid", "tanh", "relu", "identity"});
170
    AddAttr<std::string>("cell_activation",
Y
Yu Yang 已提交
171
                         "(string, default: tanh)"
D
dangqingqing 已提交
172
                         "The activation for cell output, `tanh` by defalut.")
D
dangqingqing 已提交
173 174
        .SetDefault("tanh")
        .InEnum({"sigmoid", "tanh", "relu", "identity"});
175
    AddAttr<std::string>("candidate_activation",
Y
Yu Yang 已提交
176
                         "(string, default: tanh)"
D
dangqingqing 已提交
177
                         "The activation for candidate hidden state, "
Y
Yu Yang 已提交
178
                         "`tanh` by default.")
D
dangqingqing 已提交
179 180
        .SetDefault("tanh")
        .InEnum({"sigmoid", "tanh", "relu", "identity"});
K
kexinzhao 已提交
181 182
    AddComment(R"DOC(
Long-Short Term Memory (LSTM) Operator.
D
dangqingqing 已提交
183

D
dangqingqing 已提交
184
The defalut implementation is diagonal/peephole connection
K
kexinzhao 已提交
185
(https://arxiv.org/pdf/1402.1128.pdf), the formula is as follows:
D
dangqingqing 已提交
186

K
kexinzhao 已提交
187 188
$$
i_t = \sigma(W_{ix}x_{t} + W_{ih}h_{t-1} + W_{ic}c_{t-1} + b_i) \\
D
dangqingqing 已提交
189

K
kexinzhao 已提交
190
f_t = \sigma(W_{fx}x_{t} + W_{fh}h_{t-1} + W_{fc}c_{t-1} + b_f) \\
D
dangqingqing 已提交
191

K
kexinzhao 已提交
192
\tilde{c_t} = act_g(W_{cx}x_t + W_{ch}h_{t-1} + b_c) \\
D
dangqingqing 已提交
193

K
kexinzhao 已提交
194
o_t = \sigma(W_{ox}x_{t} + W_{oh}h_{t-1} + W_{oc}c_t + b_o) \\
D
dangqingqing 已提交
195

K
kexinzhao 已提交
196
c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c_t} \\
D
dangqingqing 已提交
197

K
kexinzhao 已提交
198 199
h_t = o_t \odot act_h(c_t)
$$
D
dangqingqing 已提交
200

D
dangqingqing 已提交
201 202
where the W terms denote weight matrices (e.g. $W_{xi}$ is the matrix
of weights from the input gate to the input), $W_{ic}, W_{fc}, W_{oc}$
K
kexinzhao 已提交
203 204
are diagonal weight matrices for peephole connections. In our implementation,
we use vectors to reprenset these diagonal weight matrices. The b terms
D
dangqingqing 已提交
205
denote bias vectors ($b_i$ is the input gate bias vector), $\sigma$
K
kexinzhao 已提交
206
is the non-line activations, such as logistic sigmoid function, and
D
dangqingqing 已提交
207
$i, f, o$ and $c$ are the input gate, forget gate, output gate,
K
kexinzhao 已提交
208
and cell activation vectors, respectively, all of which have the same size as
D
dangqingqing 已提交
209
the cell output activation vector $h$.
D
dangqingqing 已提交
210

D
dangqingqing 已提交
211
The $\odot$ is the element-wise product of the vectors. $act_g$ and $act_h$
K
kexinzhao 已提交
212
are the cell input and cell output activation functions and `tanh` is usually
D
dangqingqing 已提交
213
used for them. $\tilde{c_t}$ is also called candidate hidden state,
D
dangqingqing 已提交
214 215
which is computed based on the current input and the previous hidden state.

D
dangqingqing 已提交
216 217 218
Set `use_peepholes` False to disable peephole connection. The formula
is omitted here, please refer to the paper
http://www.bioinf.jku.at/publications/older/2604.pdf for details.
D
dangqingqing 已提交
219

D
dangqingqing 已提交
220 221
Note that these $W_{xi}x_{t}, W_{xf}x_{t}, W_{xc}x_{t}, W_{xo}x_{t}$
operations on the input $x_{t}$ are NOT included in this operator.
D
dangqingqing 已提交
222
Users can choose to use fully-connect operator before LSTM operator.
D
dangqingqing 已提交
223 224 225 226 227 228 229 230 231

)DOC");
  }
};

class LSTMGradOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

232
  void InferShape(framework::InferShapeContext* ctx) const override {
233 234 235 236 237 238
    PADDLE_ENFORCE(ctx->HasInput("Input"),
                   "Input(Input) of LSTM should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Hidden"),
                   "Input(Hidden) of LSTM should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Cell"),
                   "Input(Cell) of LSTM should not be null.");
239 240 241 242
    PADDLE_ENFORCE(ctx->HasInput("Weight"),
                   "Input(Weight) of LSTM should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Bias"),
                   "Input(Bias) of LSTM should not be null.");
243 244 245 246 247 248

    PADDLE_ENFORCE(ctx->HasInput("BatchGate"),
                   "Input(BatchGate) of LSTM should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("BatchCellPreAct"),
                   "Input(BatchGate) of LSTM should not be null.");

D
dangqingqing 已提交
249 250 251 252 253 254 255 256 257 258 259
    auto SetOutGradDim = [&ctx](const std::string& name) {
      auto g_name = framework::GradVarName(name);
      if (ctx->HasOutput(g_name))
        ctx->SetOutputDim(g_name, ctx->GetInputDim(name));
    };

    SetOutGradDim("Input");
    SetOutGradDim("Weight");
    SetOutGradDim("Bias");
    SetOutGradDim("H0");
    SetOutGradDim("C0");
D
dangqingqing 已提交
260
  }
261 262

 protected:
263
  framework::OpKernelType GetExpectedKernelType(
264
      const framework::ExecutionContext& ctx) const override {
Y
Yu Yang 已提交
265 266 267
    return framework::OpKernelType(
        framework::ToDataType(ctx.Input<framework::LoDTensor>("Input")->type()),
        ctx.device_context());
268
  }
D
dangqingqing 已提交
269 270 271 272 273 274 275
};

}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;
REGISTER_OP(lstm, ops::LSTMOp, ops::LSTMOpMaker, lstm_grad, ops::LSTMGradOp);
Q
QI JUN 已提交
276 277 278 279 280 281
REGISTER_OP_CPU_KERNEL(
    lstm, ops::LSTMKernel<paddle::platform::CPUDeviceContext, float>,
    ops::LSTMKernel<paddle::platform::CPUDeviceContext, double>);
REGISTER_OP_CPU_KERNEL(
    lstm_grad, ops::LSTMGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::LSTMGradKernel<paddle::platform::CPUDeviceContext, double>);