Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into poolmaxpool_with_mask
xzl
7 years ago
commit
e19b931af9
@ -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,110 @@
|
||||
/* 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/beam_search_decode_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class BeamSearchDecodeOp : public framework::OperatorBase {
|
||||
public:
|
||||
BeamSearchDecodeOp(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 {
|
||||
framework::ExecutionContext ctx(*this, scope, dev_ctx);
|
||||
const LoDTensorArray* ids = ctx.Input<LoDTensorArray>("Ids");
|
||||
const LoDTensorArray* scores = ctx.Input<LoDTensorArray>("Scores");
|
||||
const size_t step_num = ids->size();
|
||||
PADDLE_ENFORCE_GT(step_num, 0UL,
|
||||
"beam search steps should be larger than 0");
|
||||
const size_t source_num = ids->at(0).lod().at(0).size() - 1;
|
||||
PADDLE_ENFORCE_GT(source_num, 0UL, "source num should be larger than 0");
|
||||
|
||||
for (size_t i = 0; i < step_num; ++i) {
|
||||
PADDLE_ENFORCE_EQ(ids->at(i).lod().size(), 2UL,
|
||||
"Level of LodTensor should be 2");
|
||||
}
|
||||
|
||||
// prepare output
|
||||
LoDTensor* sentenceIds = ctx.Output<LoDTensor>("SentenceIds");
|
||||
LoDTensor* sentenceScores = ctx.Output<LoDTensor>("SentenceScores");
|
||||
|
||||
BeamSearchDecoder<float> beam_search_decoder;
|
||||
beam_search_decoder.PackAllSteps(*ids, *scores, sentenceIds,
|
||||
sentenceScores);
|
||||
}
|
||||
};
|
||||
|
||||
class BeamSearchDecodeOpProtoMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
BeamSearchDecodeOpProtoMaker(framework::OpProto* proto,
|
||||
framework::OpAttrChecker* op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("Ids",
|
||||
"(LodTensorArray)"
|
||||
"score of the candidate words in each step");
|
||||
AddInput("Scores",
|
||||
"(LodTensorArray)"
|
||||
"score of the candidate words in each step");
|
||||
AddOutput("SentenceIds",
|
||||
"(LodTensor)"
|
||||
"All possible result sentences of word ids");
|
||||
AddOutput("SentenceScores",
|
||||
"(LodTensor)"
|
||||
"All possible result sentences of word scores");
|
||||
AddComment(R"DOC(
|
||||
Pack the result of Beam search op into SentenceIds and SentenceScores.
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class BeamSearchDecodeInferShape : public framework::InferShapeBase {
|
||||
public:
|
||||
void operator()(framework::InferShapeContext* context) const override {
|
||||
PADDLE_ENFORCE(context->HasInput("Ids"),
|
||||
"BeamSearchDecodeOp must has input Ids");
|
||||
PADDLE_ENFORCE(context->HasInput("Scores"),
|
||||
"BeamSearchDecodeOp must has input Scores");
|
||||
PADDLE_ENFORCE(context->HasOutput("SentenceIds"),
|
||||
"BeamSearchDecodeOp must has output SentenceIds");
|
||||
PADDLE_ENFORCE(context->HasOutput("SentenceScores"),
|
||||
"BeamSearchDecodeOp must has output SentenceScores");
|
||||
}
|
||||
};
|
||||
|
||||
class BeamSearchDecodeInferVarType : public framework::VarTypeInference {
|
||||
public:
|
||||
void operator()(const framework::OpDescBind& op_desc,
|
||||
framework::BlockDescBind* block) const override {
|
||||
for (auto& o : op_desc.Output("SentenceIds")) {
|
||||
block->Var(o)->SetType(framework::VarDesc::LOD_TENSOR);
|
||||
}
|
||||
for (auto& o : op_desc.Output("SentenceScores")) {
|
||||
block->Var(o)->SetType(framework::VarDesc::LOD_TENSOR);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
REGISTER_OPERATOR(beam_search_decode, paddle::operators::BeamSearchDecodeOp,
|
||||
paddle::operators::BeamSearchDecodeOpProtoMaker,
|
||||
paddle::operators::BeamSearchDecodeInferShape,
|
||||
paddle::operators::BeamSearchDecodeInferVarType,
|
||||
paddle::framework::EmptyGradOpMaker);
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,221 @@
|
||||
/* 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/beam_search_decode_op.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using CPUPlace = paddle::platform::CPUPlace;
|
||||
using LoD = paddle::framework::LoD;
|
||||
using LoDTensor = paddle::framework::LoDTensor;
|
||||
using LoDTensorArray = paddle::framework::LoDTensorArray;
|
||||
|
||||
template <typename T>
|
||||
using BeamNode = paddle::operators::BeamNode<T>;
|
||||
template <typename T>
|
||||
using BeamSearchDecoder = paddle::operators::BeamSearchDecoder<T>;
|
||||
template <typename T>
|
||||
using Sentence = paddle::operators::Sentence<T>;
|
||||
template <typename T>
|
||||
using BeamNodeVector = paddle::operators::BeamNodeVector<T>;
|
||||
template <typename T>
|
||||
using SentenceVector = paddle::operators::SentenceVector<T>;
|
||||
|
||||
namespace paddle {
|
||||
namespace test {
|
||||
|
||||
void GenerateExample(const std::vector<size_t>& level_0,
|
||||
const std::vector<size_t>& level_1,
|
||||
const std::vector<int>& data, LoDTensorArray* ids,
|
||||
LoDTensorArray* scores) {
|
||||
PADDLE_ENFORCE_EQ(level_0.back(), level_1.size() - 1,
|
||||
"source level is used to describe candidate set");
|
||||
PADDLE_ENFORCE_EQ(level_1.back(), data.size(),
|
||||
"the lowest level is used to describe data"
|
||||
", so it's last element should be data length");
|
||||
|
||||
CPUPlace place;
|
||||
|
||||
LoD lod;
|
||||
lod.push_back(level_0);
|
||||
lod.push_back(level_1);
|
||||
|
||||
// Ids
|
||||
LoDTensor tensor_id;
|
||||
tensor_id.set_lod(lod);
|
||||
tensor_id.Resize({static_cast<int64_t>(data.size())});
|
||||
// malloc memory
|
||||
int64_t* id_ptr = tensor_id.mutable_data<int64_t>(place);
|
||||
for (size_t i = 0; i < data.size(); ++i) {
|
||||
id_ptr[i] = static_cast<int64_t>(data.at(i));
|
||||
}
|
||||
|
||||
// Scores
|
||||
LoDTensor tensor_score;
|
||||
tensor_score.set_lod(lod);
|
||||
tensor_score.Resize({static_cast<int64_t>(data.size())});
|
||||
// malloc memory
|
||||
float* score_ptr = tensor_score.mutable_data<float>(place);
|
||||
for (size_t i = 0; i < data.size(); ++i) {
|
||||
score_ptr[i] = static_cast<float>(data.at(i));
|
||||
}
|
||||
|
||||
ids->push_back(tensor_id);
|
||||
scores->push_back(tensor_score);
|
||||
}
|
||||
|
||||
} // namespace test
|
||||
} // namespace paddle
|
||||
|
||||
TEST(BeamSearchDecodeOp, DeleteBeamNode) {
|
||||
auto* root = new BeamNode<float>(0, 0);
|
||||
auto* b1 = new BeamNode<float>(1, 1);
|
||||
auto* b2 = new BeamNode<float>(2, 2);
|
||||
auto* b3 = new BeamNode<float>(3, 3);
|
||||
|
||||
b1->AppendTo(root);
|
||||
b2->AppendTo(root);
|
||||
b3->AppendTo(b1);
|
||||
|
||||
delete b3;
|
||||
delete b2;
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOp, MakeSentence) {
|
||||
auto* root = new BeamNode<float>(0, 0);
|
||||
auto* b1 = new BeamNode<float>(1, 1);
|
||||
auto* end = new BeamNode<float>(2, 2);
|
||||
b1->AppendTo(root);
|
||||
end->AppendTo(b1);
|
||||
|
||||
BeamSearchDecoder<float> helper;
|
||||
Sentence<float> sentence = helper.MakeSentence(end);
|
||||
delete end;
|
||||
|
||||
std::vector<int64_t> expect_ids = {0, 1, 2};
|
||||
ASSERT_EQ(sentence.word_ids, expect_ids);
|
||||
|
||||
std::vector<float> expect_scores = {0, 1, 2};
|
||||
ASSERT_EQ(sentence.scores, expect_scores);
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOp, PackTwoStepsFistStep) {
|
||||
CPUPlace place;
|
||||
|
||||
LoDTensorArray ids;
|
||||
LoDTensorArray scores;
|
||||
|
||||
paddle::test::GenerateExample(
|
||||
std::vector<size_t>{0, 2, 6}, std::vector<size_t>{0, 1, 2, 3, 4, 5, 6},
|
||||
std::vector<int>{1, 2, 3, 4, 5, 6}, &ids, &scores);
|
||||
|
||||
std::vector<BeamNodeVector<float>> beamnode_vector_list;
|
||||
std::vector<SentenceVector<float>> sentence_vector_list(
|
||||
2, SentenceVector<float>());
|
||||
|
||||
BeamSearchDecoder<float> helper;
|
||||
beamnode_vector_list = helper.PackTwoSteps(
|
||||
ids[0], scores[0], beamnode_vector_list, &sentence_vector_list);
|
||||
ASSERT_EQ(beamnode_vector_list.size(), 2UL);
|
||||
ASSERT_EQ(beamnode_vector_list[0].size(), 2UL);
|
||||
ASSERT_EQ(beamnode_vector_list[1].size(), 4UL);
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOp, PackTwoSteps) {
|
||||
CPUPlace place;
|
||||
|
||||
// first source has three prefix
|
||||
BeamNodeVector<float> source0_prefixes;
|
||||
source0_prefixes.push_back(
|
||||
std::unique_ptr<BeamNode<float>>(new BeamNode<float>(1, 1)));
|
||||
source0_prefixes.push_back(
|
||||
std::unique_ptr<BeamNode<float>>(new BeamNode<float>(0, 0)));
|
||||
source0_prefixes.push_back(
|
||||
std::unique_ptr<BeamNode<float>>(new BeamNode<float>(3, 3)));
|
||||
|
||||
// second source has two prefix
|
||||
BeamNodeVector<float> source1_prefixes;
|
||||
source1_prefixes.push_back(
|
||||
std::unique_ptr<BeamNode<float>>(new BeamNode<float>(4, 4)));
|
||||
source1_prefixes.push_back(
|
||||
std::unique_ptr<BeamNode<float>>(new BeamNode<float>(5, 5)));
|
||||
|
||||
std::vector<BeamNodeVector<float>> beamnode_vector_list;
|
||||
std::vector<SentenceVector<float>> sentence_vector_list(
|
||||
2, SentenceVector<float>());
|
||||
|
||||
beamnode_vector_list.push_back(std::move(source0_prefixes));
|
||||
beamnode_vector_list.push_back(std::move(source1_prefixes));
|
||||
|
||||
// generate data for one step
|
||||
LoDTensorArray ids;
|
||||
LoDTensorArray scores;
|
||||
|
||||
paddle::test::GenerateExample(std::vector<size_t>{0, 3, 5},
|
||||
std::vector<size_t>{0, 1, 1, 3, 4, 5},
|
||||
std::vector<int>{0, 1, 2, 3, 4}, &ids, &scores);
|
||||
|
||||
BeamSearchDecoder<float> helper1;
|
||||
beamnode_vector_list = helper1.PackTwoSteps(
|
||||
ids[0], scores[0], beamnode_vector_list, &sentence_vector_list);
|
||||
|
||||
ASSERT_EQ(sentence_vector_list[0].size(), 1UL);
|
||||
ASSERT_EQ(sentence_vector_list[1].size(), 0UL);
|
||||
ASSERT_EQ(beamnode_vector_list[0].size(), 3UL);
|
||||
ASSERT_EQ(beamnode_vector_list[1].size(), 2UL);
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOp, PackAllSteps) {
|
||||
CPUPlace place;
|
||||
|
||||
// we will constuct a sample data with 3 steps and 2 source sentences
|
||||
LoDTensorArray ids;
|
||||
LoDTensorArray scores;
|
||||
|
||||
paddle::test::GenerateExample(
|
||||
std::vector<size_t>{0, 3, 6}, std::vector<size_t>{0, 1, 2, 3, 4, 5, 6},
|
||||
std::vector<int>{1, 2, 3, 4, 5, 6}, &ids, &scores);
|
||||
paddle::test::GenerateExample(
|
||||
std::vector<size_t>{0, 3, 6}, std::vector<size_t>{0, 1, 1, 3, 5, 5, 6},
|
||||
std::vector<int>{0, 1, 2, 3, 4, 5}, &ids, &scores);
|
||||
paddle::test::GenerateExample(std::vector<size_t>{0, 3, 6},
|
||||
std::vector<size_t>{0, 0, 1, 2, 3, 4, 5},
|
||||
std::vector<int>{0, 1, 2, 3, 4}, &ids, &scores);
|
||||
|
||||
ASSERT_EQ(ids.size(), 3UL);
|
||||
ASSERT_EQ(scores.size(), 3UL);
|
||||
|
||||
BeamSearchDecoder<float> helper;
|
||||
|
||||
LoDTensor id_tensor;
|
||||
LoDTensor score_tensor;
|
||||
helper.PackAllSteps(ids, scores, &id_tensor, &score_tensor);
|
||||
|
||||
LoD lod = id_tensor.lod();
|
||||
std::vector<size_t> expect_source_lod = {0, 4, 8};
|
||||
EXPECT_EQ(lod[0], expect_source_lod);
|
||||
std::vector<size_t> expect_sentence_lod = {0, 1, 3, 6, 9, 10, 13, 16, 19};
|
||||
EXPECT_EQ(lod[1], expect_sentence_lod);
|
||||
// 2| 1, 0| 3, 1, 0| 3, 2, 1| 5| 4, 3, 2| 4, 4, 3| 6, 5, 4
|
||||
std::vector<int> expect_data = {2, 1, 0, 3, 1, 0, 3, 2, 1, 5,
|
||||
4, 3, 2, 4, 4, 3, 6, 5, 4};
|
||||
ASSERT_EQ(id_tensor.dims()[0], static_cast<int64_t>(expect_data.size()));
|
||||
for (size_t i = 0; i < expect_data.size(); ++i) {
|
||||
ASSERT_EQ(id_tensor.data<int64_t>()[i],
|
||||
static_cast<int64_t>(expect_data[i]));
|
||||
}
|
||||
for (int64_t i = 0; i < id_tensor.dims()[0]; ++i) {
|
||||
ASSERT_EQ(score_tensor.data<float>()[i],
|
||||
static_cast<float>(id_tensor.data<int64_t>()[i]));
|
||||
}
|
||||
}
|
||||
@ -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,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