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.

paddle/gserver/evaluators/Evaluator.cpp

@@ -78,7 +78,7 @@ public:
                                               useGpu(arguments[0].deviceId));
     errorMat->zeroMem();
     if (label != nullptr) {
-      errorMat->classificationError(output, label);
+      errorMat->classificationError(*output, *label);
     } else if (dynamic_cast<CpuSparseMatrix*>(multiBinaryLabel.get()) ||
                dynamic_cast<GpuSparseMatrix*>(multiBinaryLabel.get())) {
       errorMat->classificationErrorMulti(

paddle/gserver/layers/ContextProjection.cpp

@@ -90,8 +90,8 @@ void ContextProjection::forward() {
   REGISTER_TIMER_INFO("ContextProjectionForward", getName().c_str());
   bool isPadding = config_.trainable_padding();
   out_->value->contextProjectionForward(
-      in_->value,
-      state_ ? state_ : isPadding ? weight_->getW() : nullptr,
+      *(in_->value),
+      state_ ? state_.get() : isPadding ? weight_->getW().get() : nullptr,
       *startPositions,
       config_.context_length(),
       config_.context_start(),
@@ -128,8 +128,8 @@ void ContextProjection::backward(const UpdateCallback& callback) {
   bool isPadding = config_.trainable_padding();
   if (!out_->grad->useGpu()) {
     out_->grad->contextProjectionBackward(
-        in_->grad,
-        isPadding ? weight_->getWGrad() : nullptr,
+        in_->grad.get(),
+        isPadding ? weight_->getWGrad().get() : nullptr,
         *startPositions,
         config_.context_length(),
         config_.context_start(),
@@ -137,7 +137,7 @@ void ContextProjection::backward(const UpdateCallback& callback) {
         isPadding);
   } else {
     if (in_->grad) {
-      out_->grad->contextProjectionBackwardData(in_->grad,
+      out_->grad->contextProjectionBackwardData(*(in_->grad),
                                                 *startPositions,
                                                 config_.context_length(),
                                                 config_.context_start());
@@ -145,7 +145,7 @@ void ContextProjection::backward(const UpdateCallback& callback) {
 
     if (isPadding && weight_->getWGrad()) {
       out_->grad->contextProjectionBackwardWeight(
-          weight_->getWGrad(),
+          *(weight_->getWGrad()),
           *startPositions,
           config_.context_length(),
           config_.context_start(),

paddle/math/Matrix.cpp

@@ -766,20 +766,19 @@ void GpuMatrix::maxoutBackward(Matrix& a,
 }
 
 /*calulate the error of classification */
-void GpuMatrix::classificationError(MatrixPtr output, IVectorPtr label) {
-  GpuMatrixPtr output_ptr = std::dynamic_pointer_cast<GpuMatrix>(output);
-  GpuIVectorPtr label_ptr = std::dynamic_pointer_cast<GpuIVector>(label);
-
+void GpuMatrix::classificationError(Matrix& output, IVector& label) {
+  auto output_ptr = dynamic_cast<const GpuMatrix*>(&output);
+  auto label_ptr = dynamic_cast<const GpuIVector*>(&label);
   CHECK(output_ptr && label_ptr) << "Invalid argument pointer";
 
   CHECK(height_ == output_ptr->height_ && width_ == 1)
       << "Matrix dimensions are not equal";
-  real* output_d = output_ptr->data_;
-  real* recResult_d = data_;
-  int* label_d = label_ptr->getData();
 
-  hl_matrix_classification_error(
-      output_d, label_d, recResult_d, height_, output_ptr->width_);
+  hl_matrix_classification_error((real*)output_ptr->data_,
+                                 (int*)label_ptr->getData(),
+                                 data_,
+                                 height_,
+                                 output_ptr->width_);
 }
 
 /* copy -log(output[i * width + label]) to this->data[i] */
@@ -1370,86 +1369,62 @@ void GpuMatrix::maxSequenceBackward(Matrix& outputGrad,
   hl_max_sequence_backward(outGrad, maxIndex, inputGrad, numSequences, dim);
 }
 
-void GpuMatrix::contextProjectionForward(MatrixPtr input,
-                                         MatrixPtr weight,
+void GpuMatrix::contextProjectionForward(Matrix& input,
+                                         Matrix* weight,
                                          const IVector& sequence,
                                          int contextLength,
                                          int contextStart,
                                          size_t beginPad,
                                          bool isPadding) {
-  CHECK(dynamic_cast<GpuMatrix*>(input.get()));
+  CHECK(dynamic_cast<GpuMatrix*>(&input));
   CHECK(dynamic_cast<const GpuIVector*>(&sequence));
-  if (weight) CHECK(dynamic_cast<GpuMatrix*>(weight.get()));
-
-  size_t numSequences = sequence.getSize() - 1;
-  int64_t inputDim = input->getWidth();
-  int64_t dim = getWidth();
-  CHECK_EQ(dim, inputDim * contextLength);
-
-  real* outData = getData();
-  real* inputData = input->getData();
-  const int* starts = sequence.getData();
+  if (weight) CHECK(dynamic_cast<GpuMatrix*>(weight));
+  CHECK_EQ(getWidth(), input.getWidth() * contextLength);
 
-  hl_context_projection_forward(inputData,
-                                starts,
+  hl_context_projection_forward(input.getData(),
+                                sequence.getData(),
                                 isPadding ? weight->getData() : NULL,
-                                outData,
-                                numSequences,
-                                inputDim,
+                                getData(),
+                                sequence.getSize() - 1,
+                                input.getWidth(),
                                 contextLength,
                                 contextStart,
                                 beginPad,
                                 isPadding);
 }
 
-void GpuMatrix::contextProjectionBackwardData(MatrixPtr inputGrad,
+void GpuMatrix::contextProjectionBackwardData(Matrix& inputGrad,
                                               const IVector& sequence,
                                               int contextLength,
                                               int contextStart) {
-  CHECK(dynamic_cast<GpuMatrix*>(inputGrad.get()));
+  CHECK(dynamic_cast<GpuMatrix*>(&inputGrad));
   CHECK(dynamic_cast<const GpuIVector*>(&sequence));
+  CHECK_EQ(getWidth(), inputGrad.getWidth() * contextLength);
 
-  size_t numSequences = sequence.getSize() - 1;
-  int64_t inputDim = inputGrad->getWidth();
-  int64_t dim = getWidth();
-  CHECK_EQ(dim, inputDim * contextLength);
-
-  real* outGrad = getData();
-  real* inGrad = inputGrad->getData();
-  const int* starts = sequence.getData();
-
-  hl_context_projection_backward_data(outGrad,
-                                      starts,
-                                      inGrad,
-                                      numSequences,
-                                      inputDim,
+  hl_context_projection_backward_data(getData(),
+                                      sequence.getData(),
+                                      inputGrad.getData(),
+                                      sequence.getSize() - 1,
+                                      inputGrad.getWidth(),
                                       contextLength,
                                       contextStart);
 }
 
-void GpuMatrix::contextProjectionBackwardWeight(MatrixPtr weightGrad,
+void GpuMatrix::contextProjectionBackwardWeight(Matrix& weightGrad,
                                                 const IVector& sequence,
                                                 int contextLength,
                                                 int contextStart,
                                                 int totalPad,
                                                 size_t beginPad) {
-  CHECK(dynamic_cast<GpuMatrix*>(weightGrad.get()));
+  CHECK(dynamic_cast<GpuMatrix*>(&weightGrad));
   CHECK(dynamic_cast<const GpuIVector*>(&sequence));
+  CHECK_EQ(getWidth(), weightGrad.getWidth() * contextLength);
 
-  size_t numSequences = sequence.getSize() - 1;
-  int64_t weightDim = weightGrad->getWidth();
-  int64_t dim = getWidth();
-  CHECK_EQ(dim, weightDim * contextLength);
-
-  real* outGrad = getData();
-  real* wtGrad = weightGrad->getData();
-  const int* starts = sequence.getData();
-
-  hl_context_projection_backward_weight(outGrad,
-                                        starts,
-                                        wtGrad,
-                                        numSequences,
-                                        weightDim,
+  hl_context_projection_backward_weight(getData(),
+                                        sequence.getData(),
+                                        weightGrad.getData(),
+                                        sequence.getSize() - 1,
+                                        weightGrad.getWidth(),
                                         totalPad,
                                         contextLength,
                                         contextStart,
@@ -2371,23 +2346,21 @@ void CpuMatrix::maxSequenceBackward(Matrix& outputGrad,
   }
 }
 
-void CpuMatrix::contextProjectionForward(MatrixPtr input,
-                                         MatrixPtr weight,
+void CpuMatrix::contextProjectionForward(Matrix& input,
+                                         Matrix* weight,
                                          const IVector& sequence,
                                          int contextLength,
                                          int contextStart,
                                          size_t beginPad,
                                          bool isPadding) {
-  CHECK(dynamic_cast<CpuMatrix*>(input.get()));
-  CHECK(dynamic_cast<const CpuIVector*>(&sequence));
-  if (weight) CHECK(dynamic_cast<CpuMatrix*>(weight.get()));
-
-  size_t numSequences = sequence.getSize() - 1;
-  int64_t inputDim = input->getWidth();
-  int64_t dim = getWidth();
-  CHECK_EQ(dim, inputDim * contextLength);
-  const int* starts = sequence.getData();
-
+  auto input_ptr = dynamic_cast<CpuMatrix*>(&input);
+  auto seq_ptr = dynamic_cast<const CpuIVector*>(&sequence);
+  CHECK(input_ptr && seq_ptr);
+  if (weight) CHECK(dynamic_cast<CpuMatrix*>(weight));
+  CHECK_EQ(getWidth(), input_ptr->getWidth() * contextLength);
+
+  const int* starts = seq_ptr->getData();
+  size_t numSequences = seq_ptr->getSize() - 1;
   for (size_t i = 0; i < numSequences; ++i) {
     for (int j = 0; j < contextLength; ++j) {
       int begin = starts[i] + contextStart + j;
@@ -2400,7 +2373,7 @@ void CpuMatrix::contextProjectionForward(MatrixPtr input,
         MatrixPtr mat = this->subMatrix(starts[i], padSize);
         if (isPadding) {
           MatrixPtr sub = weight->subMatrix(j, padSize);
-          mat->addAtOffset(*sub, j * inputDim);
+          mat->addAtOffset(*sub, j * input_ptr->getWidth());
         }
         dstBegin = starts[i] + padSize;
         begin = starts[i];
@@ -2412,41 +2385,36 @@ void CpuMatrix::contextProjectionForward(MatrixPtr input,
         if (isPadding) {
           MatrixPtr sub =
               weight->subMatrix(beginPad + contextStart + j - padSize, padSize);
-          mat->addAtOffset(*sub, j * inputDim);
+          mat->addAtOffset(*sub, j * input_ptr->getWidth());
         }
         dstEnd = starts[i + 1] - padSize;
         end = starts[i + 1];
       }
       if (end <= begin) continue;
-      MatrixPtr src = input->subMatrix(begin, end - begin);
+      MatrixPtr src = input_ptr->subMatrix(begin, end - begin);
       MatrixPtr dst = this->subMatrix(dstBegin, dstEnd - dstBegin);
-      dst->addAtOffset(*src, j * inputDim);
+      dst->addAtOffset(*src, j * input_ptr->getWidth());
     }
   }
 }
 
-void CpuMatrix::contextProjectionBackward(MatrixPtr inputGrad,
-                                          MatrixPtr weightGrad,
+void CpuMatrix::contextProjectionBackward(Matrix* inputGrad,
+                                          Matrix* weightGrad,
                                           const IVector& sequence,
                                           int contextLength,
                                           int contextStart,
                                           size_t beginPad,
                                           bool isPadding) {
-  if (inputGrad) CHECK(dynamic_cast<CpuMatrix*>(inputGrad.get()));
-  if (weightGrad) CHECK(dynamic_cast<CpuMatrix*>(weightGrad.get()));
+  if (inputGrad) CHECK(dynamic_cast<CpuMatrix*>(inputGrad));
+  if (weightGrad) CHECK(dynamic_cast<CpuMatrix*>(weightGrad));
   CHECK(dynamic_cast<const CpuIVector*>(&sequence));
 
-  int64_t inputDim = 0;
-  int64_t dim = getWidth();
-  size_t numSequences = sequence.getSize() - 1;
-  const int* starts = sequence.getData();
-  if (inputGrad) {
-    inputDim = inputGrad->getWidth();
-  } else {
-    inputDim = weightGrad->getWidth();
-  }
-  CHECK_EQ(dim, inputDim * contextLength);
+  int64_t inputDim = inputGrad ? inputGrad->getWidth()
+                               : weightGrad ? weightGrad->getWidth() : 0;
+  CHECK_EQ(getWidth(), inputDim * contextLength);
 
+  const int* starts = sequence.getData();
+  size_t numSequences = sequence.getSize() - 1;
   for (size_t i = 0; i < numSequences; ++i) {
     for (int j = 0; j < contextLength; ++j) {
       int begin = starts[i] + contextStart + j;
@@ -3544,21 +3512,20 @@ void CpuMatrix::rowNormalizeL1(Matrix& out) {
 }
 
 /* calulate classification error */
-void CpuMatrix::classificationError(MatrixPtr output, IVectorPtr label) {
-  CHECK(dynamic_cast<CpuMatrix*>(output.get()));
-  CHECK(dynamic_cast<CpuIVector*>(label.get()));
+void CpuMatrix::classificationError(Matrix& output, IVector& label) {
+  CHECK(dynamic_cast<const CpuMatrix*>(&output));
+  CHECK(dynamic_cast<const CpuIVector*>(&label));
 
-  size_t numSamples = getHeight();
-  size_t dim = output->getWidth();
-  CHECK_EQ(label->getSize(), numSamples);
-  CHECK_EQ(output->getHeight(), numSamples);
   CHECK_EQ(getWidth(), (size_t)1);
+  size_t numSamples = getHeight();
+  CHECK_EQ(label.getSize(), numSamples);
+  CHECK_EQ(output.getHeight(), numSamples);
 
-  real* out = output->getData();
-  real* result = getData();
-  int* lbl = label->getData();
-  real maxData;
-  int maxIndex;
+  size_t dim = output.getWidth();
+  real* out = output.getData();
+  int* lbl = label.getData();
+  real maxData = 0.0;
+  int maxIndex = -1;
   for (size_t i = 0; i < numSamples; ++i) {
     CHECK_GE(lbl[i], 0);
     CHECK_LT((size_t)lbl[i], dim);
@@ -3570,7 +3537,7 @@ void CpuMatrix::classificationError(MatrixPtr output, IVectorPtr label) {
         maxData = out[i * dim + j];
       }
     }
-    result[i] = (maxIndex != lbl[i]);
+    getData()[i] = (maxIndex != lbl[i]);
   }
 }
 

paddle/math/Matrix.h

@@ -835,7 +835,7 @@ public:
    *
    * output[i] = 0 if row i is correct.
    */
-  virtual void classificationError(MatrixPtr output, IVectorPtr label) {
+  virtual void classificationError(Matrix& output, IVector& label) {
     LOG(FATAL) << "Not implemented";
   }
 
@@ -997,8 +997,8 @@ public:
     LOG(FATAL) << "Not implemeted";
   }
 
-  virtual void contextProjectionForward(MatrixPtr input,
-                                        MatrixPtr weight,
+  virtual void contextProjectionForward(Matrix& input,
+                                        Matrix* weight,
                                         const IVector& sequence,
                                         int contextLength,
                                         int contextStart,
@@ -1007,8 +1007,8 @@ public:
     LOG(FATAL) << "Not implemeted";
   }
 
-  virtual void contextProjectionBackward(MatrixPtr inputGrad,
-                                         MatrixPtr weightGrad,
+  virtual void contextProjectionBackward(Matrix* inputGrad,
+                                         Matrix* weightGrad,
                                          const IVector& sequence,
                                          int contextLength,
                                          int contextStart,
@@ -1017,14 +1017,14 @@ public:
     LOG(FATAL) << "Not implemeted";
   }
 
-  virtual void contextProjectionBackwardData(MatrixPtr inputGrad,
+  virtual void contextProjectionBackwardData(Matrix& inputGrad,
                                              const IVector& sequence,
                                              int contextLength,
                                              int contextStart) {
     LOG(FATAL) << "Not implemeted";
   }
 
-  virtual void contextProjectionBackwardWeight(MatrixPtr weightGrad,
+  virtual void contextProjectionBackwardWeight(Matrix& weightGrad,
                                                const IVector& sequence,
                                                int contextLength,
                                                int contextStart,
@@ -1373,7 +1373,7 @@ public:
   void check(std::ostream& os, Matrix& refMat, bool printDiff = true);
   void randomizeUniform();
 
-  void classificationError(MatrixPtr output, IVectorPtr label);
+  void classificationError(Matrix& output, IVector& label);
 
   void convExpand(Matrix& feature,
                   int feaImgHeight,
@@ -1487,20 +1487,20 @@ public:
                            const IVector& sequence,
                            IVector& index);
 
-  void contextProjectionForward(MatrixPtr input,
-                                MatrixPtr weight,
+  void contextProjectionForward(Matrix& input,
+                                Matrix* weight,
                                 const IVector& sequence,
                                 int contextLength,
                                 int contextStart,
                                 size_t beginPad,
                                 bool isPadding);
 
-  void contextProjectionBackwardData(MatrixPtr inputGrad,
+  void contextProjectionBackwardData(Matrix& inputGrad,
                                      const IVector& sequence,
                                      int contextLength,
                                      int contextStart);
 
-  void contextProjectionBackwardWeight(MatrixPtr weightGrad,
+  void contextProjectionBackwardWeight(Matrix& weightGrad,
                                        const IVector& sequence,
                                        int contextLength,
                                        int contextStart,
@@ -1713,16 +1713,16 @@ public:
                            const IVector& sequence,
                            IVector& index);
 
-  void contextProjectionForward(MatrixPtr input,
-                                MatrixPtr weight,
+  void contextProjectionForward(Matrix& input,
+                                Matrix* weight,
                                 const IVector& sequence,
                                 int contextLength,
                                 int contextStart,
                                 size_t beginPad,
                                 bool isPadding);
 
-  void contextProjectionBackward(MatrixPtr inputGrad,
-                                 MatrixPtr weightGrad,
+  void contextProjectionBackward(Matrix* inputGrad,
+                                 Matrix* weightGrad,
                                  const IVector& sequence,
                                  int contextLength,
                                  int contextStart,
@@ -1881,7 +1881,7 @@ public:
 
   void randomizeUniform();
 
-  void classificationError(MatrixPtr output, IVectorPtr label);
+  void classificationError(Matrix& output, IVector& label);
 
   void addByBitCode(size_t numClasses, const IVector& codes, const Matrix& vec);
 

paddle/math/tests/test_matrixCompare.cpp

@@ -65,16 +65,16 @@ void testMatrixProjectionForward(int contextStart,
 
   // calculate
   int beginPad = std::max(0, -contextStart);
-  cpuOutput->contextProjectionForward(cpuInput,
-                                      cpuWeight,
+  cpuOutput->contextProjectionForward(*cpuInput,
+                                      cpuWeight.get(),
                                       *cpuSequence,
                                       contextLength,
                                       contextStart,
                                       beginPad,
                                       padding);
 
-  gpuOutput->contextProjectionForward(gpuInput,
-                                      gpuWeight,
+  gpuOutput->contextProjectionForward(*gpuInput,
+                                      gpuWeight.get(),
                                       *gpuSequence,
                                       contextLength,
                                       contextStart,
@@ -120,17 +120,17 @@ void testMatrixProjectionBackward(int contextStart,
 
   // calculate
   int beginPad = std::max(0, -contextStart);
-  cpuOutputGrad->contextProjectionBackward(cpuInputGrad,
-                                           cpuWeightGrad,
+  cpuOutputGrad->contextProjectionBackward(cpuInputGrad.get(),
+                                           cpuWeightGrad.get(),
                                            *cpuSequence,
                                            contextLength,
                                            contextStart,
                                            beginPad,
                                            padding);
   gpuOutputGrad->contextProjectionBackwardData(
-      gpuInputGrad, *gpuSequence, contextLength, contextStart);
+      *gpuInputGrad, *gpuSequence, contextLength, contextStart);
   if (padding) {
-    gpuOutputGrad->contextProjectionBackwardWeight(gpuWeightGrad,
+    gpuOutputGrad->contextProjectionBackwardWeight(*gpuWeightGrad,
                                                    *gpuSequence,
                                                    contextLength,
                                                    contextStart,
@@ -939,8 +939,8 @@ void testClassificationError(int numSamples, int dim) {
   gpuOutput->copyFrom(*cpuOutput);
   gpuLabel->copyFrom(*cpuLabel);
 
-  cpuError->classificationError(cpuOutput, cpuLabel);
-  gpuError->classificationError(gpuOutput, gpuLabel);
+  cpuError->classificationError(*cpuOutput, *cpuLabel);
+  gpuError->classificationError(*gpuOutput, *gpuLabel);
 
   TensorCheckEqual(*cpuError, *gpuError);
 }