wangmeng28
7 years ago
commit
e5135e8b4f
@ -0,0 +1,138 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/framework/data_type.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/framework/var_type.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
class AssignFunctor {
|
||||
public:
|
||||
AssignFunctor(framework::Variable *out,
|
||||
const platform::DeviceContext &dev_ctx)
|
||||
: out_(out), dev_ctx_(dev_ctx) {}
|
||||
|
||||
void operator()(const framework::LoDTensor &lod_tensor) const {
|
||||
auto &out_tensor = *out_->GetMutable<framework::LoDTensor>();
|
||||
copy_tensor(lod_tensor, &out_tensor);
|
||||
}
|
||||
|
||||
void operator()(const framework::LoDTensorArray &array) const {
|
||||
auto &out_array = *out_->GetMutable<framework::LoDTensorArray>();
|
||||
out_array.resize(array.size());
|
||||
for (size_t i = 0; i < array.size(); ++i) {
|
||||
copy_tensor(array[i], &out_array[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void operator()(const framework::SelectedRows &rows) const {
|
||||
framework::SelectedRows &out_rows =
|
||||
*out_->GetMutable<framework::SelectedRows>();
|
||||
out_rows.set_rows(rows.rows());
|
||||
out_rows.set_height(rows.height());
|
||||
auto &t = rows.value();
|
||||
out_rows.mutable_value()->CopyFrom(t, t.place(), dev_ctx_);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void operator()(const T &v) const {
|
||||
PADDLE_THROW("Not support type for assign op %s", typeid(T).name());
|
||||
}
|
||||
|
||||
private:
|
||||
void copy_tensor(const framework::LoDTensor &lod_tensor,
|
||||
framework::LoDTensor *out) const {
|
||||
auto &out_tensor = *out;
|
||||
out_tensor.CopyFrom(lod_tensor, lod_tensor.place(), dev_ctx_);
|
||||
out_tensor.set_lod(lod_tensor.lod());
|
||||
}
|
||||
|
||||
framework::Variable *out_;
|
||||
const platform::DeviceContext &dev_ctx_;
|
||||
};
|
||||
|
||||
class AssignOp : public framework::OperatorBase {
|
||||
public:
|
||||
AssignOp(const std::string &type, const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: OperatorBase(type, inputs, outputs, attrs) {}
|
||||
void Run(const framework::Scope &scope,
|
||||
const platform::DeviceContext &dev_ctx) const override {
|
||||
auto *x = scope.FindVar(Input("X"));
|
||||
if (x == nullptr) {
|
||||
return;
|
||||
}
|
||||
auto *out = scope.FindVar(Output("Out"));
|
||||
PADDLE_ENFORCE(
|
||||
out != nullptr,
|
||||
"The Output(Out) should not be null if the Input(X) is set.");
|
||||
framework::VisitVarType(*x, AssignFunctor(out, dev_ctx));
|
||||
}
|
||||
};
|
||||
|
||||
class AssignOpProtoMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
AssignOpProtoMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X",
|
||||
"(LoDTensor, SelectedRows or LoDTensorArray) The input variable "
|
||||
"could be LoDTensor, SelectedRows or LoDTensorArray.")
|
||||
.AsDispensable();
|
||||
AddOutput("Out",
|
||||
"(LoDTensor, SelectedRows or LoDTensorArray) The type of output "
|
||||
"is the same as input X.");
|
||||
AddComment(R"DOC(Assign Operator
|
||||
|
||||
Out = X, when type in [LoDTensor/SelectedRows/LoDTensorArray]
|
||||
raise error if the type is not listed above.
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class AssignInferShape : public framework::InferShapeBase {
|
||||
public:
|
||||
void operator()(framework::InferShapeContext *context) const override {
|
||||
if (context->HasInput("X")) {
|
||||
auto type = context->GetInputsVarType("X")[0];
|
||||
if (type == framework::VarDesc_VarType_SELECTED_ROWS ||
|
||||
type == framework::VarDesc_VarType_LOD_TENSOR) {
|
||||
context->SetOutputDim("Out", context->GetInputDim("X"));
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class AssignGradMaker : public framework::SingleGradOpDescMaker {
|
||||
public:
|
||||
using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;
|
||||
|
||||
protected:
|
||||
std::unique_ptr<framework::OpDescBind> Apply() const override {
|
||||
auto *op = new framework::OpDescBind();
|
||||
op->SetType("assign");
|
||||
op->SetInput("X", OutputGrad("Out"));
|
||||
op->SetOutput("Out", InputGrad("X"));
|
||||
return std::unique_ptr<framework::OpDescBind>(op);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OPERATOR(assign, ops::AssignOp, ops::AssignGradMaker,
|
||||
ops::AssignInferShape, ops::AssignOpProtoMaker);
|
||||
@ -0,0 +1,159 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/operators/bilinear_tensor_product_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using framework::Tensor;
|
||||
|
||||
class BilinearTensorProductOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(framework::InferShapeContext* ctx) const override {
|
||||
PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput("Y"), "Input(Y) should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput("Weight"),
|
||||
"Input(Weight) should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasOutput("Out"), "Output(Out) should not be null.");
|
||||
auto x_dims = ctx->GetInputDim("X");
|
||||
auto y_dims = ctx->GetInputDim("Y");
|
||||
auto weight_dims = ctx->GetInputDim("Weight");
|
||||
|
||||
PADDLE_ENFORCE_EQ(x_dims.size(), 2UL, "The input(X) must be a 2D Tensor.");
|
||||
PADDLE_ENFORCE_EQ(y_dims.size(), 2UL, "The input(Y) must be a 2D Tensor.");
|
||||
PADDLE_ENFORCE_EQ(weight_dims.size(), 3UL,
|
||||
"The input(Weight) must be a 3D tensor.");
|
||||
PADDLE_ENFORCE_EQ(x_dims[0], y_dims[0],
|
||||
"The first dimension(batch_size) of input(X) must be "
|
||||
"equal to the first dimension of the input(Y).");
|
||||
PADDLE_ENFORCE_EQ(x_dims[1], weight_dims[1],
|
||||
"The second dimension of input(X) must be equal to "
|
||||
"the second dimension of the input(Weight).");
|
||||
PADDLE_ENFORCE_EQ(y_dims[1], weight_dims[2],
|
||||
"The second dimension of input(Y) must be equal to "
|
||||
"the third dimension of the input(Weight).");
|
||||
|
||||
if (ctx->HasInput("Bias")) {
|
||||
auto bias_dims = ctx->GetInputDim("Bias");
|
||||
PADDLE_ENFORCE(bias_dims.size() == 2UL && bias_dims[0] == 1UL,
|
||||
"The Input(Bias) must be a 2-D tensor with "
|
||||
"the 2nd dimension fixed to 1 (a row vector).");
|
||||
PADDLE_ENFORCE_EQ(bias_dims[1], weight_dims[0],
|
||||
"The second dimension of input(Bias) must be equal "
|
||||
"to the first dimension of the input(Weight).");
|
||||
}
|
||||
|
||||
ctx->SetOutputDim("Out", {x_dims[0], weight_dims[0]});
|
||||
ctx->ShareLoD("X", /*->*/ "Out");
|
||||
}
|
||||
};
|
||||
|
||||
class BilinearTensorProductOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
BilinearTensorProductOpMaker(framework::OpProto* proto,
|
||||
framework::OpAttrChecker* op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X", "The first input of bilinear_tensor_product operator.");
|
||||
AddInput("Y", "The second input of bilinear_tensor_product operator.");
|
||||
AddInput("Weight",
|
||||
"The learnable parameters of bilinear_tensor_product operator.");
|
||||
AddInput("Bias", "The learnable bias of bilinear_tensor_product operator.")
|
||||
.AsDispensable();
|
||||
AddOutput("Out", "The output of bilinear_tensor_product operator.");
|
||||
AddComment(R"DOC(
|
||||
Bilinear Tensor Product operator.
|
||||
Given input X and Y, a 3D tensor weight, and bias. Each column of the
|
||||
output is computed by one slice i = 1, . . . , k of the tensor:
|
||||
|
||||
M = (X W_i) \cdot Y
|
||||
Out_i = \sum_i {M_i} + Bias_i
|
||||
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class BilinearTensorProductOpGrad : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(framework::InferShapeContext* ctx) const override {
|
||||
PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput("Y"), "Input(Y) should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput("Weight"),
|
||||
"Input(Weight) 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 y_dims = ctx->GetInputDim("Y");
|
||||
auto weight_dims = ctx->GetInputDim("Weight");
|
||||
auto out_dims = ctx->GetInputDim(framework::GradVarName("Out"));
|
||||
|
||||
PADDLE_ENFORCE_EQ(out_dims.size(), 2UL,
|
||||
"The input(Out@GRAD) must be a 2D Tensor.");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
x_dims[0], out_dims[0],
|
||||
"The first dimension(batch_size) of input(Out@GRAD) must be "
|
||||
"equal to the first dimension of the Input(X).");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
weight_dims[0], out_dims[1],
|
||||
"The second dimension of input(Out@GRAD) must be equal to "
|
||||
"the third dimension of the Input(Weight).");
|
||||
|
||||
if (ctx->HasInput("Bias")) {
|
||||
auto bias_dims = ctx->GetInputDim("Bias");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
bias_dims[1], out_dims[1],
|
||||
"The second dimension of input(Out@GRAD) must be equal to "
|
||||
"the second dimension of the Input(Bias).");
|
||||
auto bias_grad_name = framework::GradVarName("Bias");
|
||||
if (ctx->HasOutput(bias_grad_name))
|
||||
ctx->SetOutputDim(bias_grad_name, bias_dims);
|
||||
}
|
||||
|
||||
auto x_grad_name = framework::GradVarName("X");
|
||||
auto y_grad_name = framework::GradVarName("Y");
|
||||
auto weight_grad_name = framework::GradVarName("Weight");
|
||||
|
||||
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);
|
||||
}
|
||||
if (ctx->HasOutput(weight_grad_name)) {
|
||||
ctx->SetOutputDim(weight_grad_name, weight_dims);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(bilinear_tensor_product, ops::BilinearTensorProductOp,
|
||||
ops::BilinearTensorProductOpMaker, bilinear_tensor_product_grad,
|
||||
ops::BilinearTensorProductOpGrad);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
bilinear_tensor_product,
|
||||
ops::BilinearTensorProductKernel<paddle::platform::CPUPlace, float>,
|
||||
ops::BilinearTensorProductKernel<paddle::platform::CPUPlace, double>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
bilinear_tensor_product_grad,
|
||||
ops::BilinearTensorProductGradKernel<paddle::platform::CPUPlace, float>,
|
||||
ops::BilinearTensorProductGradKernel<paddle::platform::CPUPlace, double>);
|
||||
@ -0,0 +1,26 @@
|
||||
/* 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. */
|
||||
|
||||
#define EIGEN_USE_GPU
|
||||
#include "paddle/operators/bilinear_tensor_product_op.h"
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
bilinear_tensor_product,
|
||||
ops::BilinearTensorProductKernel<paddle::platform::GPUPlace, float>,
|
||||
ops::BilinearTensorProductKernel<paddle::platform::GPUPlace, double>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
bilinear_tensor_product_grad,
|
||||
ops::BilinearTensorProductGradKernel<paddle::platform::GPUPlace, float>,
|
||||
ops::BilinearTensorProductGradKernel<paddle::platform::GPUPlace, double>);
|
||||
@ -0,0 +1,184 @@
|
||||
/* 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "paddle/framework/eigen.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/operators/math/math_function.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using framework::Tensor;
|
||||
|
||||
template <typename T, int MajorType = Eigen::RowMajor,
|
||||
typename IndexType = Eigen::DenseIndex>
|
||||
using EigenMatrix = framework::EigenMatrix<T, MajorType, IndexType>;
|
||||
|
||||
template <typename Place, typename T>
|
||||
class BilinearTensorProductKernel : public framework::OpKernel<T> {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& ctx) const override {
|
||||
auto* x = ctx.Input<Tensor>("X");
|
||||
auto* y = ctx.Input<Tensor>("Y");
|
||||
auto* weight = ctx.Input<Tensor>("Weight");
|
||||
auto* bias = ctx.Input<Tensor>("Bias");
|
||||
auto* out = ctx.Output<Tensor>("Out");
|
||||
out->mutable_data<T>(ctx.GetPlace());
|
||||
|
||||
auto y_mat = EigenMatrix<T>::From(*y);
|
||||
auto output_mat = EigenMatrix<T>::From(*out);
|
||||
|
||||
auto batch_size = x->dims()[0];
|
||||
auto weight_dims = weight->dims();
|
||||
int out_dim = weight_dims[0];
|
||||
auto x_dim = weight_dims[1];
|
||||
auto y_dim = weight_dims[2];
|
||||
auto place = ctx.GetEigenDevice<Place>();
|
||||
|
||||
// Create the intermediate variable to caculate the result of
|
||||
// Input(X) multiplied by Input(Weight_i), the formula is:
|
||||
// left_mul = X Weight_i.
|
||||
Tensor left_mul;
|
||||
left_mul.mutable_data<T>(framework::make_ddim({batch_size, y_dim}),
|
||||
ctx.GetPlace());
|
||||
auto left_mul_mat = EigenMatrix<T>::From(left_mul);
|
||||
|
||||
for (int i = 0; i < out_dim; ++i) {
|
||||
auto output_col_vec = output_mat.chip(i, 1);
|
||||
Tensor weight_mat =
|
||||
weight->Slice(i, i + 1).Resize(framework::make_ddim({x_dim, y_dim}));
|
||||
math::gemm<Place, T>(ctx.device_context(), CblasNoTrans, CblasNoTrans,
|
||||
batch_size, y_dim, x_dim, 1, x->data<T>(),
|
||||
weight_mat.data<T>(), 0, left_mul.data<T>());
|
||||
output_col_vec.device(place) =
|
||||
(left_mul_mat * y_mat).sum(Eigen::DSizes<int, 1>(1));
|
||||
}
|
||||
if (bias) {
|
||||
auto bias_vec = EigenMatrix<T>::From(*bias);
|
||||
Eigen::DSizes<int, 2> bcast(batch_size, 1);
|
||||
output_mat.device(place) = bias_vec.broadcast(bcast) + output_mat;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Place, typename T>
|
||||
class BilinearTensorProductGradKernel : public framework::OpKernel<T> {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& ctx) const override {
|
||||
const Tensor* x = ctx.Input<Tensor>("X");
|
||||
const Tensor* y = ctx.Input<Tensor>("Y");
|
||||
const Tensor* weight = ctx.Input<Tensor>("Weight");
|
||||
Tensor* d_x = ctx.Output<Tensor>(framework::GradVarName("X"));
|
||||
Tensor* d_y = ctx.Output<Tensor>(framework::GradVarName("Y"));
|
||||
Tensor* d_weight = ctx.Output<Tensor>(framework::GradVarName("Weight"));
|
||||
Tensor* d_bias = ctx.Output<Tensor>(framework::GradVarName("Bias"));
|
||||
const Tensor* d_out = ctx.Input<Tensor>(framework::GradVarName("Out"));
|
||||
|
||||
auto batch_size = x->dims()[0];
|
||||
auto weight_dims = weight->dims();
|
||||
int out_dim = weight_dims[0];
|
||||
auto x_dim = weight_dims[1];
|
||||
auto y_dim = weight_dims[2];
|
||||
|
||||
auto x_mat = EigenMatrix<T>::From(*x);
|
||||
auto y_mat = EigenMatrix<T>::From(*y);
|
||||
auto d_out_mat = EigenMatrix<T>::From(*d_out);
|
||||
auto place = ctx.GetEigenDevice<Place>();
|
||||
|
||||
// Create the intermediate variable to caculate the Output(Y@Grad).
|
||||
Tensor x_scale;
|
||||
x_scale.mutable_data<T>(framework::make_ddim({batch_size, x_dim}),
|
||||
ctx.GetPlace());
|
||||
auto x_scale_mat = EigenMatrix<T>::From(x_scale);
|
||||
|
||||
// Create the intermediate variable to caculate the Output(X@Grad).
|
||||
Tensor y_scale;
|
||||
y_scale.mutable_data<T>(framework::make_ddim({batch_size, y_dim}),
|
||||
ctx.GetPlace());
|
||||
auto y_scale_mat = EigenMatrix<T>::From(y_scale);
|
||||
|
||||
math::SetConstant<Place, T> set_zero;
|
||||
|
||||
// Set Output(X@Grad) be zero.
|
||||
if (d_x) {
|
||||
d_x->mutable_data<T>(ctx.GetPlace());
|
||||
set_zero(ctx.device_context(), d_x, static_cast<T>(0));
|
||||
}
|
||||
|
||||
// Set Output(Y@Grad) be zero.
|
||||
if (d_y) {
|
||||
d_y->mutable_data<T>(ctx.GetPlace());
|
||||
set_zero(ctx.device_context(), d_y, static_cast<T>(0));
|
||||
}
|
||||
|
||||
// Caculate the Output(X@Grad) and Output(Y@Grad).
|
||||
if (d_x || d_y) {
|
||||
Eigen::DSizes<int, 2> bcast_for_x(1, y_dim);
|
||||
Eigen::DSizes<int, 2> bcast_for_y(1, x_dim);
|
||||
for (int i = 0; i < out_dim; ++i) {
|
||||
Tensor weight_i = weight->Slice(i, i + 1).Resize(
|
||||
framework::make_ddim({x_dim, y_dim}));
|
||||
auto output_vec = d_out_mat.chip(i, 1);
|
||||
if (d_x) {
|
||||
y_scale_mat.device(place) =
|
||||
output_vec.reshape(Eigen::DSizes<int, 2>(batch_size, 1))
|
||||
.broadcast(bcast_for_x) *
|
||||
y_mat;
|
||||
math::gemm<Place, T>(ctx.device_context(), CblasNoTrans, CblasTrans,
|
||||
batch_size, x_dim, y_dim, 1, y_scale.data<T>(),
|
||||
weight_i.data<T>(), 1, d_x->data<T>());
|
||||
}
|
||||
if (d_y) {
|
||||
x_scale_mat.device(place) =
|
||||
output_vec.reshape(Eigen::DSizes<int, 2>(batch_size, 1))
|
||||
.broadcast(bcast_for_y) *
|
||||
x_mat;
|
||||
math::gemm<Place, T>(ctx.device_context(), CblasNoTrans, CblasNoTrans,
|
||||
batch_size, y_dim, x_dim, 1, x_scale.data<T>(),
|
||||
weight_i.data<T>(), 1, d_y->data<T>());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Caculate the gradient of Input(Weight).
|
||||
if (d_weight) {
|
||||
d_weight->mutable_data<T>(ctx.GetPlace());
|
||||
Eigen::DSizes<int, 2> bcast_for_weight(1, x_dim);
|
||||
for (int i = 0; i < out_dim; ++i) {
|
||||
Tensor d_weight_i = d_weight->Slice(i, i + 1).Resize(
|
||||
framework::make_ddim({x_dim, y_dim}));
|
||||
auto output_vec = d_out_mat.chip(i, 1);
|
||||
x_scale_mat.device(place) =
|
||||
output_vec.reshape(Eigen::DSizes<int, 2>(batch_size, 1))
|
||||
.broadcast(bcast_for_weight) *
|
||||
x_mat;
|
||||
math::gemm<Place, T>(ctx.device_context(), CblasTrans, CblasNoTrans,
|
||||
x_dim, y_dim, batch_size, 1, x_scale.data<T>(),
|
||||
y->data<T>(), 0, d_weight_i.data<T>());
|
||||
}
|
||||
}
|
||||
|
||||
// Caculate the gradient of Input(Bias).
|
||||
if (d_bias) {
|
||||
d_bias->mutable_data<T>(ctx.GetPlace());
|
||||
auto d_bias_mat = EigenMatrix<T>::From(*d_bias);
|
||||
d_bias_mat.device(place) = d_out_mat.sum(Eigen::DSizes<int, 1>(0));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,197 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
|
||||
|
||||
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. */
|
||||
#include <algorithm>
|
||||
#include "paddle/framework/executor.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class ConditionalOp : public framework::OperatorBase {
|
||||
public:
|
||||
ConditionalOp(const std::string &type,
|
||||
const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: OperatorBase(type, inputs, outputs, attrs) {}
|
||||
|
||||
protected:
|
||||
std::vector<const framework::LoDTensor *> InputTensors(
|
||||
const framework::Scope &scope) const {
|
||||
std::vector<const framework::LoDTensor *> retv;
|
||||
auto xs = Inputs("X");
|
||||
retv.resize(xs.size(), nullptr);
|
||||
std::transform(
|
||||
xs.begin(), xs.end(), retv.begin(),
|
||||
[&scope](const std::string &var_name) -> const framework::LoDTensor * {
|
||||
auto *var = scope.FindVar(var_name);
|
||||
PADDLE_ENFORCE(var != nullptr, "Cannot find variable %s", var_name);
|
||||
return &var->Get<framework::LoDTensor>();
|
||||
});
|
||||
return retv;
|
||||
}
|
||||
};
|
||||
|
||||
class ConditionalBlockOp : public ConditionalOp {
|
||||
public:
|
||||
ConditionalBlockOp(const std::string &type,
|
||||
const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: ConditionalOp(type, inputs, outputs, attrs) {}
|
||||
void Run(const framework::Scope &scope,
|
||||
const platform::DeviceContext &dev_ctx) const override {
|
||||
auto xs = InputTensors(scope);
|
||||
bool need_run = std::all_of(
|
||||
xs.begin(), xs.end(),
|
||||
[](const framework::LoDTensor *t) { return t->numel() != 0; });
|
||||
|
||||
if (need_run) {
|
||||
auto *scope_var = scope.FindVar(Output("Scope"));
|
||||
PADDLE_ENFORCE(scope_var != nullptr, "Must set scope");
|
||||
auto *scopes = scope_var->GetMutable<std::vector<framework::Scope *>>();
|
||||
scopes->resize(1);
|
||||
scopes->front() = &scope.NewScope();
|
||||
auto &cur_scope = *scopes->front();
|
||||
|
||||
auto *block = Attr<framework::BlockDescBind *>("block");
|
||||
framework::Executor exec(dev_ctx);
|
||||
exec.Run(*block->Program(), &cur_scope, block->ID(), false);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class ConditionalBlockOpProtoMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
ConditionalBlockOpProtoMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X",
|
||||
"The conditional variable of this operator. If X is empty, the "
|
||||
"whole sub-block will not be executed.")
|
||||
.AsDuplicable();
|
||||
AddInput("Params", "The input variables of the sub-block.").AsDuplicable();
|
||||
AddOutput("Out", "The output variables of the sub-block.").AsDuplicable();
|
||||
AddOutput("Scope",
|
||||
"(std::vector<Scope*>) The step scope of conditional block. To "
|
||||
"unify the conditional block, rnn and while op, the type of "
|
||||
"scope is std::vector<Scope*>");
|
||||
AddAttr<framework::BlockDescBind *>(
|
||||
"block", "The step block of conditional block operator");
|
||||
AddComment(R"DOC(Conditional block operator
|
||||
|
||||
Run the sub-block if X is not empty. Params is the other inputs and Out is the
|
||||
outputs of the sub-block.
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class ConditionalBlockGradOp : public ConditionalOp {
|
||||
public:
|
||||
ConditionalBlockGradOp(const std::string &type,
|
||||
const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: ConditionalOp(type, inputs, outputs, attrs) {}
|
||||
void Run(const framework::Scope &scope,
|
||||
const platform::DeviceContext &dev_ctx) const override {
|
||||
auto xs = this->InputTensors(scope);
|
||||
bool need_run = std::all_of(
|
||||
xs.begin(), xs.end(),
|
||||
[](const framework::LoDTensor *t) { return t->numel() != 0; });
|
||||
|
||||
if (need_run) {
|
||||
auto *scope_var = scope.FindVar(Input("Scope"));
|
||||
PADDLE_ENFORCE(scope_var != nullptr, "Must set scope");
|
||||
auto &scopes = scope_var->Get<std::vector<framework::Scope *>>();
|
||||
framework::Scope &cur_scope = *scopes[0];
|
||||
|
||||
auto *block = Attr<framework::BlockDescBind *>("block");
|
||||
framework::Executor exec(dev_ctx);
|
||||
exec.Run(*block->Program(), &cur_scope, block->ID(), false);
|
||||
|
||||
AssignLocalGradientToGlobal(dev_ctx, cur_scope, Inputs("Params"),
|
||||
Outputs(framework::GradVarName("Params")));
|
||||
|
||||
AssignLocalGradientToGlobal(dev_ctx, cur_scope, Inputs("X"),
|
||||
Outputs(framework::GradVarName("X")));
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void AssignLocalGradientToGlobal(
|
||||
const platform::DeviceContext &dev_ctx, const framework::Scope &cur_scope,
|
||||
const std::vector<std::string> &p_names,
|
||||
const std::vector<std::string> &pg_names) const {
|
||||
for (size_t i = 0; i < p_names.size(); ++i) {
|
||||
auto out_grad_name = pg_names[i];
|
||||
auto in_grad_name = framework::GradVarName(p_names[i]);
|
||||
auto *in_var = cur_scope.FindVar(in_grad_name);
|
||||
if (in_var == nullptr) {
|
||||
continue;
|
||||
}
|
||||
auto new_in_grad_name = cur_scope.Rename(in_grad_name);
|
||||
auto assign =
|
||||
framework::OpRegistry::CreateOp("assign", {{"X", {new_in_grad_name}}},
|
||||
{{"Out", {out_grad_name}}}, {});
|
||||
assign->Run(cur_scope, dev_ctx);
|
||||
cur_scope.Rename(new_in_grad_name, in_grad_name);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class ConditionalBlockGradInferShape : public framework::InferShapeBase {
|
||||
public:
|
||||
void operator()(framework::InferShapeContext *context) const override {
|
||||
PADDLE_ENFORCE(context->HasInputs("X"));
|
||||
if (context->HasInputs("Params")) {
|
||||
PADDLE_ENFORCE(context->HasOutputs(framework::GradVarName("Params")));
|
||||
context->SetOutputsDim(framework::GradVarName("Params"),
|
||||
context->GetInputsDim("Params"));
|
||||
}
|
||||
PADDLE_ENFORCE(context->HasOutputs(framework::GradVarName("X")));
|
||||
context->SetOutputsDim(framework::GradVarName("X"),
|
||||
context->GetInputsDim("X"));
|
||||
}
|
||||
};
|
||||
|
||||
class ConditionalBlockGradMaker : public framework::SingleGradOpDescMaker {
|
||||
public:
|
||||
using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;
|
||||
|
||||
protected:
|
||||
std::unique_ptr<framework::OpDescBind> Apply() const override {
|
||||
auto grad_op = new framework::OpDescBind();
|
||||
grad_op->SetType("conditional_block_grad");
|
||||
grad_op->SetInput("X", Input("X"));
|
||||
grad_op->SetInput("Params", Input("Params"));
|
||||
grad_op->SetInput("Out", Output("Out"));
|
||||
grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out"));
|
||||
grad_op->SetInput("Scope", Output("Scope"));
|
||||
grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X"));
|
||||
grad_op->SetOutput(framework::GradVarName("Params"), InputGrad("Params"));
|
||||
grad_op->SetBlockAttr("block", *this->grad_block_[0]);
|
||||
return std::unique_ptr<framework::OpDescBind>(grad_op);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OPERATOR(conditional_block, ops::ConditionalBlockOp,
|
||||
ops::ConditionalBlockOpProtoMaker,
|
||||
ops::ConditionalBlockGradMaker);
|
||||
REGISTER_OPERATOR(conditional_block_grad, ops::ConditionalBlockGradOp,
|
||||
ops::ConditionalBlockGradInferShape);
|
||||
@ -0,0 +1,120 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/operators/lod_reset_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class LoDResetOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
void InferShape(framework::InferShapeContext *ctx) const override {
|
||||
// input check
|
||||
PADDLE_ENFORCE(ctx->HasInput("X"),
|
||||
"Input(X) of LoDResetOp should not be null.");
|
||||
PADDLE_ENFORCE(ctx->HasOutput("Out"),
|
||||
"Output(Out) of LoDResetOp should not be null.");
|
||||
// If target LoD is not set form Input(), then it must be set from Attr().
|
||||
if (!ctx->HasInput("TargetLoD")) {
|
||||
auto level0 = ctx->Attrs().Get<std::vector<int>>("target_lod");
|
||||
PADDLE_ENFORCE(level0.size() > 1,
|
||||
"Target LoD is not found, should be set to be a valid one "
|
||||
"through Input() or Attr().");
|
||||
}
|
||||
ctx->SetOutputDim("Out", ctx->GetInputDim("X"));
|
||||
}
|
||||
|
||||
protected:
|
||||
framework::OpKernelType GetKernelType(
|
||||
const framework::ExecutionContext &ctx) const override {
|
||||
return framework::OpKernelType(
|
||||
framework::ToDataType(ctx.Input<framework::LoDTensor>("X")->type()),
|
||||
ctx.device_context());
|
||||
}
|
||||
};
|
||||
|
||||
class LoDResetOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
LoDResetOpMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X", "(LoDTensor) The input tensor of lod_reset operator.");
|
||||
AddInput("TargetLoD",
|
||||
"(Tensor, optional) The target level 0 LoD from Input().")
|
||||
.AsDispensable();
|
||||
AddOutput("Out", "(LoDTensor) The output tensor of lod_reset operator.");
|
||||
AddAttr<std::vector<int>>("target_lod",
|
||||
"The target level 0 LoD from Attr().")
|
||||
.SetDefault(std::vector<int>{});
|
||||
AddComment(R"DOC(LoDReset operator
|
||||
|
||||
Reset LoD of Input(X) into a new one specified by Input(TargetLoD) or
|
||||
Attr(target_lod), or set LoD for Input(X) if it doesn't have one.
|
||||
Currently the lod_reset operator only supports the reset of level 0 LoD.
|
||||
At least one of Input(TargetLoD) and Attr(target_lod) must be set,
|
||||
and if both of them are set, Input(TargetLoD) will be chosen as the
|
||||
target LoD.
|
||||
|
||||
An example:
|
||||
Given a float LoDTensor X with shape (6, 1), its transpose form represents
|
||||
|
||||
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
|
||||
|
||||
with LoD = [[0, 2, 5, 6]] and the three (transposed) sequences look like
|
||||
|
||||
[1.0, 2.0], [3.0, 4.0, 5.0], [6.0].
|
||||
|
||||
If target LoD = [0, 4, 6], the lod_reset operator will reset the LoD and
|
||||
the sequences that the LoDTensor Output(Out) contains becomes:
|
||||
|
||||
[1.0, 2.0, 3.0, 4.0], [5.0, 6.0].
|
||||
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class LoDResetGradOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
void InferShape(framework::InferShapeContext *ctx) const override {
|
||||
PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) shouldn't be null.");
|
||||
PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")),
|
||||
"Input(Out@GRAD) shouldn't be null.");
|
||||
ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
|
||||
}
|
||||
|
||||
protected:
|
||||
framework::OpKernelType GetKernelType(
|
||||
const framework::ExecutionContext &ctx) const override {
|
||||
return framework::OpKernelType(
|
||||
framework::ToDataType(ctx.Input<framework::LoDTensor>("X")->type()),
|
||||
ctx.device_context());
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(lod_reset, ops::LoDResetOp, ops::LoDResetOpMaker, lod_reset_grad,
|
||||
ops::LoDResetGradOp);
|
||||
REGISTER_OP_CPU_KERNEL(lod_reset,
|
||||
ops::LoDResetKernel<paddle::platform::CPUPlace, float>,
|
||||
ops::LoDResetKernel<paddle::platform::CPUPlace, double>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
lod_reset_grad, ops::LoDResetGradKernel<paddle::platform::CPUPlace, float>,
|
||||
ops::LoDResetGradKernel<paddle::platform::CPUPlace, double>);
|
||||
@ -0,0 +1,24 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/operators/lod_reset_op.h"
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(lod_reset,
|
||||
ops::LoDResetKernel<paddle::platform::GPUPlace, float>,
|
||||
ops::LoDResetKernel<paddle::platform::GPUPlace, double>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
lod_reset_grad, ops::LoDResetGradKernel<paddle::platform::GPUPlace, float>,
|
||||
ops::LoDResetGradKernel<paddle::platform::GPUPlace, double>);
|
||||
@ -0,0 +1,78 @@
|
||||
/* 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "paddle/framework/eigen.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
template <typename Place, typename T>
|
||||
class LoDResetKernel : public framework::OpKernel<T> {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& ctx) const {
|
||||
auto* out = ctx.Output<framework::LoDTensor>("Out");
|
||||
auto* in = ctx.Input<framework::LoDTensor>("X");
|
||||
auto* lod_t = ctx.Input<framework::Tensor>("TargetLoD");
|
||||
|
||||
std::vector<int> level0;
|
||||
if (lod_t) {
|
||||
auto* lod = lod_t->data<int>();
|
||||
if (platform::is_gpu_place(ctx.GetPlace())) {
|
||||
framework::Tensor lod_cpu;
|
||||
lod_cpu.CopyFrom(*lod_t, platform::CPUPlace(), ctx.device_context());
|
||||
lod = lod_cpu.data<int>();
|
||||
}
|
||||
level0 = std::vector<int>(lod, lod + lod_t->numel());
|
||||
} else {
|
||||
level0 = ctx.Attr<std::vector<int>>("target_lod");
|
||||
}
|
||||
|
||||
PADDLE_ENFORCE(level0.size() > 1UL,
|
||||
"The size of target LoD should be greater than 1.");
|
||||
PADDLE_ENFORCE(level0[0] == 0,
|
||||
"Target LoD should be a vector starting from 0.");
|
||||
PADDLE_ENFORCE(level0.back() == in->dims()[0],
|
||||
"Target LoD should be a vector end with the "
|
||||
"first dimension of Input(X).");
|
||||
for (size_t i = 0; i < level0.size() - 1; ++i) {
|
||||
PADDLE_ENFORCE(level0[i + 1] > level0[i],
|
||||
"Target LoD should be an ascending vector.");
|
||||
}
|
||||
|
||||
out->ShareDataWith(*in);
|
||||
// cast level0 to size_t
|
||||
std::vector<size_t> ulevel0(level0.size(), 0);
|
||||
std::transform(level0.begin(), level0.end(), ulevel0.begin(),
|
||||
[](int a) { return static_cast<size_t>(a); });
|
||||
framework::LoD target_lod;
|
||||
target_lod.push_back(ulevel0);
|
||||
out->set_lod(target_lod);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Place, typename T>
|
||||
class LoDResetGradKernel : public framework::OpKernel<T> {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& ctx) const {
|
||||
auto* d_out = ctx.Input<framework::Tensor>(framework::GradVarName("Out"));
|
||||
auto* d_x = ctx.Output<framework::Tensor>(framework::GradVarName("X"));
|
||||
|
||||
d_x->ShareDataWith(*d_out);
|
||||
}
|
||||
};
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,182 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/memory/memcpy.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using LoD = framework::LoD;
|
||||
|
||||
class MergeLoDTensorOp : public framework::OperatorBase {
|
||||
public:
|
||||
MergeLoDTensorOp(const std::string &type,
|
||||
const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: OperatorBase(type, inputs, outputs, attrs) {}
|
||||
void Run(const framework::Scope &scope,
|
||||
const platform::DeviceContext &dev_ctx) const override {
|
||||
auto &x = scope.FindVar(Input("X"))->Get<framework::LoDTensor>();
|
||||
auto &mask = scope.FindVar(Input("Mask"))->Get<framework::LoDTensor>();
|
||||
auto &in_true = scope.FindVar(Input("InTrue"))->Get<framework::LoDTensor>();
|
||||
auto &in_false =
|
||||
scope.FindVar(Input("InFalse"))->Get<framework::LoDTensor>();
|
||||
auto *out =
|
||||
scope.FindVar(Output("Out"))->GetMutable<framework::LoDTensor>();
|
||||
auto level = static_cast<size_t>(Attr<int>("level"));
|
||||
|
||||
auto &mask_dim = mask.dims();
|
||||
|
||||
std::unique_ptr<framework::LoDTensor> cpu_mask{new framework::LoDTensor()};
|
||||
if (platform::is_cpu_place(mask.place())) {
|
||||
cpu_mask->ShareDataWith(mask);
|
||||
} else if (platform::is_gpu_place(mask.place())) {
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
cpu_mask->CopyFrom(mask, platform::CPUPlace(), dev_ctx);
|
||||
#else
|
||||
PADDLE_THROW("Not supported GPU, Please compile WITH_GPU option");
|
||||
#endif
|
||||
}
|
||||
auto *mask_data = cpu_mask->data<bool>();
|
||||
|
||||
int rank = in_true.dims().size();
|
||||
platform::Place place = in_true.place();
|
||||
std::type_index data_type = in_true.type();
|
||||
framework::DDim in_true_dims =
|
||||
framework::slice_ddim(in_true.dims(), 1, rank);
|
||||
|
||||
int64_t batch_size = in_true.dims()[0] + in_false.dims()[0];
|
||||
|
||||
auto in_true_dim_vec = framework::vectorize(in_true_dims);
|
||||
in_true_dim_vec.insert(in_true_dim_vec.begin(), batch_size);
|
||||
|
||||
framework::DDim out_dims = framework::make_ddim(in_true_dim_vec);
|
||||
out->Resize(out_dims);
|
||||
out->mutable_data(place, data_type);
|
||||
|
||||
auto *out_lod = out->mutable_lod();
|
||||
out_lod->clear();
|
||||
size_t out_offset = 0;
|
||||
|
||||
// Build LoDTensor `out`
|
||||
|
||||
size_t in_true_idx = 0;
|
||||
size_t in_false_idx = 0;
|
||||
for (size_t i = 0; i < static_cast<size_t>(mask_dim[0]); i++) {
|
||||
const framework::LoDTensor *input = nullptr;
|
||||
size_t *in_idx = nullptr;
|
||||
if (static_cast<int>(mask_data[i]) == 0) {
|
||||
input = &in_false;
|
||||
in_idx = &in_false_idx;
|
||||
} else {
|
||||
input = &in_true;
|
||||
in_idx = &in_true_idx;
|
||||
}
|
||||
auto lod_and_offset = framework::GetSubLoDAndAbsoluteOffset(
|
||||
input->lod(), *in_idx, (*in_idx) + 1, 0);
|
||||
auto &lod_length = lod_and_offset.first;
|
||||
|
||||
framework::AppendLoD(out_lod, lod_length);
|
||||
|
||||
size_t start_offset = lod_and_offset.second.first;
|
||||
size_t end_offset = lod_and_offset.second.second;
|
||||
|
||||
PADDLE_ENFORCE_GE(end_offset, start_offset);
|
||||
size_t len = end_offset - start_offset;
|
||||
if (len == 0) {
|
||||
continue;
|
||||
}
|
||||
out->Slice(out_offset, out_offset + len)
|
||||
.CopyFrom(input->Slice(start_offset, end_offset), place, dev_ctx);
|
||||
out_offset += len;
|
||||
(*in_idx) += 1;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < level; i++) {
|
||||
out_lod->insert(out_lod->begin(), x.lod()[i]);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class MergeLoDTensorOpProtoMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
MergeLoDTensorOpProtoMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X",
|
||||
"The input LoDTensor, contains complete lod information to "
|
||||
"construct the output");
|
||||
AddInput("Mask", "A bool column vector which mask the input");
|
||||
AddInput("InTrue", "The True branch to be merged");
|
||||
AddInput("InFalse", "The False branch to be merged");
|
||||
AddOutput("Out", "The merged output LoDTensor");
|
||||
AddAttr<int>("level", "(int) the specific lod level to rank.")
|
||||
.SetDefault(0)
|
||||
.EqualGreaterThan(0);
|
||||
AddComment(
|
||||
R"DOC(
|
||||
Merge True and False branches of LoDTensor into a single Output,
|
||||
with a mask at certain lod level. X is used to obtain complete
|
||||
lod information. Please refer to SplitLoDTensorOp.)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class MergeLoDTensorInferShape : public framework::InferShapeBase {
|
||||
public:
|
||||
void operator()(framework::InferShapeContext *context) const override {
|
||||
PADDLE_ENFORCE(context->HasInput("X"),
|
||||
"MergeLoDTensorOp must has input X.");
|
||||
PADDLE_ENFORCE(context->HasInput("Mask"),
|
||||
"MergeLoDTensorOp must has input Mask.");
|
||||
PADDLE_ENFORCE(context->HasInput("InTrue"),
|
||||
"MergeLoDTensorOp must has input InTrue.");
|
||||
PADDLE_ENFORCE(context->HasInput("InFalse"),
|
||||
"MergeLoDTensorOp must has input InFalse.");
|
||||
PADDLE_ENFORCE(context->HasOutput("Out"),
|
||||
"MergeLoDTensorOp must has output Out");
|
||||
|
||||
auto mask_dim = context->GetInputDim("Mask");
|
||||
PADDLE_ENFORCE_EQ(mask_dim.size(), 2);
|
||||
PADDLE_ENFORCE_EQ(mask_dim[1], 1);
|
||||
|
||||
context->SetOutputDim("Out", context->GetInputDim("InTrue"));
|
||||
}
|
||||
};
|
||||
|
||||
class MergeLoDTensorGradMaker : public framework::SingleGradOpDescMaker {
|
||||
public:
|
||||
using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;
|
||||
|
||||
protected:
|
||||
std::unique_ptr<framework::OpDescBind> Apply() const override {
|
||||
auto *grad_op = new framework::OpDescBind();
|
||||
grad_op->SetType("split_lod_tensor");
|
||||
grad_op->SetInput("X", OutputGrad("Out"));
|
||||
grad_op->SetInput("Mask", Input("Mask"));
|
||||
grad_op->SetOutput("OutTrue", InputGrad("InTrue"));
|
||||
grad_op->SetOutput("OutFalse", InputGrad("InFalse"));
|
||||
grad_op->SetAttrMap(Attrs());
|
||||
return std::unique_ptr<framework::OpDescBind>(grad_op);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OPERATOR(merge_lod_tensor, ops::MergeLoDTensorOp,
|
||||
ops::MergeLoDTensorOpProtoMaker,
|
||||
ops::MergeLoDTensorInferShape, ops::MergeLoDTensorGradMaker);
|
||||
@ -0,0 +1,186 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/memory/memcpy.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
struct CopyRange {
|
||||
size_t begin;
|
||||
size_t end;
|
||||
};
|
||||
|
||||
using LoD = framework::LoD;
|
||||
|
||||
class SplitLoDTensorOp : public framework::OperatorBase {
|
||||
public:
|
||||
SplitLoDTensorOp(const std::string &type,
|
||||
const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: OperatorBase(type, inputs, outputs, attrs) {}
|
||||
void Run(const framework::Scope &scope,
|
||||
const platform::DeviceContext &dev_ctx) const override {
|
||||
auto &x = scope.FindVar(Input("X"))->Get<framework::LoDTensor>();
|
||||
auto &mask = scope.FindVar(Input("Mask"))->Get<framework::LoDTensor>();
|
||||
auto *out_true =
|
||||
scope.FindVar(Output("OutTrue"))->GetMutable<framework::LoDTensor>();
|
||||
auto *out_false =
|
||||
scope.FindVar(Output("OutFalse"))->GetMutable<framework::LoDTensor>();
|
||||
auto level = static_cast<size_t>(Attr<int>("level"));
|
||||
auto &x_lod = x.lod();
|
||||
auto &mask_dim = mask.dims();
|
||||
|
||||
std::unique_ptr<framework::LoDTensor> cpu_mask{new framework::LoDTensor()};
|
||||
if (platform::is_cpu_place(mask.place())) {
|
||||
cpu_mask->ShareDataWith(mask);
|
||||
} else if (platform::is_gpu_place(mask.place())) {
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
cpu_mask->CopyFrom(mask, platform::CPUPlace(), dev_ctx);
|
||||
#else
|
||||
PADDLE_THROW("Not supported GPU, Please compile WITH_GPU option");
|
||||
#endif
|
||||
}
|
||||
auto *mask_data = cpu_mask->data<bool>();
|
||||
|
||||
std::vector<std::vector<CopyRange>> copy_ranges(mask_dim[0]);
|
||||
|
||||
// set out_true/out_false lod
|
||||
for (size_t t = 0; t < 2; t++) {
|
||||
LoD *lod = nullptr;
|
||||
if (t == 0) {
|
||||
lod = out_false->mutable_lod();
|
||||
} else {
|
||||
lod = out_true->mutable_lod();
|
||||
}
|
||||
lod->clear();
|
||||
for (size_t i = 0; i < static_cast<size_t>(mask_dim[0]); i++) {
|
||||
if (static_cast<size_t>(mask_data[i]) == t) {
|
||||
size_t start_idx = i;
|
||||
auto lod_and_offset = framework::GetSubLoDAndAbsoluteOffset(
|
||||
x_lod, start_idx, start_idx + 1, level);
|
||||
|
||||
auto &lod_length = lod_and_offset.first;
|
||||
framework::AppendLoD(lod, lod_length);
|
||||
|
||||
size_t start_offset = lod_and_offset.second.first;
|
||||
size_t end_offset = lod_and_offset.second.second;
|
||||
copy_ranges[t].emplace_back(CopyRange{start_offset, end_offset});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t t = 0; t < 2; ++t) {
|
||||
framework::LoDTensor *out;
|
||||
if (t == 0) {
|
||||
out = out_false;
|
||||
} else {
|
||||
out = out_true;
|
||||
}
|
||||
auto &ranges = copy_ranges[t];
|
||||
size_t height = std::accumulate(
|
||||
ranges.begin(), ranges.end(), 0UL,
|
||||
[](size_t a, const CopyRange &b) { return a + b.end - b.begin; });
|
||||
auto x_dim = x.dims();
|
||||
x_dim[0] = static_cast<int64_t>(height);
|
||||
out->Resize(x_dim);
|
||||
out->mutable_data(x.place(), x.type());
|
||||
size_t offset = 0;
|
||||
for (auto &each_range : ranges) {
|
||||
size_t len = each_range.end - each_range.begin;
|
||||
if (len == 0) {
|
||||
continue;
|
||||
}
|
||||
// out[offset: offset+len] = x[each_range.begin: each_range.end]
|
||||
out->Slice(static_cast<int>(offset), static_cast<int>(offset + len))
|
||||
.CopyFrom(x.Slice(static_cast<int>(each_range.begin),
|
||||
static_cast<int>(each_range.end)),
|
||||
x.place(), dev_ctx);
|
||||
offset += len;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class SplitLoDTensorOpProtoMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
SplitLoDTensorOpProtoMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X", "The input LoDTensor");
|
||||
AddInput("Mask", "A bool column vector which mask the input");
|
||||
AddOutput("OutTrue", "True branch of input LoDTensor");
|
||||
AddOutput("OutFalse", "False branch of input LoDTensor");
|
||||
AddAttr<int>("level", "(int) the specific lod level to split.")
|
||||
.SetDefault(0)
|
||||
.EqualGreaterThan(0);
|
||||
AddComment(
|
||||
R"DOC(
|
||||
Split a LoDTensor with a Mask at certain level. The input LoDTensor
|
||||
has 3 sequence at certain lod level. The Mask is a bool column vector,
|
||||
such as [0, 1, 0] at the same level. The first and third sequence will
|
||||
be send to False Output LoDTensor; whereas the second sequence will
|
||||
be send to True Output LoDTensor. Please refer to MergeLoDTensorOp.)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class SplitLoDTensorInferShape : public framework::InferShapeBase {
|
||||
public:
|
||||
void operator()(framework::InferShapeContext *context) const override {
|
||||
PADDLE_ENFORCE(context->HasInput("X"),
|
||||
"SplitLoDTensorOp must has input X.");
|
||||
PADDLE_ENFORCE(context->HasInput("Mask"),
|
||||
"SplitLoDTensorOp must has input Mask.");
|
||||
PADDLE_ENFORCE(context->HasOutput("OutTrue"),
|
||||
"SplitLoDTensorOp must has output OutTrue.");
|
||||
PADDLE_ENFORCE(context->HasOutput("OutFalse"),
|
||||
"SplitLoDTensorOp must has output OutFalse.");
|
||||
|
||||
auto mask_dim = context->GetInputDim("Mask");
|
||||
PADDLE_ENFORCE_EQ(mask_dim.size(), 2);
|
||||
PADDLE_ENFORCE_EQ(mask_dim[1], 1);
|
||||
|
||||
context->SetOutputDim("OutTrue", context->GetInputDim("X"));
|
||||
context->SetOutputDim("OutFalse", context->GetInputDim("X"));
|
||||
}
|
||||
};
|
||||
|
||||
class SplitLoDTensorArrayGradMaker : public framework::SingleGradOpDescMaker {
|
||||
public:
|
||||
using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;
|
||||
|
||||
protected:
|
||||
std::unique_ptr<framework::OpDescBind> Apply() const override {
|
||||
auto *grad_op = new framework::OpDescBind();
|
||||
grad_op->SetType("merge_lod_tensor");
|
||||
grad_op->SetInput("InTrue", OutputGrad("OutTrue"));
|
||||
grad_op->SetInput("InFalse", OutputGrad("OutFalse"));
|
||||
grad_op->SetInput("Mask", Input("Mask"));
|
||||
grad_op->SetInput("X", Input("X"));
|
||||
grad_op->SetOutput("Out", InputGrad("X"));
|
||||
grad_op->SetAttrMap(Attrs());
|
||||
return std::unique_ptr<framework::OpDescBind>(grad_op);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OPERATOR(split_lod_tensor, ops::SplitLoDTensorOp,
|
||||
ops::SplitLoDTensorOpProtoMaker,
|
||||
ops::SplitLoDTensorInferShape,
|
||||
ops::SplitLoDTensorArrayGradMaker);
|
||||
@ -0,0 +1,5 @@
|
||||
file(GLOB TEST_OPS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "test_*.py")
|
||||
string(REPLACE ".py" "" TEST_OPS "${TEST_OPS}")
|
||||
foreach(src ${TEST_OPS})
|
||||
py_test(${src} SRCS ${src}.py)
|
||||
endforeach()
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue