sequence_pool_op.cc 5.8 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14

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. */

Y
Yi Wang 已提交
15
#include "paddle/fluid/operators/sequence_pool_op.h"
16
#include <string>
17 18 19 20

namespace paddle {
namespace operators {

21
class SequencePoolOp : public framework::OperatorWithKernel {
22 23 24
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

25
  void InferShape(framework::InferShapeContext* ctx) const override {
26
    PADDLE_ENFORCE(ctx->HasInput("X"),
27
                   "Input(X) of SequencePoolOp should not be null.");
28
    PADDLE_ENFORCE(ctx->HasOutput("Out"),
29
                   "Output(Out) of SequencePoolOp should not be null.");
30
    ctx->SetOutputDim("Out", ctx->GetInputDim("X"));
31 32 33 34 35
    if (ctx->Attrs().Get<std::string>("pooltype") == "MAX") {
      PADDLE_ENFORCE(ctx->HasOutput("MaxIndex"),
                     "Output(MaxIndex) of SequencePoolOp should not be null.");
      ctx->SetOutputDim("MaxIndex", ctx->GetInputDim("X"));
    }
36 37 38
  }
};

39
class SequencePoolOpMaker : public framework::OpProtoAndCheckerMaker {
40
 public:
Y
Yu Yang 已提交
41
  void Make() override {
42
    AddInput("X", "(LoDTensor) The variable-length input of SequencePoolOp");
43
    AddOutput("Out",
44
              "(Tensor) The output of SequencePoolOp does not contain LoD "
45
              "infomation.");
46
    AddOutput("MaxIndex",
D
dangqingqing 已提交
47 48
              "(Tensor<int>) This tensor is used for the sequence max-pooling "
              "to record the max indexes.")
49
        .AsIntermediate();
50
    AddAttr<bool>("is_test", "").SetDefault(false);
D
dzhwinter 已提交
51 52
    AddAttr<std::string>(
        "pooltype",
53
        "(string, default 'AVERAGE') the pooling pooltype of SequencePoolOp.")
54 55
        .SetDefault("AVERAGE")
        .InEnum({"AVERAGE", "SUM", "SQRT", "LAST", "FIRST", "MAX"});
56
    AddComment(R"DOC(
57
Sequence Pool Operator.
58

59 60
The SequencePoolOp pools features of all time-steps of each instance.
It supports six pooling types:
61 62 63
1. AVERAGE: $$Out[i] = \frac{\sum_i X_i}{N}$$
2. SUM:     $$Out[i] = \sum_jX_{ij}$$
3. SQRT:    $$Out[i] = \frac{\sum_jX_{ij}}{\sqrt{len(X_i)}}$$
64 65
4. LAST:    Out[i] = last instance in i-th sequence X[i]
5. FIRST:   Out[i] = first instance in i-th sequence X[i]
66
6. MAX:     $$Out[i] = max(X_i)$$
67

68 69 70
The following example explains how this works:
For a mini-batch of 3 variable-length sentences,
containing 2, 3, and 2 time-steps:
71

72 73 74
Assume X is a [7,M,N] LoDTensor, and X->lod()[0] = [0, 2, 5, 7], 7=2+3+2.
Besides, for the sake of simplicity, we assume M=1 and N=1,
and the value of X = [[1, 3], [2, 4, 6], [5, 1]].
75

76 77
Thus, Out is a [3,1,1] Tensor without LoD infomation.
And for different pooltype, the value of Out is as follows:
78

79 80 81
- AVERAGE: [2, 4, 3], where 2=(1+3)/2, 4=(2+4+6)/3, 3=(5+1)/2
- SUM: [4, 12, 6], where 4=1+3, 12=2+4+6, 6=5+1
- SQRT: [2.82, 6.93, 4.24], where 2.82=(1+3)/sqrt(2),
82
           6.93=(2+4+6)/sqrt(3), 4.24=(5+1)/sqrt(2)
83 84 85 86
- MAX: [3, 6, 5], where 3=max(1,3), 6=max(2,4,6), 5=max(5,1)
- LAST: [3, 6, 1], where 3=last(1,3), 6=last(2,4,6), 1=last(5,1)
- FIRST: [1, 2, 5], where 1=first(1,3), 2=first(2,4,6), 5=first(5,1)

87 88 89 90
    )DOC");
  }
};

91
class SequencePoolGradOp : public framework::OperatorWithKernel {
92 93 94
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

95
  void InferShape(framework::InferShapeContext* ctx) const override {
96 97 98 99 100
    PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")),
                   "Gradient of Out should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("X"), "The input X should not be null.");
    auto og_dims = ctx->GetInputDim(framework::GradVarName("Out"));
    auto x_dims = ctx->GetInputDim("X");
101 102
    PADDLE_ENFORCE_EQ(og_dims.size(), x_dims.size(),
                      "The rank of output grad must equal to Input(X).");
103
    for (int64_t i = 1; i < og_dims.size(); ++i) {
104 105
      PADDLE_ENFORCE_EQ(og_dims[i], x_dims[i], "The dimension mismatch.");
    }
106 107 108

    ctx->ShareDim("X", /*->*/ framework::GradVarName("X"));
    ctx->ShareLoD("X", /*->*/ framework::GradVarName("X"));
109
  }
110 111

 protected:
112
  framework::OpKernelType GetExpectedKernelType(
113
      const framework::ExecutionContext& ctx) const override {
Y
Yu Yang 已提交
114 115 116
    return framework::OpKernelType(
        framework::ToDataType(ctx.Input<Tensor>("X")->type()),
        ctx.device_context());
117
  }
118 119
};

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
class SequencePoolGradOpMaker : public framework::SingleGradOpDescMaker {
 public:
  using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;

 protected:
  std::unique_ptr<framework::OpDesc> Apply() const override {
    auto* op_desc_ptr = new framework::OpDesc();
    op_desc_ptr->SetType("sequence_pool_grad");
    op_desc_ptr->SetInput("X", Input("X"));
    if (boost::get<std::string>(GetAttr("pooltype")) == "MAX") {
      op_desc_ptr->SetInput("MaxIndex", Output("MaxIndex"));
    }
    op_desc_ptr->SetInput(framework::GradVarName("Out"), OutputGrad("Out"));
    op_desc_ptr->SetOutput(framework::GradVarName("X"), InputGrad("X"));
    op_desc_ptr->SetAttrMap(Attrs());
    return std::unique_ptr<framework::OpDesc>(op_desc_ptr);
  }
};

139 140 141 142
}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;
143 144 145
REGISTER_OPERATOR(sequence_pool, ops::SequencePoolOp, ops::SequencePoolOpMaker,
                  ops::SequencePoolGradOpMaker);
REGISTER_OPERATOR(sequence_pool_grad, ops::SequencePoolGradOp);
146
REGISTER_OP_CPU_KERNEL(
Q
QI JUN 已提交
147 148
    sequence_pool,
    ops::SequencePoolKernel<paddle::platform::CPUDeviceContext, float>);
149
REGISTER_OP_CPU_KERNEL(
150
    sequence_pool_grad,
Q
QI JUN 已提交
151
    ops::SequencePoolGradKernel<paddle::platform::CPUDeviceContext, float>);
新手
引导
客服 返回
顶部