reduce_op.h 12.8 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
G
guosheng 已提交
2

L
Luo Tao 已提交
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
G
guosheng 已提交
6

L
Luo Tao 已提交
7
    http://www.apache.org/licenses/LICENSE-2.0
G
guosheng 已提交
8

L
Luo Tao 已提交
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. */
G
guosheng 已提交
14 15 16

#pragma once

17 18
#include <algorithm>
#include <string>
W
whs 已提交
19
#include <vector>
20

W
Wu Yi 已提交
21
#include "paddle/fluid/operators/reduce_ops/reduce_op_function.h"
G
guosheng 已提交
22 23 24 25

namespace paddle {
namespace operators {

26 27 28 29 30
#define HANDLE_DIM(NDIM, RDIM)                                            \
  if (ndim == NDIM && rdim == RDIM) {                                     \
    ReduceFunctor<DeviceContext, T, NDIM, RDIM, Functor>(                 \
        context.template device_context<DeviceContext>(), *input, output, \
        dims, keep_dim);                                                  \
W
whs 已提交
31 32
  }

Q
QI JUN 已提交
33
template <typename DeviceContext, typename T, typename Functor>
Y
Yu Yang 已提交
34
class ReduceKernel : public framework::OpKernel<T> {
G
guosheng 已提交
35 36
 public:
  void Compute(const framework::ExecutionContext& context) const override {
37
    bool reduce_all = context.Attr<bool>("reduce_all");
38 39 40 41 42 43 44
    auto* input = context.Input<Tensor>("X");
    auto* output = context.Output<Tensor>("Out");
    output->mutable_data<T>(context.GetPlace());

    auto dims = context.Attr<std::vector<int>>("dim");
    bool keep_dim = context.Attr<bool>("keep_dim");

45 46 47 48 49 50 51 52
    if (reduce_all) {
      // Flatten and reduce 1-D tensor
      auto x = EigenVector<T>::Flatten(*input);
      auto out = EigenScalar<T>::From(*output);
      auto& place =
          *context.template device_context<DeviceContext>().eigen_device();
      auto reduce_dim = Eigen::array<int, 1>({{0}});
      Functor functor;
53
      functor(place, &x, &out, reduce_dim);
54
    } else {
55 56
      int ndim = input->dims().size();
      int rdim = dims.size();
57 58 59 60 61 62 63 64 65 66
      // comments for accelerating compiling temporarily.
      //      HANDLE_DIM(6, 5);
      //      HANDLE_DIM(6, 4);
      //      HANDLE_DIM(6, 3);
      //      HANDLE_DIM(6, 2);
      //      HANDLE_DIM(6, 1);
      //      HANDLE_DIM(5, 4);
      //      HANDLE_DIM(5, 3);
      //      HANDLE_DIM(5, 2);
      //      HANDLE_DIM(5, 1);
W
whs 已提交
67 68 69 70 71 72 73
      HANDLE_DIM(4, 3);
      HANDLE_DIM(4, 2);
      HANDLE_DIM(4, 1);
      HANDLE_DIM(3, 2);
      HANDLE_DIM(3, 1);
      HANDLE_DIM(2, 1);
      HANDLE_DIM(1, 1);
G
guosheng 已提交
74 75 76 77
    }
  }
};

78 79
template <typename DeviceContext, typename T, typename Functor,
          bool kNoNeedBufferX = false, bool kNoNeedBufferY = false>
Y
Yu Yang 已提交
80
class ReduceGradKernel : public framework::OpKernel<T> {
G
guosheng 已提交
81 82
 public:
  void Compute(const framework::ExecutionContext& context) const override {
83
    bool reduce_all = context.Attr<bool>("reduce_all");
84 85 86 87 88 89 90 91
    auto dims = context.Attr<std::vector<int>>("dim");

    auto* input0 = context.Input<Tensor>("X");
    auto* input1 = context.Input<Tensor>("Out");
    auto* input2 = context.Input<Tensor>(framework::GradVarName("Out"));
    auto* output = context.Output<Tensor>(framework::GradVarName("X"));
    output->mutable_data<T>(context.GetPlace());

92 93 94 95 96 97 98 99 100 101 102
    // NOTE: EigenTensor::From() uses tensor->data()
    // if op has NoNeedBufferVarsInferer, the corresponding kNoNeedBufferX or
    // kNoNeedBufferY should set true
    // and use fake var that has same dims.
    if (kNoNeedBufferX) {
      input0 = output;
    }
    if (kNoNeedBufferY) {
      input1 = input2;
    }

L
lvmengsi 已提交
103 104 105 106
    // NOTE(dengkaipeng): Out is unnecessary in some reduce kernel and
    // not be set as Input in grad Maker, use Out_grad to replace here
    if (!input1) input1 = input2;

107 108 109 110 111 112 113 114 115 116
    if (reduce_all) {
      auto x = EigenVector<T>::Flatten(*input0);
      auto x_reduce = EigenVector<T>::From(*input1);
      auto x_reduce_grad = EigenVector<T>::From(*input2);
      auto x_grad = EigenVector<T>::Flatten(*output);
      auto& place =
          *context.template device_context<DeviceContext>().eigen_device();
      auto broadcast_dim =
          Eigen::array<int, 1>({{static_cast<int>(input0->numel())}});
      Functor functor;
117
      functor(place, &x, &x_reduce, &x_grad, &x_reduce_grad, broadcast_dim,
118 119
              broadcast_dim[0]);
    } else {
120
      int rank = input0->dims().size();
121 122
      switch (rank) {
        case 1:
123 124 125
          ReduceGradFunctor<DeviceContext, T, 1, Functor>(
              context.template device_context<DeviceContext>(), *input0,
              *input1, *input2, output, dims);
126 127
          break;
        case 2:
128 129 130
          ReduceGradFunctor<DeviceContext, T, 2, Functor>(
              context.template device_context<DeviceContext>(), *input0,
              *input1, *input2, output, dims);
131 132
          break;
        case 3:
133 134 135
          ReduceGradFunctor<DeviceContext, T, 3, Functor>(
              context.template device_context<DeviceContext>(), *input0,
              *input1, *input2, output, dims);
136 137
          break;
        case 4:
138 139 140
          ReduceGradFunctor<DeviceContext, T, 4, Functor>(
              context.template device_context<DeviceContext>(), *input0,
              *input1, *input2, output, dims);
141 142
          break;
        case 5:
143 144 145
          ReduceGradFunctor<DeviceContext, T, 5, Functor>(
              context.template device_context<DeviceContext>(), *input0,
              *input1, *input2, output, dims);
146 147
          break;
        case 6:
148 149 150
          ReduceGradFunctor<DeviceContext, T, 6, Functor>(
              context.template device_context<DeviceContext>(), *input0,
              *input1, *input2, output, dims);
151 152
          break;
      }
G
guosheng 已提交
153 154
    }
  }
155
};
G
guosheng 已提交
156

157 158 159
class ReduceOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;
G
guosheng 已提交
160

161 162 163 164 165 166 167
  void InferShape(framework::InferShapeContext* ctx) const override {
    PADDLE_ENFORCE(ctx->HasInput("X"),
                   "Input(X) of ReduceOp should not be null.");
    PADDLE_ENFORCE(ctx->HasOutput("Out"),
                   "Output(Out) of ReduceOp should not be null.");
    auto x_dims = ctx->GetInputDim("X");
    auto x_rank = x_dims.size();
168 169 170 171 172
    PADDLE_ENFORCE_LE(x_rank, 6,
                      "ShapeError: The input tensor X's dimensions of Reduce "
                      "should be less equal than 6. But received X's "
                      "dimensions = %d, X's shape = [%s].",
                      x_rank, x_dims);
173
    auto dims = ctx->Attrs().Get<std::vector<int>>("dim");
174 175 176 177 178 179
    PADDLE_ENFORCE_GT(
        dims.size(), 0,
        "ShapeError: The input dim dimensions of Reduce "
        "shoud be greater than 0. But received the dim dimesions of Reduce "
        " = %d",
        dims.size());
180

181
    for (size_t i = 0; i < dims.size(); ++i) {
182 183 184 185 186
      PADDLE_ENFORCE_LT(dims[i], x_rank,
                        "ShapeError: The reduce dim index %d should be in the "
                        "range [-dimension(X), dimension(X)]."
                        "which dimesion = %d, But received dim index = %d",
                        i, x_rank, dims[i]);
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
      if (dims[i] < 0) dims[i] = x_rank + dims[i];
    }
    sort(dims.begin(), dims.end());
    bool reduce_all = ctx->Attrs().Get<bool>("reduce_all");
    bool keep_dim = ctx->Attrs().Get<bool>("keep_dim");
    if (reduce_all) {
      if (keep_dim)
        ctx->SetOutputDim(
            "Out", framework::make_ddim(std::vector<int64_t>(x_rank, 1)));
      else
        ctx->SetOutputDim("Out", {1});
    } else {
      auto dims_vector = vectorize(x_dims);
      if (keep_dim) {
        for (size_t i = 0; i < dims.size(); ++i) {
          dims_vector[dims[i]] = 1;
        }
      } else {
        const int kDelFlag = -2;
        for (size_t i = 0; i < dims.size(); ++i) {
          dims_vector[dims[i]] = kDelFlag;
        }
        dims_vector.erase(
            remove(dims_vector.begin(), dims_vector.end(), kDelFlag),
            dims_vector.end());
      }
213 214 215
      if (!keep_dim && dims_vector.size() == 0) {
        dims_vector.push_back(1);
      }
216 217
      auto out_dims = framework::make_ddim(dims_vector);
      ctx->SetOutputDim("Out", out_dims);
218
      if (dims.size() > 0 && dims[0] != 0) {
219 220 221 222 223 224 225
        // Only pass LoD when not reducing on the first dim.
        ctx->ShareLoD("X", /*->*/ "Out");
      }
    }
  }
};

G
Guo Sheng 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238
class ReduceOpUseInputPlace : public ReduceOp {
 public:
  using ReduceOp::ReduceOp;

