Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Fix crf_layer when using GPU. #6522

Closed
wants to merge 5 commits into from
Closed

Fix crf_layer when using GPU. #6522

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
18cd66c
add gpu support for crf
peterzhang2029 Dec 12, 2017
2ee77ac
add gpu support for ChunckEvaluator
peterzhang2029 Dec 12, 2017
53179a4
fix code style
peterzhang2029 Dec 12, 2017
5daca79
update the duplicate of weight
peterzhang2029 Dec 15, 2017
5ca9411
remove unnecessary copy
peterzhang2029 Dec 18, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 16 additions & 3 deletions paddle/gserver/evaluators/ChunkEvaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -75,6 +75,8 @@ class ChunkEvaluator : public Evaluator {
std::vector<Segment> labelSegments_;
std::vector<Segment> outputSegments_;
std::set<int> excludedChunkTypes_;
IVectorPtr cpuOutput_;
IVectorPtr cpuLabel_;
mutable std::unordered_map<std::string, real> values_;

public:
Expand Down Expand Up @@ -142,16 +144,27 @@ class ChunkEvaluator : public Evaluator {
CHECK_EQ(arguments.size(), (size_t)2);
IVectorPtr& output = arguments[0].ids;
IVectorPtr& label = arguments[1].ids;
CHECK(!output->useGpu() && !label->useGpu()) << "Not supported";
auto sequenceStartPositions =
arguments[1].sequenceStartPositions->getVector(false);
CHECK_EQ(output->getSize(), label->getSize());
CHECK(sequenceStartPositions);
size_t numSequences = sequenceStartPositions->getSize() - 1;
const int* starts = sequenceStartPositions->getData();
if (output->useGpu()) {
IVector::resizeOrCreate(cpuOutput_, output->getSize(), false);
cpuOutput_->copyFrom(*output);
} else {
cpuOutput_ = output;
}
if (label->useGpu()) {
IVector::resizeOrCreate(cpuLabel_, label->getSize(), false);
cpuLabel_->copyFrom(*label);
} else {
cpuLabel_ = label;
}
for (size_t i = 0; i < numSequences; ++i) {
eval1(output->getData() + starts[i],
label->getData() + starts[i],
eval1(cpuOutput_->getData() + starts[i],
cpuLabel_->getData() + starts[i],
starts[i + 1] - starts[i]);
}
return 0;
Expand Down
64 changes: 55 additions & 9 deletions paddle/gserver/layers/CRFDecodingLayer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,42 +23,88 @@ bool CRFDecodingLayer::init(const LayerMap& layerMap,
if (!CRFLayer::init(layerMap, parameterMap)) {
return false;
}
crf_.reset(new LinearChainCRF(
numClasses_, parameter_->getBuf(PARAMETER_VALUE)->getData()));
if (!useGpu_) {
crf_.reset(new LinearChainCRF(
numClasses_, parameter_->getBuf(PARAMETER_VALUE)->getData()));
}
return true;
}

void CRFDecodingLayer::forward(PassType passType) {
Layer::forward(passType);

CHECK(!useGpu_) << "GPU is not supported";

if (useGpu_) {
cpuParam =
Vector::create(parameter_->getBuf(PARAMETER_VALUE)->getSize(), false);
cpuParam->copyFrom(*parameter_->getBuf(PARAMETER_VALUE));
crf_.reset(new LinearChainCRF(numClasses_, cpuParam->getData()));
}
const Argument& output = getInput(0);
CHECK(output.sequenceStartPositions);

size_t batchSize = output.getBatchSize();
size_t numSequences = output.sequenceStartPositions->getSize() - 1;

IVector::resizeOrCreate(output_.ids, batchSize, useGpu_);
IVectorPtr output_ids = output_.ids;
MatrixPtr output_arg_val = output.value;
if (useGpu_) {
Matrix::resizeOrCreate(cpuOutputArg_,
/* height */ output_arg_val->getHeight(),
/* width */ output_arg_val->getWidth(),
/* trans */ false,
/* useGpu */ false);
IVector::resizeOrCreate(cpuOutputId_, batchSize, false);
cpuOutputArg_->copyFrom(*output_arg_val);
} else {
cpuOutputId_ = output_ids;
cpuOutputArg_ = output_arg_val;
}
const int* starts = output.sequenceStartPositions->getData(false);
CHECK_EQ(starts[numSequences], (int)batchSize);

for (size_t i = 0; i < numSequences; ++i) {
crf_->decode(output.value->getData() + numClasses_ * starts[i],
output_.ids->getData() + starts[i],
crf_->decode(cpuOutputArg_->getData() + numClasses_ * starts[i],
cpuOutputId_->getData() + starts[i],
starts[i + 1] - starts[i]);
}

if (inputLayers_.size() == 2) {
const Argument& label = getInput(1);
resizeOutput(batchSize, 1);
CHECK(label.ids);
real* error = output_.value->getData();
int* ids = label.ids->getData();
int* result = output_.ids->getData();
MatrixPtr output_val = output_.value;
if (useGpu_) {
Matrix::resizeOrCreate(cpuOutput_,
/* height */ output_val->getHeight(),
/* width */ output_val->getWidth(),
/* trans */ false,
/* useGpu */ false);
IVector::resizeOrCreate(cpuLabel_, label.ids->getSize(), false);
cpuOutput_->copyFrom(*output_val);
cpuLabel_->copyFrom(*label.ids);
} else {
cpuOutput_ = output_val;
cpuLabel_ = label.ids;
}
real* error = cpuOutput_->getData();
int* ids = cpuLabel_->getData();
int* result = cpuOutputId_->getData();
for (size_t i = 0; i < batchSize; ++i) {
error[i] = ids[i] == result[i] ? 0 : 1;
}
if (useGpu_) {
output_val->copyFrom(*cpuOutput_);
} else {
output_val = cpuOutput_;
}
}
if (useGpu_) {
output_ids->copyFrom(*cpuOutputId_);
output_arg_val->copyFrom(*cpuOutputArg_);
} else {
output_ids = cpuOutputId_;
output_arg_val = cpuOutputArg_;
}
}

Expand Down
6 changes: 6 additions & 0 deletions paddle/gserver/layers/CRFDecodingLayer.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,12 @@ class CRFDecodingLayer : public CRFLayer {

protected:
std::unique_ptr<LinearChainCRF> crf_;
// The temporary variables in CPU memory.
MatrixPtr cpuOutputArg_;
MatrixPtr cpuOutput_;
IVectorPtr cpuLabel_;
IVectorPtr cpuOutputId_;
VectorPtr cpuParam;
};

} // namespace paddle
109 changes: 97 additions & 12 deletions paddle/gserver/layers/CRFLayer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -54,8 +54,6 @@ bool CRFLayer::init(const LayerMap& layerMap,
void CRFLayer::forward(PassType passType) {
Layer::forward(passType);

CHECK(!useGpu_) << "GPU is not supported";

const Argument& output = getInput(0);
const Argument& label = getInput(1);
CHECK(label.sequenceStartPositions);
Expand All @@ -68,16 +66,53 @@ void CRFLayer::forward(PassType passType) {
const int* starts = label.sequenceStartPositions->getData(false);
CHECK_EQ(starts[numSequences], batchSize);

MatrixPtr weight_val = weight_->getW();
MatrixPtr output_val = output_.value;
MatrixPtr output_arg_val = output.value;
IVectorPtr label_val = label.ids;
if (useGpu_) {
Matrix::resizeOrCreate(cpuWeight_,
/* height */ weight_val->getHeight(),
/* width */ weight_val->getWidth(),
/* trans */ false,
/* useGpu */ false);
Matrix::resizeOrCreate(cpuOutput_,
/* height */ output_val->getHeight(),
/* width */ output_val->getWidth(),
/* trans */ false,
/* useGpu */ false);
Matrix::resizeOrCreate(cpuOutputArg_,
/* height */ output_arg_val->getHeight(),
/* width */ output_arg_val->getWidth(),
/* trans */ false,
/* useGpu */ false);
IVector::resizeOrCreate(cpuLabel_, label_val->getSize(), false);
cpuWeight_->copyFrom(*weight_val);
cpuOutputArg_->copyFrom(*output_arg_val);
cpuOutput_->copyFrom(*output_val);
cpuLabel_->copyFrom(*label_val);
} else {
cpuWeight_ = weight_val;
cpuOutputArg_ = output_arg_val;
cpuOutput_ = output_val;
cpuLabel_ = label_val;
}
for (size_t i = 0; i < numSequences; ++i) {
if (i >= crfs_.size()) {
crfs_.emplace_back(numClasses_, weight_->getW()->getData());
crfs_.emplace_back(numClasses_, cpuWeight_->getData());
}
output_.value->getData()[i] =
crfs_[i].forward(output.value->getData() + numClasses_ * starts[i],
label.ids->getData() + starts[i],
cpuOutput_->getData()[i] =
crfs_[i].forward(cpuOutputArg_->getData() + numClasses_ * starts[i],
cpuLabel_->getData() + starts[i],
starts[i + 1] - starts[i]);
}

if (useGpu_) {
output_val->copyFrom(*cpuOutput_);
output_arg_val->copyFrom(*cpuOutputArg_);
} else {
output_val = cpuOutput_;
output_arg_val = cpuOutputArg_;
}
if (weightLayer_) {
const MatrixPtr& weight = getInputValue(*weightLayer_);
getOutputValue()->dotMul(*getOutputValue(), *weight);
Expand All @@ -91,9 +126,42 @@ void CRFLayer::backward(const UpdateCallback& callback) {
int numSequences = label.sequenceStartPositions->getSize() - 1;

bool needWGrad = weight_->getWGrad() ? true : false;
MatrixPtr output_arg_grad = output.grad;
MatrixPtr weight_grad = weight_->getWGrad();
MatrixPtr output_arg_val = output.value;
IVectorPtr label_val = label.ids;
if (useGpu_) {
cpuOutputArg_->copyFrom(*output_arg_val);
cpuLabel_->copyFrom(*label_val);
if (output_arg_grad) {
Matrix::resizeOrCreate(cpuOutputArgGrad_,
/* height */ output_arg_grad->getHeight(),
/* width */ output_arg_grad->getWidth(),
/* trans */ false,
/* useGpu */ false);
cpuOutputArgGrad_->copyFrom(*output_arg_grad);
}
if (needWGrad) {
Matrix::resizeOrCreate(cpuWeightGrad_,
/* height */ weight_grad->getHeight(),
/* width */ weight_grad->getWidth(),
/* trans */ false,
/* useGpu */ false);
cpuWeightGrad_->copyFrom(*weight_grad);
}
} else {
cpuOutputArg_ = output_arg_val;
cpuLabel_ = label_val;
if (output_arg_grad) {
cpuOutputArgGrad_ = output_arg_grad;
}
if (needWGrad) {
cpuWeightGrad_ = weight_grad;
}
}
for (int i = 0; i < numSequences; ++i) {
crfs_[i].backward(output.value->getData() + numClasses_ * starts[i],
label.ids->getData() + starts[i],
crfs_[i].backward(cpuOutputArg_->getData() + numClasses_ * starts[i],
cpuLabel_->getData() + starts[i],
starts[i + 1] - starts[i],
needWGrad);
real instanceWeight = weightLayer_
Expand All @@ -102,13 +170,30 @@ void CRFLayer::backward(const UpdateCallback& callback) {
instanceWeight *= coeff_;

if (output.grad) {
MatrixPtr grad = output.grad->subRowMatrix(starts[i], starts[i + 1]);
MatrixPtr grad =
cpuOutputArgGrad_->subRowMatrix(starts[i], starts[i + 1]);
grad->add(*crfs_[i].getXGrad(), real(1.0f), instanceWeight);
}
if (needWGrad) {
weight_->getWGrad()->add(
*crfs_[i].getWGrad(), real(1.0f), instanceWeight);
cpuWeightGrad_->add(*crfs_[i].getWGrad(), real(1.0f), instanceWeight);
}
}
if (useGpu_) {
if (output.grad) {
output_arg_grad->copyFrom(*cpuOutputArgGrad_);
}
if (needWGrad) {
weight_grad->copyFrom(*cpuWeightGrad_);
}
output_arg_val->copyFrom(*cpuOutputArg_);
} else {
if (output.grad) {
output_arg_grad = cpuOutputArgGrad_;
}
if (needWGrad) {
weight_grad = cpuWeightGrad_;
}
output_arg_val = cpuOutputArg_;
}

parameter_->incUpdate(callback);
Expand Down
8 changes: 8 additions & 0 deletions paddle/gserver/layers/CRFLayer.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -41,6 +41,14 @@ class CRFLayer : public Layer {
LayerPtr weightLayer_; // weight for each sequence
std::unique_ptr<Weight> weight_; // parameters
real coeff_; // weight for the layer

// The temporary variables in CPU memory.
MatrixPtr cpuWeight_;
MatrixPtr cpuOutputArg_;
MatrixPtr cpuOutput_;
MatrixPtr cpuWeightGrad_;
MatrixPtr cpuOutputArgGrad_;
IVectorPtr cpuLabel_;
};

} // namespace paddle
46 changes: 24 additions & 22 deletions paddle/gserver/tests/test_CRFLayerGrad.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -130,34 +130,36 @@ TestConfig initTestConfig(size_t numClasses, bool withWeight) {

TEST(Layer, CRFLayer) {
size_t numClasses = 10;
for (int tries = 0; tries < 5; ++tries) {
TestConfig config = initTestConfig(numClasses, /* withWeight= */ false);
for (int length : {1, 3, 100}) {
// Not support GPU now
testLayerGrad(config,
"crf",
length,
/* trans= */ false,
/* useGpu= */ false,
/* useWeight= */ false,
epsilon());
for (auto useGpu : {false, true}) {
for (int tries = 0; tries < 5; ++tries) {
TestConfig config = initTestConfig(numClasses, /* withWeight= */ false);
for (int length : {1, 3, 100}) {
testLayerGrad(config,
"crf",
length,
/* trans= */ false,
/* useGpu= */ useGpu,
/* useWeight= */ false,
epsilon());
}
}
}
}

TEST(Layer, CRFLayerUseWeight) {
size_t numClasses = 10;
for (int tries = 0; tries < 5; ++tries) {
TestConfig config = initTestConfig(numClasses, /* withWeight= */ true);
for (int length : {1, 3, 100}) {
// Not support GPU now
testLayerGrad(config,
"crf",
length,
/* trans= */ false,
/* useGpu= */ false,
/* useWeight= */ false,
epsilon());
for (auto useGpu : {false, true}) {
for (int tries = 0; tries < 5; ++tries) {
TestConfig config = initTestConfig(numClasses, /* withWeight= */ true);
for (int length : {1, 3, 100}) {
testLayerGrad(config,
"crf",
length,
/* trans= */ false,
/* useGpu= */ useGpu,
/* useWeight= */ false,
epsilon());
}
}
}
}
Expand Down