squared_l2_distance_op.cc 6.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/squared_l2_distance_op.h"
16

H
Huihuang Zheng 已提交
17 18 19 20
#include <memory>

#include "paddle/fluid/framework/no_need_buffer_vars_inference.h"

21 22 23 24 25 26 27
namespace paddle {
namespace operators {

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

28
  void InferShape(framework::InferShapeContext* ctx) const override {
Q
Qiao Longfei 已提交
29 30 31 32 33 34
    PADDLE_ENFORCE(ctx->HasInput("X"),
                   "Input(X) of SquaredL2DistanceOp should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Y"),
                   "Input(Y) of SquaredL2DistanceOp should not be null.");
    PADDLE_ENFORCE(
        ctx->HasOutput("sub_result"),
35
        "Output(sub_result) of SquaredL2DistanceOp should not be null.");
Q
Qiao Longfei 已提交
36 37
    PADDLE_ENFORCE(ctx->HasOutput("Out"),
                   "Output(Out) of SquaredL2DistanceOp should not be null.");
38

Q
Qiao Longfei 已提交
39 40
    auto x_dims = ctx->GetInputDim("X");
    auto y_dims = ctx->GetInputDim("Y");
41

42
    PADDLE_ENFORCE_EQ(framework::arity(x_dims), framework::arity(y_dims),
43 44
                      "Tensor rank of both SquaredL2DistanceOp's "
                      "inputs must be same.");
45 46

    int rank = framework::arity(x_dims);
Y
yangyaming 已提交
47
    PADDLE_ENFORCE_GE(rank, 2, "Tensor rank should be at least equal to 2.");
X
xuezhong 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
    bool check = true;
    if ((!ctx->IsRuntime()) &&
        (framework::product(x_dims) <= 0 || framework::product(y_dims) <= 0)) {
      check = false;
    }
    if (check) {
      PADDLE_ENFORCE_EQ(product(x_dims) / x_dims[0],
                        product(y_dims) / y_dims[0],
                        "Product of dimensions expcet the first dimension of "
                        "input and target must be equal.");
    }
    check = true;
    if ((!ctx->IsRuntime()) && (y_dims[0] <= 0 || x_dims[0] <= 0)) {
      check = false;
    }
    if (check) {
      PADDLE_ENFORCE(y_dims[0] == 1 || y_dims[0] == x_dims[0],
                     "First dimension of target must be equal to input "
                     "or to 1.");
    }
Q
Qiao Longfei 已提交
68 69 70
    ctx->SetOutputDim("sub_result", {x_dims[0], product(x_dims) / x_dims[0]});
    ctx->SetOutputDim("Out", {x_dims[0], 1});
    ctx->ShareLoD("X", /*->*/ "Out");
71 72 73
  }
};

H
Huihuang Zheng 已提交
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(SquaredL2DistanceGradOpNoBuffer, "X",
                                      "Y");

class SquaredL2DistanceGradOpDescMaker
    : public framework::SingleGradOpDescMaker {
 public:
  using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;

 protected:
  std::unique_ptr<framework::OpDesc> Apply() const override {
    std::unique_ptr<framework::OpDesc> op(new framework::OpDesc());

    op->SetType("squared_l2_distance_grad");

    op->SetInput(framework::GradVarName("Out"), OutputGrad("Out"));
    op->SetInput("sub_result", Output("sub_result"));
    op->SetInput("X", Input("X"));
    op->SetInput("Y", Input("Y"));

    op->SetOutput(framework::GradVarName("X"), InputGrad("X"));
    op->SetOutput(framework::GradVarName("Y"), InputGrad("Y"));

    op->SetAttrMap(Attrs());

    return op;
  }
};

102 103
class SquaredL2DistanceOpMaker : public framework::OpProtoAndCheckerMaker {
 public:
Y
Yu Yang 已提交
104
  void Make() override {
105 106
    AddInput("X", "(Tensor) Input of SquaredL2DistanceOp.");
    AddInput("Y", "(Tensor) Target of SquaredL2DistanceOp.");
107
    AddOutput("sub_result",
108
              "(Tensor) Buffering subtraction result which "
109 110
              "will be reused in backward.")
        .AsIntermediate();
111
    AddOutput("Out", "(Tensor) Squared l2 distance between input and target.");
112
    AddComment(R"DOC(
113 114 115 116 117 118 119 120 121 122 123 124
SquaredL2Distance operator

This operator will cacluate the squared L2 distance for the input and 
the target. Number of distance value will be equal to the first dimension 
of input. First dimension of the target could be equal to the input or to 1. 
If the first dimension of target is 1, the operator will broadcast target's 
first dimension to input's first dimension. During backward propagation, 
the user can decide whether to calculate the gradient of the input or 
the target or both.

Both the input X and Y can carry the LoD (Level of Details) information. 
However, the output only shares the LoD information with input X.
125 126 127 128 129 130 131 132
    )DOC");
  }
};

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

133
  void InferShape(framework::InferShapeContext* ctx) const override {
Q
Qiao Longfei 已提交
134 135
    PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")),
                   "Gradient of Out should not be null");
H
Huihuang Zheng 已提交
136
    PADDLE_ENFORCE(ctx->HasInput("sub_result"), "SubResult should not be null");
Q
Qiao Longfei 已提交
137 138 139
    auto out_dims = ctx->GetInputDim(framework::GradVarName("Out"));
    auto x_dims = ctx->GetInputDim("X");
    auto y_dims = ctx->GetInputDim("Y");
X
xuezhong 已提交
140 141 142 143 144 145
    PADDLE_INFERSHAPE_ENFORCE_EQ(ctx, out_dims[0], x_dims[0],
                                 "First dimension of output gradient and "
                                 "input value must be equal.");
    PADDLE_INFERSHAPE_ENFORCE_EQ(ctx, out_dims[1], 1,
                                 "Second dimension of output gradient "
                                 "must be 1.");
Q
Qiao Longfei 已提交
146 147 148 149
    auto x_grad_name = framework::GradVarName("X");
    auto y_grad_name = framework::GradVarName("Y");
    if (ctx->HasOutput(x_grad_name)) ctx->SetOutputDim(x_grad_name, x_dims);
    if (ctx->HasOutput(y_grad_name)) ctx->SetOutputDim(y_grad_name, y_dims);
150
  }
H
Huihuang Zheng 已提交
151 152 153 154

 protected:
  framework::OpKernelType GetExpectedKernelType(
      const framework::ExecutionContext& ctx) const override {
155 156 157
    return framework::OpKernelType(
        OperatorWithKernel::IndicateVarDataType(ctx, "sub_result"),
        ctx.GetPlace());
H
Huihuang Zheng 已提交
158
  }
159 160 161 162 163 164
};

}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;
Y
Yang Yang 已提交
165 166
REGISTER_OPERATOR(squared_l2_distance, ops::SquaredL2DistanceOp,
                  ops::SquaredL2DistanceOpMaker,
H
Huihuang Zheng 已提交
167 168 169
                  ops::SquaredL2DistanceGradOpDescMaker);
REGISTER_OPERATOR(squared_l2_distance_grad, ops::SquaredL2DistanceGradOp,
                  ops::SquaredL2DistanceGradOpNoBuffer);
170 171
REGISTER_OP_CPU_KERNEL(
    squared_l2_distance,
Q
QI JUN 已提交
172 173 174 175
    ops::SquaredL2DistanceKernel<paddle::platform::CPUDeviceContext, float>);
REGISTER_OP_CPU_KERNEL(squared_l2_distance_grad,
                       ops::SquaredL2DistanceGradKernel<
                           paddle::platform::CPUDeviceContext, float>);