 protected:
  framework::OpKernelType GetExpectedKernelType(
      const framework::ExecutionContext& ctx) const override {
    framework::OpKernelType kt = OperatorWithKernel::GetExpectedKernelType(ctx);
    kt.place_ = ctx.Input<framework::LoDTensor>("X")->place();
    return kt;
  }
};

239 240 241
class ReduceGradOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;
W
whs 已提交
242

243 244 245 246 247 248 249 250
  void InferShape(framework::InferShapeContext* ctx) const override {
    PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) should not be null.");
    PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")),
                   "Input(Out@GRAD) should not be null.");
    auto x_dims = ctx->GetInputDim("X");
    auto x_rank = x_dims.size();
    PADDLE_ENFORCE_LE(x_rank, 6, "Tensors with rank at most 6 are supported.");
    auto dims = ctx->Attrs().Get<std::vector<int>>("dim");
W
whs 已提交
251
    for (size_t i = 0; i < dims.size(); ++i) {
252 253 254 255 256
      PADDLE_ENFORCE_LT(dims[i], x_rank,
                        "ShapeError: The reduce dim index %d should be in the "
                        "range [-dimension(X), dimension(X)]."
                        "which dimesion = %d, But received dim index = %d",
                        i, x_rank, dims[i]);
W
whs 已提交
257
      if (dims[i] < 0) dims[i] = x_rank + dims[i];
258 259 260 261 262 263
    }
    sort(dims.begin(), dims.end());
    auto x_grad_name = framework::GradVarName("X");
    if (ctx->HasOutput(x_grad_name)) {
      ctx->SetOutputDim(x_grad_name, x_dims);
      ctx->ShareLoD("X", /*->*/ x_grad_name);
W
whs 已提交
264
    }
