Skip to content

Commit 706c572

Browse files
author
xutianbing
committed
Matrix API refactor, when passing parameters, convert shared_ptr (MatrixPtr) to
reference or raw matrix (Matrix & or Matrix *) contextProjectionForward contextProjectionBackward contextProjectionBackwardData contextProjectionBackwardWeight classificationError The mul functions would be updated later.
1 parent 80b45ad commit 706c572

File tree

5 files changed

+103
-136
lines changed

5 files changed

+103
-136
lines changed

‎paddle/gserver/evaluators/Evaluator.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -78,7 +78,7 @@ class ClassificationErrorEvaluator : public Evaluator {
7878
useGpu(arguments[0].deviceId));
7979
errorMat->zeroMem();
8080
if (label != nullptr) {
81-
errorMat->classificationError(output, label);
81+
errorMat->classificationError(*output, *label);
8282
} else if (dynamic_cast<CpuSparseMatrix*>(multiBinaryLabel.get()) ||
8383
dynamic_cast<GpuSparseMatrix*>(multiBinaryLabel.get())) {
8484
errorMat->classificationErrorMulti(

‎paddle/gserver/layers/ContextProjection.cpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -90,8 +90,8 @@ void ContextProjection::forward() {
9090
REGISTER_TIMER_INFO("ContextProjectionForward", getName().c_str());
9191
bool isPadding = config_.trainable_padding();
9292
out_->value->contextProjectionForward(
93-
in_->value,
94-
state_ ? state_ : isPadding ? weight_->getW() : nullptr,
93+
*(in_->value),
94+
state_ ? state_.get() : isPadding ? weight_->getW().get() : nullptr,
9595
*startPositions,
9696
config_.context_length(),
9797
config_.context_start(),
@@ -128,24 +128,24 @@ void ContextProjection::backward(const UpdateCallback& callback) {
128128
bool isPadding = config_.trainable_padding();
129129
if (!out_->grad->useGpu()) {
130130
out_->grad->contextProjectionBackward(
131-
in_->grad,
132-
isPadding ? weight_->getWGrad() : nullptr,
131+
in_->grad.get(),
132+
isPadding ? weight_->getWGrad().get() : nullptr,
133133
*startPositions,
134134
config_.context_length(),
135135
config_.context_start(),
136136
beginPad_,
137137
isPadding);
138138
} else {
139139
if (in_->grad) {
140-
out_->grad->contextProjectionBackwardData(in_->grad,
140+
out_->grad->contextProjectionBackwardData(*(in_->grad),
141141
*startPositions,
142142
config_.context_length(),
143143
config_.context_start());
144144
}
145145

146146
if (isPadding && weight_->getWGrad()) {
147147
out_->grad->contextProjectionBackwardWeight(
148-
weight_->getWGrad(),
148+
*(weight_->getWGrad()),
149149
*startPositions,
150150
config_.context_length(),
151151
config_.context_start(),

‎paddle/math/Matrix.cpp‎

Lines changed: 69 additions & 102 deletions
Original file line numberDiff line numberDiff line change
@@ -766,20 +766,19 @@ void GpuMatrix::maxoutBackward(Matrix& a,
766766
}
767767

768768
/*calulate the error of classification */
769-
void GpuMatrix::classificationError(MatrixPtr output, IVectorPtr label) {
770-
GpuMatrixPtr output_ptr = std::dynamic_pointer_cast<GpuMatrix>(output);
771-
GpuIVectorPtr label_ptr = std::dynamic_pointer_cast<GpuIVector>(label);
772-
769+
void GpuMatrix::classificationError(Matrix& output, IVector& label) {
770+
auto output_ptr = dynamic_cast<const GpuMatrix*>(&output);
771+
auto label_ptr = dynamic_cast<const GpuIVector*>(&label);
773772
CHECK(output_ptr && label_ptr) << "Invalid argument pointer";
774773

775774
CHECK(height_ == output_ptr->height_ && width_ == 1)
776775
<< "Matrix dimensions are not equal";
777-
real* output_d = output_ptr->data_;
778-
real* recResult_d = data_;
779-
int* label_d = label_ptr->getData();
780776

781-
hl_matrix_classification_error(
782-
output_d, label_d, recResult_d, height_, output_ptr->width_);
777+
hl_matrix_classification_error((real*)output_ptr->data_,
778+
(int*)label_ptr->getData(),
779+
data_,
780+
height_,
781+
output_ptr->width_);
783782
}
784783

785784
/* copy -log(output[i * width + label]) to this->data[i] */
@@ -1370,86 +1369,62 @@ void GpuMatrix::maxSequenceBackward(Matrix& outputGrad,
13701369
hl_max_sequence_backward(outGrad, maxIndex, inputGrad, numSequences, dim);
13711370
}
13721371

1373-
void GpuMatrix::contextProjectionForward(MatrixPtr input,
1374-
MatrixPtr weight,
1372+
void GpuMatrix::contextProjectionForward(Matrix& input,
1373+
Matrix* weight,
13751374
const IVector& sequence,
13761375
int contextLength,
13771376
int contextStart,
13781377
size_t beginPad,
13791378
bool isPadding) {
1380-
CHECK(dynamic_cast<GpuMatrix*>(input.get()));
1379+
CHECK(dynamic_cast<GpuMatrix*>(&input));
13811380
CHECK(dynamic_cast<const GpuIVector*>(&sequence));
1382-
if (weight) CHECK(dynamic_cast<GpuMatrix*>(weight.get()));
1383-
1384-
size_t numSequences = sequence.getSize() - 1;
1385-
int64_t inputDim = input->getWidth();
1386-
int64_t dim = getWidth();
1387-
CHECK_EQ(dim, inputDim * contextLength);
1388-
1389-
real* outData = getData();
1390-
real* inputData = input->getData();
1391-
const int* starts = sequence.getData();
1381+
if (weight) CHECK(dynamic_cast<GpuMatrix*>(weight));
1382+
CHECK_EQ(getWidth(), input.getWidth() * contextLength);
13921383

1393-
hl_context_projection_forward(inputData,
1394-
starts,
1384+
hl_context_projection_forward(input.getData(),
1385+
sequence.getData(),
13951386
isPadding ? weight->getData() : NULL,
1396-
outData,
1397-
numSequences,
1398-
inputDim,
1387+
getData(),
1388+
sequence.getSize() - 1,
1389+
input.getWidth(),
13991390
contextLength,
14001391
contextStart,
14011392
beginPad,
14021393
isPadding);
14031394
}
14041395

1405-
void GpuMatrix::contextProjectionBackwardData(MatrixPtr inputGrad,
1396+
void GpuMatrix::contextProjectionBackwardData(Matrix& inputGrad,
14061397
const IVector& sequence,
14071398
int contextLength,
14081399
int contextStart) {
1409-
CHECK(dynamic_cast<GpuMatrix*>(inputGrad.get()));
1400+
CHECK(dynamic_cast<GpuMatrix*>(&inputGrad));
14101401
CHECK(dynamic_cast<const GpuIVector*>(&sequence));
1402+
CHECK_EQ(getWidth(), inputGrad.getWidth() * contextLength);
14111403

1412-
size_t numSequences = sequence.getSize() - 1;
1413-
int64_t inputDim = inputGrad->getWidth();
1414-
int64_t dim = getWidth();
1415-
CHECK_EQ(dim, inputDim * contextLength);
1416-
1417-
real* outGrad = getData();
1418-
real* inGrad = inputGrad->getData();
1419-
const int* starts = sequence.getData();
1420-
1421-
hl_context_projection_backward_data(outGrad,
1422-
starts,
1423-
inGrad,
1424-
numSequences,
1425-
inputDim,
1404+
hl_context_projection_backward_data(getData(),
1405+
sequence.getData(),
1406+
inputGrad.getData(),
1407+
sequence.getSize() - 1,
1408+
inputGrad.getWidth(),
14261409
contextLength,
14271410
contextStart);
14281411
}
14291412

1430-
void GpuMatrix::contextProjectionBackwardWeight(MatrixPtr weightGrad,
1413+
void GpuMatrix::contextProjectionBackwardWeight(Matrix& weightGrad,
14311414
const IVector& sequence,
14321415
int contextLength,
14331416
int contextStart,
14341417
int totalPad,
14351418
size_t beginPad) {
1436-
CHECK(dynamic_cast<GpuMatrix*>(weightGrad.get()));
1419+
CHECK(dynamic_cast<GpuMatrix*>(&weightGrad));
14371420
CHECK(dynamic_cast<const GpuIVector*>(&sequence));
1421+
CHECK_EQ(getWidth(), weightGrad.getWidth() * contextLength);
14381422

1439-
size_t numSequences = sequence.getSize() - 1;
1440-
int64_t weightDim = weightGrad->getWidth();
1441-
int64_t dim = getWidth();
1442-
CHECK_EQ(dim, weightDim * contextLength);
1443-
1444-
real* outGrad = getData();
1445-
real* wtGrad = weightGrad->getData();
1446-
const int* starts = sequence.getData();
1447-
1448-
hl_context_projection_backward_weight(outGrad,
1449-
starts,
1450-
wtGrad,
1451-
numSequences,
1452-
weightDim,
1423+
hl_context_projection_backward_weight(getData(),
1424+
sequence.getData(),
1425+
weightGrad.getData(),
1426+
sequence.getSize() - 1,
1427+
weightGrad.getWidth(),
14531428
totalPad,
14541429
contextLength,
14551430
contextStart,
@@ -2371,23 +2346,21 @@ void CpuMatrix::maxSequenceBackward(Matrix& outputGrad,
23712346
}
23722347
}
23732348

2374-
void CpuMatrix::contextProjectionForward(MatrixPtr input,
2375-
MatrixPtr weight,
2349+
void CpuMatrix::contextProjectionForward(Matrix& input,
2350+
Matrix* weight,
23762351
const IVector& sequence,
23772352
int contextLength,
23782353
int contextStart,
23792354
size_t beginPad,
23802355
bool isPadding) {
2381-
CHECK(dynamic_cast<CpuMatrix*>(input.get()));
2382-
CHECK(dynamic_cast<const CpuIVector*>(&sequence));
2383-
if (weight) CHECK(dynamic_cast<CpuMatrix*>(weight.get()));
2384-
2385-
size_t numSequences = sequence.getSize() - 1;
2386-
int64_t inputDim = input->getWidth();
2387-
int64_t dim = getWidth();
2388-
CHECK_EQ(dim, inputDim * contextLength);
2389-
const int* starts = sequence.getData();
2390-
2356+
auto input_ptr = dynamic_cast<CpuMatrix*>(&input);
2357+
auto seq_ptr = dynamic_cast<const CpuIVector*>(&sequence);
2358+
CHECK(input_ptr && seq_ptr);
2359+
if (weight) CHECK(dynamic_cast<CpuMatrix*>(weight));
2360+
CHECK_EQ(getWidth(), input_ptr->getWidth() * contextLength);
2361+
2362+
const int* starts = seq_ptr->getData();
2363+
size_t numSequences = seq_ptr->getSize() - 1;
23912364
for (size_t i = 0; i < numSequences; ++i) {
23922365
for (int j = 0; j < contextLength; ++j) {
23932366
int begin = starts[i] + contextStart + j;
@@ -2400,7 +2373,7 @@ void CpuMatrix::contextProjectionForward(MatrixPtr input,
24002373
MatrixPtr mat = this->subMatrix(starts[i], padSize);
24012374
if (isPadding) {
24022375
MatrixPtr sub = weight->subMatrix(j, padSize);
2403-
mat->addAtOffset(*sub, j * inputDim);
2376+
mat->addAtOffset(*sub, j * input_ptr->getWidth());
24042377
}
24052378
dstBegin = starts[i] + padSize;
24062379
begin = starts[i];
@@ -2412,41 +2385,36 @@ void CpuMatrix::contextProjectionForward(MatrixPtr input,
24122385
if (isPadding) {
24132386
MatrixPtr sub =
24142387
weight->subMatrix(beginPad + contextStart + j - padSize, padSize);
2415-
mat->addAtOffset(*sub, j * inputDim);
2388+
mat->addAtOffset(*sub, j * input_ptr->getWidth());
24162389
}
24172390
dstEnd = starts[i + 1] - padSize;
24182391
end = starts[i + 1];
24192392
}
24202393
if (end <= begin) continue;
2421-
MatrixPtr src = input->subMatrix(begin, end - begin);
2394+
MatrixPtr src = input_ptr->subMatrix(begin, end - begin);
24222395
MatrixPtr dst = this->subMatrix(dstBegin, dstEnd - dstBegin);
2423-
dst->addAtOffset(*src, j * inputDim);
2396+
dst->addAtOffset(*src, j * input_ptr->getWidth());
24242397
}
24252398
}
24262399
}
24272400

2428-
void CpuMatrix::contextProjectionBackward(MatrixPtr inputGrad,
2429-
MatrixPtr weightGrad,
2401+
void CpuMatrix::contextProjectionBackward(Matrix* inputGrad,
2402+
Matrix* weightGrad,
24302403
const IVector& sequence,
24312404
int contextLength,
24322405
int contextStart,
24332406
size_t beginPad,
24342407
bool isPadding) {
2435-
if (inputGrad) CHECK(dynamic_cast<CpuMatrix*>(inputGrad.get()));
2436-
if (weightGrad) CHECK(dynamic_cast<CpuMatrix*>(weightGrad.get()));
2408+
if (inputGrad) CHECK(dynamic_cast<CpuMatrix*>(inputGrad));
2409+
if (weightGrad) CHECK(dynamic_cast<CpuMatrix*>(weightGrad));
24372410
CHECK(dynamic_cast<const CpuIVector*>(&sequence));
24382411

2439-
int64_t inputDim = 0;
2440-
int64_t dim = getWidth();
2441-
size_t numSequences = sequence.getSize() - 1;
2442-
const int* starts = sequence.getData();
2443-
if (inputGrad) {
2444-
inputDim = inputGrad->getWidth();
2445-
} else {
2446-
inputDim = weightGrad->getWidth();
2447-
}
2448-
CHECK_EQ(dim, inputDim * contextLength);
2412+
int64_t inputDim = inputGrad ? inputGrad->getWidth()
2413+
: weightGrad ? weightGrad->getWidth() : 0;
2414+
CHECK_EQ(getWidth(), inputDim * contextLength);
24492415

2416+
const int* starts = sequence.getData();
2417+
size_t numSequences = sequence.getSize() - 1;
24502418
for (size_t i = 0; i < numSequences; ++i) {
24512419
for (int j = 0; j < contextLength; ++j) {
24522420
int begin = starts[i] + contextStart + j;
@@ -3544,21 +3512,20 @@ void CpuMatrix::rowNormalizeL1(Matrix& out) {
35443512
}
35453513

35463514
/* calulate classification error */
3547-
void CpuMatrix::classificationError(MatrixPtr output, IVectorPtr label) {
3548-
CHECK(dynamic_cast<CpuMatrix*>(output.get()));
3549-
CHECK(dynamic_cast<CpuIVector*>(label.get()));
3515+
void CpuMatrix::classificationError(Matrix& output, IVector& label) {
3516+
CHECK(dynamic_cast<const CpuMatrix*>(&output));
3517+
CHECK(dynamic_cast<const CpuIVector*>(&label));
35503518

3551-
size_t numSamples = getHeight();
3552-
size_t dim = output->getWidth();
3553-
CHECK_EQ(label->getSize(), numSamples);
3554-
CHECK_EQ(output->getHeight(), numSamples);
35553519
CHECK_EQ(getWidth(), (size_t)1);
3520+
size_t numSamples = getHeight();
3521+
CHECK_EQ(label.getSize(), numSamples);
3522+
CHECK_EQ(output.getHeight(), numSamples);
35563523

3557-
real* out = output->getData();
3558-
real* result = getData();
3559-
int* lbl = label->getData();
3560-
real maxData;
3561-
int maxIndex;
3524+
size_t dim = output.getWidth();
3525+
real* out = output.getData();
3526+
int* lbl = label.getData();
3527+
real maxData = 0.0;
3528+
int maxIndex = -1;
35623529
for (size_t i = 0; i < numSamples; ++i) {
35633530
CHECK_GE(lbl[i], 0);
35643531
CHECK_LT((size_t)lbl[i], dim);
@@ -3570,7 +3537,7 @@ void CpuMatrix::classificationError(MatrixPtr output, IVectorPtr label) {
35703537
maxData = out[i * dim + j];
35713538
}
35723539
}
3573-
result[i] = (maxIndex != lbl[i]);
3540+
getData()[i] = (maxIndex != lbl[i]);
35743541
}
35753542
}
35763543

0 commit comments

Comments
 (0)