265
  }
266 267 268 269 270 271 272 273

 protected:
  framework::OpKernelType GetExpectedKernelType(
      const framework::ExecutionContext& ctx) const override {
    return framework::OpKernelType(
        ctx.Input<Tensor>(framework::GradVarName("Out"))->type(),
        ctx.GetPlace());
  }
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
};

class ReduceOpMaker : public framework::OpProtoAndCheckerMaker {
 public:
  void Make() final {
    AddInput("X",
             "(Tensor) The input tensor. Tensors with rank at most 6 are "
             "supported.");
    AddOutput("Out", "(Tensor) The result tensor.");
    AddAttr<std::vector<int>>(
        "dim",
        "(list<int>, default {0}) The dimensions to reduce. "
        "Must be in the range [-rank(input), rank(input)). "
        "If `dim[i] < 0`, the dims[i] to reduce is `rank + dims[i]`. "
        "Note that reducing on the first dim will make the LoD info lost.")
        .SetDefault({0});
    AddAttr<bool>("keep_dim",
                  "(bool, default false) "
                  "If true, retain the reduced dimension with length 1.")
        .SetDefault(false);
    AddAttr<bool>("reduce_all",
                  "(bool, default false) "
                  "If true, output a scalar reduced along all dimensions.")
        .SetDefault(false);
    AddComment(string::Sprintf(R"DOC(
%s Operator.
W
whs 已提交
300

301 302 303
This operator computes the %s of input tensor along the given dimension.
The result tensor has 1 fewer dimension than the input unless keep_dim is true.
If reduce_all is true, just reduce along all dimensions and output a scalar.
W
whs 已提交
304

305 306
)DOC",
                               GetOpType(), GetName()));
G
guosheng 已提交
307
  }
308 309 310 311

 protected:
  virtual std::string GetName() const = 0;
  virtual std::string GetOpType() const = 0;
G
guosheng 已提交
312 313 314 315
};

}  // namespace operators
}  // namespace paddle
316

317 318 319 320 321 322 323 324 325 326 327
namespace ops = paddle::operators;

#define REGISTER_REDUCE_OP(op_name)                                      \
  class __##op_name##Maker__ : public ops::ReduceOpMaker {               \
   protected:                                                            \
    virtual std::string GetName() const { return #op_name; }             \
    virtual std::string GetOpType() const { return "Reduce " #op_name; } \
  };                                                                     \
  REGISTER_OPERATOR(op_name, ops::ReduceOp, __##op_name##Maker__,        \
                    paddle::framework::DefaultGradOpDescMaker<true>);    \
  REGISTER_OPERATOR(op_name##_grad, ops::ReduceGradOp)
Z
zhoukunsheng 已提交
328

G
Guo Sheng 已提交
329 330 331 332 333 334 335
#define REGISTER_REDUCE_OP_WITHOUT_GRAD(op_name, ...)                          \
  class __##op_name##Maker__ : public ops::ReduceOpMaker {                     \
   protected:                                                                  \
    virtual std::string GetName() const { return #op_name; }                   \
    virtual std::string GetOpType() const { return "Reduce " #op_name; }       \
  };                                                                           \
  REGISTER_OPERATOR(op_name, ops::ReduceOp##__VA_ARGS__, __##op_name##Maker__, \
336
                    paddle::framework::EmptyGradOpMaker);