# Matrix

## Base

Defines

`CAL_MATRIX_START_ADDRESS`(address, height, width, ld, col, row)

  Calculate matrix element address.

  For instance, address of A[i][j] = i * ld + j.

namespace `paddle`

  Typedefs

  typedef bool_constant<bool, false> `false_type`
  typedef bool_constant<bool, true> `true_type`
  typedef BaseMatrixT<real> `BaseMatrix`
  typedef BaseMatrixT<int> `IBaseMatrix`
  template <class T, T v>
  struct `bool_constant`

    Public Static Attributes

    const T `value`
  class `MatrixOffset`

    Public Functions

    `MatrixOffset`(size_t aCol = 0, size_t aRow = 0, size_t bCol = 0, size_t bRow = 0, size_t cCol = 0, size_t cRow = 0, size_t dCol = 0, size_t dRow = 0)

    Public Members

    size_t `aCol_`
    size_t `aRow_`
    size_t `bCol_`
    size_t `bRow_`
    size_t `cCol_`
    size_t `cRow_`
    size_t `dCol_`
    size_t `dRow_`
  template <class T>
  class `BaseMatrixT`

    Subclassed by paddle::BaseVector< T >, paddle::Matrix

    Public Functions

    virtual `~BaseMatrixT`()
    `BaseMatrixT`(size_t height, size_t width, T *data, bool trans, bool useGpu)
    `BaseMatrixT`(BaseMatrixT &mat, bool useGpu)

      Note
        This constructor is for temporarily making a matrix with different useGpu flag as the original matrix so that mixed gpu/cpu operations can be performed successfully.
    `BaseMatrixT`(size_t height, size_t width, size_t stride, T *data, bool trans, bool use_gpu)
    void `setData`(T *data)

      caller should make sure that the size of data is at least height*width

    template <class Op>
    int `applyUnary`(Op op)

      unary operator: element wise op(a).

          for 0 <= i < this->height_ & for 0 <= j < this->width_.

    template <class Op>
    int `applyUnary`(Op op, int numRows, int numCols, MatrixOffset &offset)

      unary operator: element wise op(a).

          for 0 <= i < numRows & for 0 <= j < numCols.
          While matrix start address is:
           A = this->data_ + offset.aRow_*ld + offset.aCol_;

    template <class Op>
    int `applyBinary`(Op op, BaseMatrixT &b)

      binary operator: element wise op(a, b).

          for 0 <= i < this->height_ & for 0 <= j < this->width_.
          While this->height_ == b.height_ && this->width_ == b.width_.

    template <class Op, class bAsRowVector, class bAsColVector>
    int `applyBinary`(Op op, BaseMatrixT &b, int numRows, int numCols, MatrixOffset &offset, bAsRowVector, bAsColVector)

      binary operator: element wise op(a, b)

          for 0 <= i < numRows & for 0 <= j < numCols.
          While matrix start address is:
            A = this->data_ + offset.aRow_*lda + offset.aCol_;
            B = b->data_ + offset.bRow_*ldb + offset.bCol_;

          if (bAsRowVector == false_type && bAsColVector == false_type)
            op(A[i * lda + j], B[i * ldb + j])

          if (bAsRowVector == true_type && bAsColVector == false_type)
            op(A[i * lda + j], B[j])

          if (bAsRowVector == false_type && bAsColVector == true_type)
            op(A[i * lda + j], B[i * ldb])

          if (bAsRowVector == true_type && bAsColVector == true_type)
            op(A[i * lda + j], B[0])

    template <class Op>
    int `applyBinary`(Op op, BaseMatrixT &b, int numRows, int numCols, MatrixOffset &offset)
    template <class Op>
    int `applyTernary`(Op op, BaseMatrixT &b, BaseMatrixT &c)

      ternary operator: element wise op(a, b, c).

          for 0 <= i < this->height_ & for 0 <= j < this->width_.

          While this->height_ == b.height_ && this->width_ == b.width_
             && this->height_ == c.height_ && this->width_ == c.width_

    template <class Op, class cAsRowVector, class cAsColVector>
    int `applyTernary`(Op op, BaseMatrixT &b, BaseMatrixT &c, int numRows, int numCols, MatrixOffset &offset, cAsRowVector, cAsColVector)

      ternary operator: element wise op(a, b, c).

          for 0 <= i < numRows & for 0 <= j < numCols.
          While matrix start address is:

            A = this->data_ + offset.aRow_*lda + offset.aCol_;
            B = b->data_ + offset.bRow_*ldb + offset.bCol_;
            C = c->data_ + offset.cRow_*ldc + offset.cCol_;

            if (cAsRowVector == false_type && cAsColVector == false_type)
              op(A[i*lda + j], B[i*ldb + j], C[i*ldc + j])

            if (cAsRowVector == true_type && cAsColVector == false_type)
              op(A[i*lda + j], B[i*ldb + j], C[j])

            if (cAsRowVector == false_type && cAsColVector == true_type)
              op(A[i*lda + j], B[i*ldb + j], C[i*ldc])

            if (cAsRowVector == 1 && cAsColVector == 1)
              op(A[i*lda + j], B[i*ldb + j], C[0])

    template <class Op>
    int `applyTernary`(Op op, BaseMatrixT &b, BaseMatrixT &c, int numRows, int numCols, MatrixOffset &offset)
    template <class Op>
    int `applyQuaternary`(Op op, BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d)

      quaternary operator: element wise op(a, b, c, d).

          for 0 <= i < this->height_ & for 0 <= j < this->width_.

          While this->height_ == b.height_ && this->width_ == b.width_
             && this->height_ == c.height_ && this->width_ == c.width_
             && this->height_ == d.height_ && this->width_ == d.width_

    template <class Op>
    int `applyQuaternary`(Op op, BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d, int numRows, int numCols, MatrixOffset &offset)

      quaternary operator: element wise op(a, b, c, d).

          for 0 <= i < numRows & for 0 <= j < numCols.
          While matrix start address is:
             A = this->data_ + offset.aRow_*lda + offset.aCol_;
             B = b->data_ + offset.bRow_*ldb + offset.bCol_;
             C = c->data_ + offset.cRow_*ldc + offset.cCol_;
             D = d->data_ + offset.dRow_*ldd + offset.dCol_;

    template <class Agg, class Op, class Saver, class aAsRowVector, class aAsColVector>
    int `aggregate`(Agg agg, Op op, Saver sv, BaseMatrixT &b, int numRows, int numCols, MatrixOffset &offset, aAsRowVector, aAsColVector)

      a aggregate expression that apply each row(or column) of matrix b. op and sv is element wise operator.

          if (aAsRowVector == true_type && aAsColVector == false_type)
           for each column j & 0 <= i < numRows, do:
             dst = agg(op(b[i*ldb + j]))
             a[j] = sv(a[j], dst)

          if (aAsRowVector == false_type && aAsColVector == true_type)
           for each row i & 0 <= j < numCols, do:
             dst = agg(op(b[i*ldb + j]))
             a[i] = sv(a[i], dst)

    template <class Agg, class Op, class Saver, class aAsRowVector, class aAsColVector>
    int `aggregate`(Agg agg, Op op, Saver sv, BaseMatrixT &b, BaseMatrixT &c, int numRows, int numCols, MatrixOffset &offset, aAsRowVector, aAsColVector)

      a aggregate expression that apply each row(or column) of matrix b and c.

      op and sv is element wise operator.

          if (aAsRowVector == true_type && aAsColVector == false_type)
            for each column j & 0 <= i < numRows, do:
              dst = agg(op(b[i*ldb + j], c[i*ldc + j]))
              a[j] = sv(a[j], dst)

          if (aAsRowVector == false_type && aAsColVector == true_type)
            for each row i & 0 <= j < numCols, do:
              dst = agg(op(b[i*ldb + j], c[i*ldc + j]))
              a[i] = sv(a[i], dst)

    template <class Agg>
    int `applyRow`(Agg agg, BaseMatrixT &b)

      a aggregate expression that apply each row of matrix b.

          for each row i & 0 <= j < b.width_, do:
            this[i] = agg(b[i*ldb + j])

    template <class Agg, class Op, class Saver>
    int `applyRow`(Agg agg, Op op, Saver sv, BaseMatrixT &b, BaseMatrixT &c)

      a aggregate expression that apply each row of matrix b.

          for each row i & 0 <= j < b.width_, do:
            dst = agg(op(b[i*ldb + j], c[i*ldc + j])
            this[i] = sv(this[i], dst)

    template <class Agg, class Op>
    int `applyRow`(Agg agg, Op op, real scaleDest, real scaleAgg, BaseMatrixT &b, BaseMatrixT &c)
    template <class Agg, class Saver>
    int `applyRow`(Agg agg, Saver sv, BaseMatrixT &b)

      a aggregate expression that apply each row of matrix b.

          for each row i & 0 <= j < b.width_, do:
            dst = agg(b[i*ldb + j])
            this[i] = sv(this[i], dst)

    template <class Agg>
    int `applyRow`(Agg agg, real scaleDest, real scaleAgg, BaseMatrixT &b)
    template <class Agg>
    int `applyCol`(Agg agg, BaseMatrixT &b)

      a aggregate expression that apply each column of matrix b.

          for each column j & 0 <= i < b.height_, do:
            this[j] = agg(b[i*ldb + j])

    template <class Agg, class Saver>
    int `applyCol`(Agg agg, Saver sv, BaseMatrixT &b)

      a aggregate expression that apply each column of matrix b.

          for each column j & 0 <= i < b.height_, do:
            dst = agg(b[i*ldb + j])
            this[j] = sv(this[j], dst)

    template <class Agg>
    int `applyCol`(Agg agg, real scaleDest, real scaleAgg, BaseMatrixT &b)
    bool `useGpu`() const
    const T *`rowBuf`(size_t row) const
    T *`rowBuf`(size_t row)
    void `neg`()

      unary operator.

    void `exp`()
    void `pow`(T p)
    void `log`()
    void `sqrt`()
    void `square`()
    void `reciprocal`()
    void `abs`()
    void `sign`()
    void `zero`()
    void `zeroAtOffset`(int64_t columnOffset, int64_t numColumns)

          this(row, col + columnOffset) = 0 for 0 <= col < numColumns

    void `one`()
    void `subScalar`(T p)
    void `mulScalar`(T p)
    void `divScalar`(T p)
    void `assign`(T p)

          this = p

    void `add`(T p)

          this = this + p

    void `add`(T p1, T p2)

          this = this*p1 + p2

    void `clip`(T p1, T p2)

      this = this < low ? low : this

      this = this > high ? high : this

    void `biggerThanScalar`(T p)

          a = a > p ? 1.0f : 0.0f

    void `downClip`(T p)

          a = a > p ? a : p

    void `assign`(BaseMatrixT &b)

          this = b

    void `assignAtOffset`(BaseMatrixT &b, int64_t columnOffset)

          If b.width + columOffset <= this.width
           this(row, col + columnOffset) = b(row, col) for 0 <= col < b.width

          If this.width + columnOffset <= b.width
           this(row, col) = b(row, col + columnOffset) for 0 <= col < this.width

          Otherwise, FATAL

    void `add`(BaseMatrixT &b)

      this = this + b

    void `addAtOffset`(BaseMatrixT &b, int64_t columnOffset)

          If b.width + columOffset <= this.width
           this(row, col + columnOffset) += b(row, col) for 0 <= col < b.width

          If this.width + columnOffset <= b.width
           this(row, col) += b(row, col + columnOffset) for 0 <= col < this.width

          Otherwise, FATAL

    void `addColVector`(BaseMatrixT &b)
    void `addRowVector`(BaseMatrixT &b)
    void `addBias`(BaseMatrixT &b, T scale)
    void `mulRowVector`(BaseMatrixT &b)
    void `divRowVector`(BaseMatrixT &b)
    void `addP2P`(BaseMatrixT &b)
    void `add`(BaseMatrixT &b, T p)

          this = this + b*p

    void `add`(BaseMatrixT &b, T p1, T p2)

          this = p1*this + p2*b

    void `sub`(BaseMatrixT &b)

          this = this - b

    void `sub`(BaseMatrixT &b, T p)

          this = this - b*p

    void `relu`(BaseMatrixT &b)

          b = max(0, this)

    void `reluDerivative`(BaseMatrixT &b)
    void `softrelu`(BaseMatrixT &b)

          b = log(1.0 + exp(this))

    void `softreluDerivative`(BaseMatrixT &b)
    void `brelu`(BaseMatrixT &b)

          b = min(max(this, p1), p2)

    void `breluDerivative`(BaseMatrixT &b)
    void `square`(BaseMatrixT &b)

          b = this * this

    void `squareDerivative`(BaseMatrixT &b)
    void `tanh`(BaseMatrixT &b)

          b = tanh(this)

    void `tanhDerivative`(BaseMatrixT &b)
    void `scaledTanh`(BaseMatrixT &b, T p1, T p2)

          b = p1 * tanh(p2 * this)

    void `scaledTanhDerivative`(BaseMatrixT &b, T p1, T p2)
    void `reciprocal`(BaseMatrixT &b)

          b = 1.0f / this

    void `reciprocalDerivative`(BaseMatrixT &b)
    void `abs`(BaseMatrixT &b)

          b = this > 0.0f ? this : -this

    void `absDerivative`(BaseMatrixT &b)
    void `sigmoid`(BaseMatrixT &b)

          b = 1.0f / (1.0f + exp(-this))

    void `sigmoidDerivative`(BaseMatrixT &b)
    void `expDerivative`(BaseMatrixT &b)

          b = a

    void `sign`(BaseMatrixT &b)
    void `exp`(BaseMatrixT &b)
    void `pow`(BaseMatrixT &b, T p)
    void `log`(BaseMatrixT &b)
    void `sqrt`(BaseMatrixT &b)
    void `addScalar`(BaseMatrixT &b, T p)
    void `subScalar`(BaseMatrixT &b, T p)
    void `mulScalar`(BaseMatrixT &b, T p)
    void `divScalar`(BaseMatrixT &b, T p)
    void `scalarDiv`(BaseMatrixT &b, T p)
    void `invSqrt`(BaseMatrixT &b)

          this = 1.0f / sqrt(b)

    void `isEqualTo`(BaseMatrixT &b, T value)

      this = (b == value)

    void `softCrossEntropy`(BaseMatrixT &b, BaseMatrixT &c)

      ternary operator.

    void `softCrossEntropyBp`(BaseMatrixT &b, BaseMatrixT &c)
    void `binaryLabelCrossEntropy`(BaseMatrixT &b, BaseMatrixT &c)
    void `binaryLabelCrossEntropyBp`(BaseMatrixT &b, BaseMatrixT &c)
    void `add`(BaseMatrixT &b, BaseMatrixT &c)

          this = b + c

    void `add`(BaseMatrixT &b, T p1, BaseMatrixT &c, T p2)

          this = b*p1 + c*p2

    void `sub`(BaseMatrixT &b, BaseMatrixT &c)

          this = b - c

    void `sub`(BaseMatrixT &b, T p1, BaseMatrixT &c, T p2)

          this = b*p1 - c*p2

    void `add2`(BaseMatrixT &b, BaseMatrixT &c)

          this = this + b + c

    void `add2`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2, T p3)

          this = this*p1 + b*p2 + c*p3

    void `add3`(BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d, T p1, T p2, T p3)

          this = a*p1 + b*p2 + c*p3

    void `sgdUpdate`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2, T p3)

          c = p2 * c - p1 *  (b + p3 * this)
          this += mom

    void `sgdUpdate`(BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d, T p1, T p2, T p3)

          c = p2 * c - p1 * d * (b + p3 * this)
          this += mom

    void `applyL1`(T learningRate, T decayRate)

      apply L1/L2 to this

    void `applyL1`(BaseMatrixT &lr, T learningRate, T decayRate)
    void `applyL2`(T learningRate, T decayRate)
    void `applyL2`(BaseMatrixT &lr, T learningRate, T decayRate)
    void `dotMul`(BaseMatrixT &b)

          this *= b

    void `dotMul`(BaseMatrixT &b, BaseMatrixT &c)

          this = b * c

    void `dotDiv`(BaseMatrixT &b, BaseMatrixT &c)

          this = b / c

    void `dotDiv`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2)

          this = (b + p1) / (c + p2)

    void `rankLoss`(BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d)

          this = log(1 + exp(b - c)) - d * (b - c)

    void `rankLossBp`(BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d)
    void `logisticRegressionLoss`(BaseMatrixT &b, BaseMatrixT &c)

          this = log(1 + exp(b)) - c * b

    void `logisticRegressionLossBp`(BaseMatrixT &b, BaseMatrixT &c)

          this += exp(b)/(1+exp(b)) - c

    void `biggerThan`(BaseMatrixT &b, BaseMatrixT &c)

          this = b > c ? 1.0 : 0.0

    void `biggerThan`(BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT &d)

          this = ((b>c && d>0.5) || (b<c && d<0.5)) ? 1 : 0)

    void `max`(BaseMatrixT &b, BaseMatrixT &c)

          this = b>c ? b : c

    void `binaryClassificationError`(size_t destCol, BaseMatrixT &b, BaseMatrixT &c, T p)

          this[destCol] += (b>p1 == c>p1) ? 0 : 1)

    void `binaryClassificationError2`(size_t destCol, BaseMatrixT &b, BaseMatrixT &c, T p)
    void `dotMulSquare`(BaseMatrixT &b)

          this = this * b * b

    void `dotSquareMul`(BaseMatrixT &b)

          this = this * this * b

    void `dotMulSquare`(BaseMatrixT &b, BaseMatrixT &c)

          this = b * c * c

    void `dotSquareSquare`(BaseMatrixT &b, BaseMatrixT &c)

          this = b * b * c * c

    void `dotMulSquareSum`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2)

          this = this * (p1*b + p2*c)^2

    void `dotSquareSum`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2)

          this = (p1*b + p2*c)^2

    void `dotMulSum`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2)

          this=  this * (p1*b + p2*c)

    void `addSquareSum`(BaseMatrixT &b, BaseMatrixT &c, BaseMatrixT d, T p1, T p2, T p3)

          this += sqr(p1*b + p2*c + p3*d)

    void `addSquare`(BaseMatrixT &b, T p)

          this += p * sqr(b)

    void `decayAddSquare`(BaseMatrixT &b, T p1, T p2)

          this = p1 * this + p2 * sqr(b)

    void `decayAddSquareMul`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2)

          this = p1 * this + p2 * sqr(b * c)

    void `reciprocal`(BaseMatrixT &b, T p1, T p2)

          this = 1 / (p1 * b + p2)

    void `reciprocalSum`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2, T p3)

          this = 1 / (p1 * b + p2 * c + p3)

    void `copyAndClear`(BaseMatrixT &b)

          b = this; this = 0

    void `rowDotMul`(size_t destCol, BaseMatrixT &b, BaseMatrixT &c)

          this_row[destCol] += dotprod(b_row, c_row)

    void `rowDotMul2`(size_t destCol, BaseMatrixT &b, BaseMatrixT &c)
    void `addDotMulVMM`(BaseMatrixT &b, BaseMatrixT &c)

      this is vector (one row matrix)

          for each row i, do:
             this_row += dotmul(b_row_i, c_row_i)

    void `addDotMulVMM2`(BaseMatrixT &b, BaseMatrixT &c)
    void `addDotMulMMV`(BaseMatrixT &b, BaseMatrixT &c)

      c is vector (one row matrix)

          for each row i, do:
             this_row_i += dotmul(b_row_i, c_row)

    void `addDotMulMMV2`(BaseMatrixT &b, BaseMatrixT &c)
    void `addDotMul`(BaseMatrixT &b, BaseMatrixT &c, T p1, T p2)

          this = p1 * this + p2 * b * c

    void `rowScale`(size_t cCol, BaseMatrixT &b, BaseMatrixT &c)

          this_row = b_row * c_row[cCol]

    void `rowScale2`(size_t cCol, BaseMatrixT &b, BaseMatrixT &c)
    void `colScale`(size_t cRow, BaseMatrixT &b, BaseMatrixT &c)

          this_col = b_col * c_col[cRow]

    void `addColScale`(size_t cRow, BaseMatrixT &b, BaseMatrixT &c)

          this_col += b_col * c_col[cRow]

    void `addRowScale`(size_t cCol, BaseMatrixT &b, BaseMatrixT &c)

          this_row += b_row * c_row[cCol]

    void `sumRows`(BaseMatrixT &b, T scaleSum, T scaleDest)

      calculate the sum of each row of the matrix b. this_i = scaleDest * this_i + scaleSum * b_{ij}

    void `maxRows`(BaseMatrixT &b)

      calculate the maximum value of each row of the matrix b.

    void `minRows`(BaseMatrixT &b)

      calculate the minimum value of each row of the matrix b.

    void `sumCols`(BaseMatrixT &b)

      calculate the sum of each column of the matrix b.

    void `maxCols`(BaseMatrixT &b)

      calculate the maximum value of each column of the matrix b.

    void `minCols`(BaseMatrixT &b)

      calculate the minimum value of each column of the matrix b.

    void `sumCols`(BaseMatrixT &b, T scaleSum, T scaleDest)

      calculate the sum of each column of the matrix b. this_i = scaleDest * this_i + scaleSum * b_{ji}

    void `sumOfSquaredDiffs`(BaseMatrixT &b, BaseMatrixT &c, T scaleSum, T scaleDest)

      this_i = scaleDest * this_i + scaleSum * (b_{ij} - c_{ij})^2

    void `sumOfProducts`(BaseMatrixT &b, BaseMatrixT &c, T scaleSum, T scaleDest)

      this_i = scaleDest * this_i + scaleSum * b_{ij} * c_{ij}

    void `rowAdd`(size_t cCol, BaseMatrixT &b, BaseMatrixT &c, T p)

          this_row = b_row + p * ones * c_row[cCol]

    void `rowPow`(size_t cCol, BaseMatrixT &b, BaseMatrixT &c)

          this_row = pow(b_row, c_row[cCol])

    virtual bool `isSparse`() const

    Public Members

    size_t `height_`
    size_t `width_`
    size_t `stride_`
    T *`data_`
    bool `trans_`
    bool `useGpu_`

## Sparse Matrix

namespace `paddle`

  Typedefs

  typedef std::shared_ptr<Matrix> `MatrixPtr`
  typedef std::shared_ptr<GpuMatrix> `GpuMatrixPtr`
  typedef std::shared_ptr<CpuMatrix> `CpuMatrixPtr`
  typedef std::shared_ptr<GpuSparseMatrix> `GpuSparseMatrixPtr`
  typedef std::shared_ptr<CpuSparseMatrix> `CpuSparseMatrixPtr`

  Enums

  enum `SparseValueType`

    Values:

    `NO_VALUE` = 0
    `FLOAT_VALUE` = 1
  enum `SparseFormat`

    matrix sparse_format .

    nnz represents nonzero number in sparse matrix.

    SPARSE_CSR: row major matrix. length of row is height_ + 1, each element represents row start index in Matrix. length of col and value are nnz.

    SPARSE_CSC: col major matrix. length of col is width_ + 1, each element represents col start index in Matrix. length of col and value are nnz.

        for example: [0, 1, 0, 2, 0;
                      1, 0, 0, 0, 0;
                      0, 0, 0, 2, 5];
        SPARSE_CSR row   [0, 2, 3, 5];
                   col   [1, 3, 0, 3, 4];
                   value [1, 2, 1, 2, 5]
        SPARSE_CSC col   [0, 1, 2, 2, 4, 5];
                   row   [1, 0, 0, 2, 2];
                   value [1, 1, 2, 2, 5]

    Values:

    `SPARSE_CSR` = 0
    `SPARSE_CSC` = 1

  Functions

  std::ostream &`operator<<`(std::ostream &os, const Matrix &mat)
  class `Matrix`
    #include <Matrix.h>

    Copy or assignemnt constructor will share the data as opposed to making a copy of the original data. To make a copy of the orinal data, use copyFrom() instead.

    Inherits from paddle::BaseMatrixT< real >

    Subclassed by paddle::CpuMatrix, paddle::CpuSparseMatrix, paddle::GpuMatrix, paddle::GpuSparseMatrix

    Public Functions

    virtual `~Matrix`()
    void `setData`(real *data)

      set the data buffer used to hold the matrix data.

      caller should make sure that the size of data is at least sizeof(real)*height*width.

    void `setData`(real *data, size_t newHeight, size_t newWidth)

      the data should be contiguous

    size_t `getWidth`() const
    size_t `getHeight`() const
    size_t `getStride`() const
    size_t `getElementCnt`() const
    virtual real *`getData`()
    virtual const real *`getData`() const
    bool `isTransposed`() const
    bool `isContiguous`() const
    virtual int *`getRows`() const
    virtual int *`getCols`() const
    virtual SparseFormat `getFormat`() const
    virtual SparseValueType `getValueType`() const
    virtual void `add3`(MatrixPtr b)

      matrix elment-wise add

      Named add3 just because add/add2 has been used in BaseMatrix.cu and they are not virtual function.

    MemoryHandlePtr `getMemoryHandle`() const
    virtual void `zeroMem`()
    virtual void `resetOne`()
    void `setDiag`(real value)
    virtual void `copyFrom`(const Matrix &src)
    virtual void `trimFrom`(const CpuSparseMatrix &src)
    virtual void `copyFrom`(const Matrix &src, hl_stream_t stream)
    MatrixPtr `subMatrix`(size_t startRow, size_t endRow, size_t startCol, size_t endCol)
    MatrixPtr `subRowMatrix`(size_t startRow, size_t endRow)
    MatrixPtr `subColMatrix`(size_t startCol, size_t endCol)
    virtual MatrixPtr `subMatrix`(size_t startRow, size_t numRows)
    virtual MatrixPtr `subMatrix`(size_t startRow, size_t numRows, MatrixPtr dest)
    virtual void `copyFrom`(const real *src, size_t size)

      If this is GpuMatrix, src is assumed to be CPU memory

      If this is CpuMatrix, src is assumed to be CPU memory

    virtual void `copyFrom`(const real *src, const int64_t *seq)
    virtual void `copyFrom`(const IVector &src)

      convert a int vector to a real matrix.

      (1) source and dest are both in CPU.

      (2) sizes are exactly match.

    virtual void `copyByRowIndex`(Matrix &b, const IVector &rowIndex)
    virtual MatrixPtr `clone`(size_t height = 0, size_t width = 0, bool useGpu = false)

      Create a matrix with the same type (GpuMatrix, CpuMatrix, NonValueSparseMatrix, etc.) as this.

      If height and width is zero, the new matrix will have the same size as this, otherwise the new matrix will have the specified size.

    virtual real *`getRowBuf`(size_t row)
    virtual real `getElement`(size_t x, size_t y) const
    virtual real `getSum`()
    virtual void `accumulateColSum`(Matrix &src)
    virtual real `getAbsSum`()
    virtual void `resize`(size_t newHeight, size_t newWidth) = 0

      Note
        Original data may not be preserved after resize().
    virtual void `resize`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType, SparseFormat format) = 0

      Note
        This should only be used for sparse matrix.
    virtual void `setRow`(size_t row, size_t colNum, const unsigned int *cols, const real *values) = 0

      This should only be used for sparse matrix.

      Currently must be called for each row in order. The matrix is not valid until setRow is called for the last row.

    virtual MatrixPtr `getTranspose`() = 0
    virtual void `transpose`(MatrixPtr matTrans, bool memAlloc)

      hard transpose.

      allocate matTrans’ memory outside, then set memAlloc as false; else set as true.

    virtual MatrixPtr `getInverse`()
    virtual void `inverse`(MatrixPtr matInv, bool memAlloc)

      inverse.

      if allocate matInv’s memory outside, then set memAlloc as false; else set as true.

    virtual void `clear`()

      Only set all variables to 0 or NULL but not free them.

    void `reshape`(size_t height, size_t width)
    virtual void `addBias`(Matrix &b, real scale)

      add b to each sample of this.

    virtual void `addSharedBias`(Matrix &b, real scale)
    virtual void `addBias`(Matrix &b, real scale, bool sharedBias)
    virtual void `collectBias`(Matrix &a, real scale)

      add each sample from a to this.

    virtual void `collectSharedBias`(Matrix &a, real scale)
    virtual void `collectBias`(Matrix &a, real scale, bool sharedBias)
    virtual void `sequenceAvgForward`(Matrix &a, const IVector &startsPos, int mode)
    virtual void `mul`(const MatrixPtr a, const MatrixPtr b, real scaleAB, real scaleT)

          this = scaleAB*(a*b) + scaleT*this

    virtual void `addColumnVector`(const Matrix &b)

      Add a vector (column) b to matrix a, column by column.

    virtual void `addByBitCode`(size_t numClasses, const IVector &codes, const Matrix &vec)

          For j < codeLength:
            this(i, j) += vec(index(i, j), 0)
          where index(i, j) = ((codes(i) + numClasses) >> (j + 1)) - 1

    virtual void `addByBitCodeBackward`(size_t numClasses, const IVector &codes, Matrix &vec)

          For j < codeLength:
            vec(index(i, j), 0) += this(i, j)
          where index is same as the index for addByBitCode

    virtual void `mulByBitCode`(size_t numClasses, const IVector &codes, const Matrix &mat, const Matrix &input)

          For j < codeLength:
            this(i, j) += <mat.row(index(i, j)), input.row(i)>
          where index is same as the index for addByBitCode

    virtual void `mulByBitCodeBackwardWeight`(size_t numClasses, const IVector &codes, Matrix &mat, const Matrix &input)

          For j < codeLength:
            mat.row(index(i, j)) += this(i, j) * input.row(i)
          where index is same as the index for addByBitCode

    virtual void `mulByBitCodeBackwardError`(size_t numClasses, const IVector &codes, const Matrix &mat, Matrix &input)

          For j < codeLength:
            input.row(i) += this(i, j) * mat.row(index(i, j))
          where index is same as the index for addByBitCode

    virtual void `sumByBitCode`(size_t numClasses, IVector &codes, Matrix &sum, real scaleSum)

          For j < codeLength
            sum(i, 0) = scaleSum * \sum_j  bit(i, j) * this(i, j)
          where bit(i, j) = ((codes(i) + numClasses) & 2^j) ? 1 : 0

    virtual void `subByBitCode`(size_t numClasses_, IVector &codes)

          For j < codeLength
           this(i, j) -= bit(i, j)
          where bit(i, j) is same as that for sumByBitCode

    virtual void `rowSum`(Matrix &sum)

      add the sum of each row of this to mat

    virtual void `rowMax`(Matrix &max)

      set the max of each row of this to mat

    virtual void `colMax`(Matrix &max)

      set the max of each column of this to mat

    virtual void `colMax`(IVector &maxIds, Matrix &maxVal)

      Get the top k elements of each column of this matrix.

      The row ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    virtual void `maxoutForward`(Matrix &a, IVector &id, size_t channels, size_t groups)
    virtual void `maxoutBackward`(Matrix &a, IVector &id, size_t channels, size_t groups)
    virtual void `rowMaxId`(IVector &maxIds)
    virtual void `rowMax`(IVector &maxIds, Matrix &max)

      Get the top k elements of each row of this matrix.

      The column ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    virtual void `rowNormalizeL1`(Matrix &out)

      normalize each row so that the sum of each row is 1.

    virtual void `mul`(const MatrixPtr a, const MatrixPtr b)

          this = a*b

    virtual void `rightMul`(Matrix &b, real scaleAB, real scaleT)

          this = scaleAB*(this*b) +  scaleT*this

    virtual void `rightMul`(Matrix &b)

          this = this* b

    virtual void `leftMul`(Matrix &a, real scaleAB, real scaleT)

          this = scaleAB*(a*this) +  scaleT*this

    virtual void `leftMul`(Matrix &a)

          this = a*this)

    virtual void `colMerge`(Matrix &src)

      merge the element for each col.

    virtual void `oneHotCrossEntropy`(Matrix &output, IVector &label)

      copy -log(output[label]) to this->data[i].

    virtual void `oneHotCrossEntropyBp`(Matrix &outputV, IVector &label)

      calculate the error of outputV according to label.

    virtual void `oneHotCrossEntropyWithSelfNorm`(Matrix &output, IVector &label, real alpha)

      copy -log(output[label]) to this->data[i].

    virtual void `oneHotCrossEntropyWithSelfNormBp`(Matrix &outputV, IVector &label, real alpha)

      calculate the error of outputV according to label.

    virtual void `circularConv`(Matrix &b, Matrix &c)

      \[ a[i] = \sum_{j=-(N-1)/2}^{(N-1)/2} b_{i+j} * c_{j} \]

      b contains M elements, c contains N elements (N is odd), b’s index arithmetic is computed modulo M, c’s index arithmetic is computed modulo N.

    virtual void `circularConvDerivative`(Matrix &output, Matrix &prevOut1, Matrix &prevOut2, Matrix &prevGrad1, Matrix &prevGrad2)
    virtual void `softmax`(Matrix &output)
    virtual void `sequenceSoftmax`(Matrix &output, const IVector &index)
    virtual void `softmaxBackward`(Matrix &outputV)
    virtual void `softmaxDerivative`(Matrix &output, Matrix &sftmaxSum)
    virtual void `sumOfSquares`(Matrix &output, Matrix &label)

      calculate the sum of squares diff cost.

    virtual void `sumOfSquaresBp`(Matrix &outputV, Matrix &label)

      gradient of sumOfSquares.

    virtual void `tanh`(Matrix &output)
    virtual void `tanhDerivative`(Matrix &output)
    virtual void `softrelu`(Matrix &output)
    virtual void `softreluDerivative`(Matrix &output)
    virtual void `scaledTanh`(Matrix &output, real p1, real p2)
    virtual void `cosSim`(Matrix &output1, Matrix &output2, real scale = 1.0f)

      cosine similarity, for each row i, this[i] = cos(output1[i], output2[i])

      output2 can only have one row, then for each row i, this[i] = cos(output1[i], output2[0])

    virtual void `cosSimDerivative`(Matrix &output, Matrix &prevOut1, Matrix &prevOut2, Matrix &prevGrad1, Matrix &prevGrad2, real scale = 1.0f)
    virtual void `print`(std::ostream &os) const

      print out the values of elements to os

    virtual void `print`(std::ostream &os, size_t height, size_t width) const

      print a part of the matrix from the (top,left) value to the (height, width) value (not included)

    virtual void `printOneRow`(std::ostream &os, size_t idx) const

      print one row to os

    virtual void `check`(std::ostream &os, Matrix &refMat, bool printDiff = true)
    virtual real `getMin`()
    virtual real `getMax`()
    virtual void `randomizeUniform`()
    virtual void `classificationError`(MatrixPtr output, IVectorPtr label)

      calulate the error of classification

      output[i] = 1 if row i is an error.

      output[i] = 0 if row i is correct.

    virtual void `convExpand`(Matrix &feature, int feaImgHeight, int feaImgWidth, int channels, int blockH, int blockW, int strideH, int strideW, int paddingH, int paddingW, int outputH, int outputW)

      This function is used to calculate the convolution:

      It will expand a feature matrix according to the convolution filters

    virtual void `convShrink`(Matrix &expandColMat, int thisImgHeight, int thisImgWidth, int channels, int blockH, int blockW, int strideH, int strideW, int paddingH, int paddingW, int outputH, int outputW, real alpha = 1.0f, real beta = 0.0f)

      This function is the reverse implementation of convExpand:

      Its function is to restore a expanded-matrix into a feature matrix

    virtual void `maxPoolForward`(Matrix &inputMat, size_t imgSizeH, size_t imgSizeW, size_t channels, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, size_t paddingH, size_t paddingW)

      Pooling forward operation, pick out the largest element in the sizeX of value

    virtual void `maxPoolBackward`(Matrix &image, size_t imgSizeH, size_t imgSizeW, Matrix &outGrad, Matrix &outV, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, real scaleTargets, real scaleOutput, size_t paddingH, size_t paddingW)

      Pooling backward operation.

    virtual void `avgPoolForward`(Matrix &input, size_t imgSizeH, size_t imgSizeW, size_t channels, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, size_t paddingH, size_t paddingW)

      Pooling forward operation, caculate the average of sizeX elements.

    virtual void `avgPoolBackward`(Matrix &input, size_t imgSizeH, size_t imgSizeW, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, real scaleTargets, real scaleOutput, size_t paddingH, size_t paddingW)
    virtual void `crossMapNormalFwd`(Matrix &input, size_t imgSizeH, size_t imgSizeW, Matrix &denoms, size_t channels, size_t sizeX, float scale, float pow)

      normalize-operation.

    virtual void `crossMapNormalBwd`(Matrix &localGrad, Matrix &denoms, Matrix &preOutV, Matrix &localOutV, size_t channels, size_t imgSizeH, size_t imgSizeW, size_t size, float scale, float pow)
    virtual void `maxSequenceForward`(Matrix &input, const IVector &sequence, IVector &index)

      Input: one or more sequences. Each sequence contains some instances.

      Output: output size is the number of input sequences (NOT input instances).

      output[i] is set to max_input[i].

    virtual void `maxSequenceBackward`(Matrix &outputGrad, const IVector &sequence, IVector &index)
    virtual void `contextProjectionForward`(MatrixPtr input, MatrixPtr weight, const IVector &sequence, int contextLength, int contextStart, size_t beginPad, bool isPadding)
    virtual void `contextProjectionBackward`(MatrixPtr inputGrad, MatrixPtr weightGrad, const IVector &sequence, int contextLength, int contextStart, size_t beginPad, bool isPadding)
    virtual void `contextProjectionBackwardData`(MatrixPtr inputGrad, const IVector &sequence, int contextLength, int contextStart)
    virtual void `contextProjectionBackwardWeight`(MatrixPtr weightGrad, const IVector &sequence, int contextLength, int contextStart, int totalPad, size_t beginPad)
    virtual void `selectRows`(Matrix &table, IVector &ids)

          this.row[i] += table.row[ids[i]]
          if ids[i] == -1, it will be ignored

    virtual void `selectElements`(Matrix &table, IVector &ids)

          this[i] = table[i, id[i]]

    virtual void `addToRows`(Matrix &table, IVector &ids)

          table.row[ids[i]] += this.row[i]
          if ids[i] == -1, it will be ignored

    virtual void `addElements`(Matrix &table, IVector &ids)

          table[i, id[i]] += this[i]

    virtual void `multiBinaryLabelCrossEntropy`(Matrix &output, Matrix &label)

      cross entropy for multi binary labels

          this[i] = -sum(label[i][j]*log(output[i][j])
                    + (1-label[i][j])*log(1-output[i][j]))

    virtual void `multiBinaryLabelCrossEntropyBp`(Matrix &output, Matrix &label)

      The gradient of cross entropy for multi binary labels on output.

          this[i][j] = -label[i][j]/output[i][j]
                       + (1-label[i][j])/(1-output[i][j])

    virtual void `classificationErrorMulti`(Matrix &output, Matrix &label, real threshold)

      Calculate the classification error for multi binary labels.

          this[i] = sum((output[i][j] >= threshold && label[i][j] == 0)
                     || (output[i][j] < threshold && label[i][j] == 1))
                     / output->getWidth()

    virtual void `paramReluForward`(Matrix &data, Matrix &W)
    virtual void `paramReluBackwardW`(Matrix &oGrad, Matrix &data)
    virtual void `paramReluBackwardDiff`(Matrix &oGrad, Matrix &data, Matrix &W)
    virtual void `bilinearForward`(const Matrix &in, const size_t inImgH, const size_t inImgW, const size_t outImgH, const size_t outImgW, const size_t numChannels, const real ratioH, const real ratioW)
    virtual void `bilinearBackward`(const Matrix &out, const size_t outImgH, const size_t outImgW, const size_t inImgH, const size_t inImgW, const size_t numChannels, const real ratioH, const real ratioW)

    Public Members

    size_t `elementCnt_`
    MemoryHandlePtr `memoryHandle_`

    Public Static Functions

    MatrixPtr `create`(MemoryHandlePtr memHandle, size_t height, size_t width, bool trans = false)
    MatrixPtr `create`(size_t height, size_t width, bool trans = false, bool useGpu = false)
    MatrixPtr `create`(real *data, size_t height, size_t width, bool trans = false, bool useGpu = false)
    MatrixPtr `create`(real *data, size_t height, size_t width, size_t stride, bool trans = false, bool useGpu = false)
    MatrixPtr `createSparseMatrix`(size_t height, size_t width, size_t nnz, SparseValueType valueType = FLOAT_VALUE, bool trans = false, bool useGpu = false)
    MatrixPtr `createSparseMatrix`(size_t height, size_t width, size_t nnz, SparseValueType valueType = FLOAT_VALUE, SparseFormat foramt = SPARSE_CSR, bool trans = false, bool useGpu = false)
    MatrixPtr `createSparseMatrix`(real *data, int *row, int *col, size_t height, size_t width, size_t nnz, SparseValueType valueType, SparseFormat format, bool trans, bool useGpu)
    void `resizeOrCreateSparseMatrix`(MatrixPtr &matrix, size_t height, size_t width, size_t nnz, SparseValueType valueType = FLOAT_VALUE, SparseFormat foramt = SPARSE_CSR, bool trans = false, bool useGpu = false)
    void `resizeOrCreate`(MatrixPtr &a, size_t height, size_t width, bool trans = false, bool useGpu = false)

    Protected Functions

    `Matrix`(MemoryHandlePtr memHandle, size_t height, size_t width, bool trans, bool use_gpu)
    `Matrix`(real *data, size_t height, size_t width, bool trans, bool use_gpu)
    `Matrix`(real *data, size_t height, size_t width, size_t stride, bool trans, bool use_gpu)

    Protected Static Attributes

    ThreadLocal<MatrixPtr> `tmpMat_`
  class `GpuMatrix`

    Inherits from paddle::Matrix

    Public Functions

    `GpuMatrix`()
    `GpuMatrix`(size_t height, size_t width, bool trans = false)
    `GpuMatrix`(real *data, size_t height, size_t width, bool trans = false)
    `GpuMatrix`(real *data, size_t height, size_t width, size_t stride, bool trans = false)
    `GpuMatrix`(GpuMemHandlePtr dataHandle, size_t height, size_t width, bool trans = false)
    `~GpuMatrix`()
    void `zeroMem`()
    void `resetOne`()
    void `setDiag`(real value)
    void `resize`(size_t newHeight, size_t newWidth)

      Note
        Original data may not be preserved after resize().
    void `resize`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType, SparseFormat format)

      Note
        This should only be used for sparse matrix.
    void `setRow`(size_t row, size_t colNum, const unsigned int *cols, const real *values)

      This should only be used for sparse matrix.

      Currently must be called for each row in order. The matrix is not valid until setRow is called for the last row.

    void `copyFrom`(const real *hostSrc, size_t size)

      Copy the data from cpu_memory buffer

    void `copyFrom`(const real *hostSrc, const int64_t *seq)
    void `copyFrom`(const Matrix &src, hl_stream_t stream)
    void `copyFrom`(const Matrix &src)
    void `copyFrom`(const IVector &src)

      convert a int vector to a real matrix.

      (1) source and dest are both in CPU.

      (2) sizes are exactly match.

    void `copyByRowIndex`(Matrix &b, const IVector &rowIndex)
    MatrixPtr `clone`(size_t height, size_t width, bool useGpu = false)

      Create a matrix with the same type (GpuMatrix, CpuMatrix, NonValueSparseMatrix, etc.) as this.

      If height and width is zero, the new matrix will have the same size as this, otherwise the new matrix will have the specified size.

    real `getElement`(size_t x, size_t y) const
    real *`getRow`(size_t row)
    virtual real *`getRowBuf`(size_t row)
    real `getSum`()
    void `accumulateColSum`(Matrix &src)
    real `getAbsSum`()
    MatrixPtr `getTranspose`()
    void `transpose`(MatrixPtr matTrans, bool memAlloc)

      hard transpose.

      allocate matTrans’ memory outside, then set memAlloc as false; else set as true.

    MatrixPtr `getInverse`()
    void `inverse`(MatrixPtr matInv, bool memAlloc)

      inverse.

      if allocate matInv’s memory outside, then set memAlloc as false; else set as true.

    void `addBias`(Matrix &b, real scale)

      add b to each sample of this.

    void `addSharedBias`(Matrix &b, real scale)
    void `collectBias`(Matrix &a, real scale)

          add each sample from a to this.

    void `collectSharedBias`(Matrix &a, real scale)
    void `sequenceAvgForward`(Matrix &a, const IVector &startsPos, int mode)
    void `selectRows`(Matrix &table, IVector &ids)

          this.row[i] += table.row[ids[i]]

    void `selectElements`(Matrix &table, IVector &ids)

          this[i] = table[i, id[i]]

    void `addToRows`(Matrix &table, IVector &ids)

          table.row[ids[i]] += this.row[i]

    void `addColumnVector`(const Matrix &b)

      Add a vector (column) b to matrix a, column by column.

    void `mul`(const MatrixPtr a, const MatrixPtr b, real scaleAB, real scaleT)

          this = scaleAB*(a*b) + scaleT*this

    void `mul`(const MatrixPtr a, const MatrixPtr b)

          this = a*b

    void `mul`(const GpuMatrix &a, const GpuMatrix &b, real scaleAB, real scaleT)
    void `mul`(const GpuSparseMatrix &a, const GpuMatrix &b, real scaleAB, real scaleT)
    void `mul`(const GpuMatrix &a, const GpuSparseMatrix &b, real scaleAB, real scaleT)
    void `rightMul`(Matrix &b, real scaleAB, real scaleT)

          this = scaleAB*(this*b) +  scaleT*this

    void `rightMul`(Matrix &b)

          this = this* b

    void `leftMul`(Matrix &a, real scaleAB, real scaleT)

          this = scaleAB*(a*this) +  scaleT*this

    void `leftMul`(Matrix &a)

          this = a*this

    void `colMerge`(Matrix &src)

      merge the element for each col.

    void `rowSum`(Matrix &sum)

      add the sum of each row of this to mat

    void `rowMax`(Matrix &max)

      set the max of each row of this to mat

    void `rowMax`(IVector &maxIds, Matrix &max)

      Get the top k elements of each row of this matrix.

      The column ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    void `colMax`(Matrix &max)

      set the max of each column of this to mat

    void `colMax`(IVector &maxIds, Matrix &maxVal)

      Get the top k elements of each column of this matrix.

      The row ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    void `maxoutForward`(Matrix &a, IVector &id, size_t channels, size_t groups)
    void `maxoutBackward`(Matrix &a, IVector &id, size_t channels, size_t groups)
    void `oneHotCrossEntropy`(Matrix &output, IVector &label)

      copy -log(output[label]) to this->data[i].

    void `oneHotCrossEntropyBp`(Matrix &outputV, IVector &label)

      calculate the error of outputV according to label.

    void `oneHotCrossEntropyWithSelfNorm`(Matrix &output, IVector &label, real alpha)

      copy -log(output[label]) to this->data[i].

    void `oneHotCrossEntropyWithSelfNormBp`(Matrix &outputV, IVector &label, real alpha)

      calculate the error of outputV according to label.

    void `softmax`(Matrix &output)
    void `sequenceSoftmax`(Matrix &output, const IVector &index)
    void `softmaxBackward`(Matrix &outputV)
    void `softmaxDerivative`(Matrix &output, Matrix &sftmaxSum)
    void `sumOfSquares`(Matrix &output, Matrix &label)

      calculate the sum of squares diff cost.

    void `sumOfSquaresBp`(Matrix &outputV, Matrix &label)

      gradient of sumOfSquares.

    void `tanh`(Matrix &output)
    void `tanhDerivative`(Matrix &output)
    void `softrelu`(Matrix &output)
    void `softreluDerivative`(Matrix &output)
    void `scaledTanh`(Matrix &output, real p1, real p2)
    void `cosSim`(Matrix &output1, Matrix &output2, real scale)

      cosine similarity, for each row i, this[i] = cos(output1[i], output2[i])

      output2 can only have one row, then for each row i, this[i] = cos(output1[i], output2[0])

    void `cosSimDerivative`(Matrix &output, Matrix &prevOut1, Matrix &prevOut2, Matrix &prevGrad1, Matrix &prevGrad2, real scale)
    void `print`(std::ostream &os) const

      print out the values of elements to os

    void `print`(std::ostream &os, size_t height, size_t width) const

      print a part of the matrix from the (top,left) value to the (height, width) value (not included)

    void `paramReluForward`(Matrix &data, Matrix &W)
    void `paramReluBackwardW`(Matrix &oGrad, Matrix &data)
    void `paramReluBackwardDiff`(Matrix &oGrad, Matrix &data, Matrix &W)
    void `check`(std::ostream &os, Matrix &refMat, bool printDiff = true)
    void `randomizeUniform`()
    void `classificationError`(MatrixPtr output, IVectorPtr label)

      calulate the error of classification

      output[i] = 1 if row i is an error.

      output[i] = 0 if row i is correct.

    void `convExpand`(Matrix &feature, int feaImgHeight, int feaImgWidth, int channels, int blockH, int blockW, int strideH, int strideW, int paddingH, int paddingW, int outputH, int outputW)

      This function is used to calculate the convolution:

      It will expand a feature matrix according to the convolution filters

    void `convShrink`(Matrix &expandColMat, int thisImgHeight, int thisImgWidth, int channels, int blockH, int blockW, int strideH, int strideW, int paddingH, int paddingW, int outputH, int outputW, real alpha = 1.0f, real beta = 0.0f)

      This function is the reverse implementation of convExpand:

      Its function is to restore a expanded-matrix into a feature matrix

    void `maxPoolForward`(Matrix &inputMat, size_t imgSizeH, size_t imgSizeW, size_t channels, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, size_t paddingH, size_t paddingW)

      Pooling forward operation, pick out the largest element in the sizeX of value

    void `maxPoolBackward`(Matrix &image, size_t imgSizeH, size_t imgSizeW, Matrix &outGrad, Matrix &outV, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, real scaleTargets, real scaleOutput, size_t paddingH, size_t paddingW)

      Pooling backward operation.

    void `avgPoolForward`(Matrix &input, size_t imgSizeH, size_t imgSizeW, size_t channels, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, size_t paddingH, size_t paddingW)

      Pooling forward operation, caculate the average of sizeX elements.

    void `avgPoolBackward`(Matrix &input, size_t imgSizeH, size_t imgSizeW, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, real scaleTargets, real scaleOutput, size_t paddingH, size_t paddingW)
    void `crossMapNormalFwd`(Matrix &input, size_t imgSizeH, size_t imgSizeW, Matrix &denoms, size_t channels, size_t sizeX, float scale, float pow)

      normalize-operation.

    void `crossMapNormalBwd`(Matrix &localGrad, Matrix &denoms, Matrix &preOutV, Matrix &localOutV, size_t channels, size_t imgSizeH, size_t imgSizeW, size_t sizeX, float scale, float pow)
    void `maxSequenceForward`(Matrix &input, const IVector &sequence, IVector &index)

      Input: one or more sequences. Each sequence contains some instances.

      Output: output size is the number of input sequences (NOT input instances).

      output[i] is set to max_input[i].

    void `maxSequenceBackward`(Matrix &outputGrad, const IVector &sequence, IVector &index)
    void `contextProjectionForward`(MatrixPtr input, MatrixPtr weight, const IVector &sequence, int contextLength, int contextStart, size_t beginPad, bool isPadding)
    void `contextProjectionBackwardData`(MatrixPtr inputGrad, const IVector &sequence, int contextLength, int contextStart)
    void `contextProjectionBackwardWeight`(MatrixPtr weightGrad, const IVector &sequence, int contextLength, int contextStart, int totalPad, size_t beginPad)
    void `bilinearForward`(const Matrix &in, const size_t inImgH, const size_t inImgW, const size_t outImgH, const size_t outImgW, const size_t numChannels, const real ratioH, const real ratioW)
    void `bilinearBackward`(const Matrix &out, const size_t outImgH, const size_t outImgW, const size_t inImgH, const size_t inImgW, const size_t numChannels, const real ratioH, const real ratioW)
    void `multiBinaryLabelCrossEntropy`(Matrix &output, Matrix &label)

      cross entropy for multi binary labels

          this[i] = -sum(label[i][j]*log(output[i][j])
                    + (1-label[i][j])*log(1-output[i][j]))

    void `multiBinaryLabelCrossEntropyBp`(Matrix &output, Matrix &label)

      The gradient of cross entropy for multi binary labels on output.

          this[i][j] = -label[i][j]/output[i][j]
                       + (1-label[i][j])/(1-output[i][j])

  class `CpuMatrix`

    Inherits from paddle::Matrix

    Subclassed by paddle::SharedCpuMatrix, paddle::SparseRowCpuMatrix, paddle::SparseRowIdsCpuMatrix

    Public Functions

    `CpuMatrix`(size_t height, size_t width, bool trans = false)

      CpuMatrix

    `CpuMatrix`(real *data, size_t height, size_t width, bool trans = false)
    `CpuMatrix`(real *data, size_t height, size_t width, size_t stride, bool trans = false)
    `CpuMatrix`(CpuMemHandlePtr dataHandle, size_t height, size_t width, bool trans = false)
    `~CpuMatrix`()
    void `zeroMem`()
    void `resetOne`()
    void `setDiag`(real value)
    void `resize`(size_t newHeight, size_t newWidth)

      Note
        Original data may not be preserved after resize().
    void `resize`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType, SparseFormat format)

      Note
        This should only be used for sparse matrix.
    void `setRow`(size_t row, size_t colNum, const unsigned int *cols, const real *values)

      This should only be used for sparse matrix.

      Currently must be called for each row in order. The matrix is not valid until setRow is called for the last row.

    real `getElement`(size_t x, size_t y) const
    real `getSum`()
    void `accumulateColSum`(Matrix &src)
    real `getAbsSum`()
    MatrixPtr `getTranspose`()
    void `transpose`(MatrixPtr matTrans, bool memAlloc)

      hard transpose.

      allocate matTrans’ memory outside, then set memAlloc as false; else set as true.

    MatrixPtr `getInverse`()
    void `inverse`(MatrixPtr matInv, bool memAlloc)

      inverse.

      if allocate matInv’s memory outside, then set memAlloc as false; else set as true.

    void `copyFrom`(const Matrix &src)
    void `copyFrom`(const Matrix &src, hl_stream_t stream)
    void `copyFrom`(const real *src, size_t size)

      If this is GpuMatrix, src is assumed to be CPU memory

      If this is CpuMatrix, src is assumed to be CPU memory

    void `copyFrom`(const real *cpuSrc, const int64_t *seq)
    void `copyFrom`(const IVector &src)

      convert a int vector to a real matrix.

      (1) source and dest are both in CPU.

      (2) sizes are exactly match.

    void `copyFrom`(CpuSparseMatrix &src)
    void `copyByRowIndex`(Matrix &b, const IVector &rowIndex)
    MatrixPtr `clone`(size_t height, size_t width, bool useGpu = false)

      Create a matrix with the same type (GpuMatrix, CpuMatrix, NonValueSparseMatrix, etc.) as this.

      If height and width is zero, the new matrix will have the same size as this, otherwise the new matrix will have the specified size.

    void `convExpand`(Matrix &feature, int feaImgHeight, int feaImgWidth, int channels, int blockH, int blockW, int strideH, int strideW, int paddingH, int paddingW, int outputH, int outputW)

      This function is used to calculate the convolution:

      It will expand a feature matrix according to the convolution filters

    void `convShrink`(Matrix &expandColMat, int thisImgHeight, int thisImgWidth, int channels, int blockH, int blockW, int strideH, int strideW, int paddingH, int paddingW, int outputH, int outputW, real alpha = 1.0f, real beta = 0.0f)

      This function is the reverse implementation of convExpand:

      Its function is to restore a expanded-matrix into a feature matrix

    void `maxPoolForward`(Matrix &inputMat, size_t imgSizeH, size_t imgSizeW, size_t channels, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, size_t paddingH, size_t paddingW)

      Pooling forward operation, pick out the largest element in the sizeX of value

    void `maxPoolBackward`(Matrix &image, size_t imgSizeH, size_t imgSizeW, Matrix &outGrad, Matrix &outV, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, real scaleTargets, real scaleOutput, size_t paddingH, size_t paddingW)

      Pooling backward operation.

    void `avgPoolForward`(Matrix &input, size_t imgSizeH, size_t imgSizeW, size_t channels, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, size_t paddingH, size_t paddingW)

      Pooling forward operation, caculate the average of sizeX elements.

    void `avgPoolBackward`(Matrix &input, size_t imgSizeH, size_t imgSizeW, size_t sizeX, size_t sizeY, size_t strideH, size_t strideW, size_t outputH, size_t outputW, real scaleTargets, real scaleOutput, size_t paddingH, size_t paddingW)
    void `crossMapNormalFwd`(Matrix &input, size_t imgSizeH, size_t imgSizeW, Matrix &denoms, size_t channels, size_t sizeX, float scale, float pow)

      normalize-operation.

    void `crossMapNormalBwd`(Matrix &localGrad, Matrix &denoms, Matrix &preOutV, Matrix &localOutV, size_t channels, size_t imgSizeH, size_t imgSizeW, size_t sizeX, float scale, float pow)
    void `maxSequenceForward`(Matrix &input, const IVector &sequence, IVector &index)

      Input: one or more sequences. Each sequence contains some instances. Output: output size is the number of input sequences (NOT input instances). output[i] is set to max_{for each instance in this sequence}{input[i]}

    void `maxSequenceBackward`(Matrix &outputGrad, const IVector &sequence, IVector &index)
    void `contextProjectionForward`(MatrixPtr input, MatrixPtr weight, const IVector &sequence, int contextLength, int contextStart, size_t beginPad, bool isPadding)
    void `contextProjectionBackward`(MatrixPtr inputGrad, MatrixPtr weightGrad, const IVector &sequence, int contextLength, int contextStart, size_t beginPad, bool isPadding)
    real *`getRow`(size_t row)
    virtual real *`getRowBuf`(size_t row)
    void `addBias`(Matrix &b, real scale)

      add b to each sample of this.

    void `addSharedBias`(Matrix &b, real scale)
    void `collectBias`(Matrix &a, real scale)

      add each sample of a to this.

    void `collectSharedBias`(Matrix &a, real scale)
    void `sequenceAvgForward`(Matrix &a, const IVector &startsPos, int mode)
    void `selectRows`(Matrix &table, IVector &ids)

          this.row[i] += table.row[ids[i]]

    void `addToRows`(Matrix &table, IVector &ids)

          table.row[ids[i]] += this.row[i]

    void `selectElements`(Matrix &table, IVector &ids)

          this[i] = table[i, id[i]]

    void `addElements`(Matrix &table, IVector &ids)

          table[i, id[i]] += this[i]

    template <typename TableMatType>
    void `selectRowsImp`(TableMatType &table, IVector &ids)

      use abstract getRow() to get row from table.

      Define table as template instead of virtual class for performance sake. internal used by above two virtual funcs.

    template <typename TableMatType>
    void `addToRowsImp`(TableMatType &table, IVector &ids)
    void `addColumnVector`(const Matrix &b)

      Add a vector (column) b to matrix a, column by column.

    void `mul`(const MatrixPtr a, const MatrixPtr b, real scaleAB, real scaleT)

          this = scaleAB*(a*b) + scaleT*this

    void `mul`(CpuMatrix *a, CpuMatrix *b, real scaleAB, real scaleT)
    void `mul`(CpuMatrix *a, CpuSparseMatrix *b, real scaleAB, real scaleT)
    void `mul`(CpuSparseMatrix *a, CpuMatrix *b, real scaleAB, real scaleT)
    void `mul`(const MatrixPtr a, const MatrixPtr b)

          this = a*b

    void `rightMul`(Matrix &b, real scaleAB, real scaleT)

          this = scaleAB*(this*b) +  scaleT*this

    void `rightMul`(Matrix &b)

          this = this* b

    void `leftMul`(Matrix &a, real scaleAB, real scaleT)

          this = scaleAB*(a*this) +  scaleT*this

    void `leftMul`(Matrix &a)

          this = a*this)

    void `colMerge`(Matrix &src)

      merge the element for each col.

    void `rowSum`(Matrix &sum)

      add the sum of each row of this to mat

    void `rowMaxId`(IVector &maxIds)
    void `rowMax`(Matrix &max)

      set the max of each row of this to mat

    void `rowMax`(IVector &maxIds, Matrix &max)

      Get the top k elements of each row of this matrix.

      The column ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    void `colMax`(Matrix &max)

      set the max of each column of this to mat

    void `colMax`(IVector &maxIds, Matrix &maxVal)

      Get the top k elements of each column of this matrix.

      The row ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    void `maxoutForward`(Matrix &a, IVector &id, size_t channels, size_t groups)
    void `maxoutBackward`(Matrix &a, IVector &id, size_t channels, size_t groups)
    void `rowNormalizeL1`(Matrix &out)

      normalize each row so that the sum of each row is 1.

    void `oneHotCrossEntropy`(Matrix &output, IVector &label)

      copy -log(output[label]) to this->data[i].

    void `oneHotCrossEntropyBp`(Matrix &outputV, IVector &label)

      calculate the error of outputV according to label.

    void `oneHotCrossEntropyWithSelfNorm`(Matrix &output, IVector &label, real alpha)

      copy -log(output[label]) to this->data[i].

    void `oneHotCrossEntropyWithSelfNormBp`(Matrix &outputV, IVector &label, real alpha)

      calculate the error of outputV according to label.

    void `circularConv`(Matrix &b, Matrix &c)

      \[ a[i] = \sum_{j=-(N-1)/2}^{(N-1)/2} b_{i+j} * c_{j} \]

      b contains M elements, c contains N elements (N is odd), b’s index arithmetic is computed modulo M, c’s index arithmetic is computed modulo N.

    void `circularConvDerivative`(Matrix &output, Matrix &prevOut1, Matrix &prevOut2, Matrix &prevGrad1, Matrix &prevGrad2)
    void `softmax`(Matrix &output)
    void `sequenceSoftmax`(Matrix &output, const IVector &index)
    void `softmaxDerivative`(Matrix &output, Matrix &sftmaxSum)
    void `sumOfSquares`(Matrix &output, Matrix &label)

      calculate the sum of squares diff cost.

    void `sumOfSquaresBp`(Matrix &outputV, Matrix &label)

      gradient of sumOfSquares.

    void `tanh`(Matrix &output)
    void `tanhDerivative`(Matrix &output)
    void `softrelu`(Matrix &output)
    void `softreluDerivative`(Matrix &output)
    void `scaledTanh`(Matrix &output, real p1, real p2)
    void `cosSim`(Matrix &output1, Matrix &output2, real scale)

      cosine similarity, for each row i, this[i] = cos(output1[i], output2[i])

      output2 can only have one row, then for each row i, this[i] = cos(output1[i], output2[0])

    void `cosSimDerivative`(Matrix &output, Matrix &prevOut1, Matrix &prevOut2, Matrix &prevGrad1, Matrix &prevGrad2, real scale)
    void `print`(std::ostream &os) const

      print out the values of elements to os

    void `print`(std::ostream &os, size_t height, size_t width) const

      print a part of the matrix from the (top,left) value to the (height, width) value (not included)

    void `printOneRow`(std::ostream &os, size_t idx) const

      print one row to os

    void `paramReluForward`(Matrix &data, Matrix &W)
    void `paramReluBackwardW`(Matrix &oGrad, Matrix &data)
    void `paramReluBackwardDiff`(Matrix &oGrad, Matrix &data, Matrix &W)
    void `check`(std::ostream &os, Matrix &refMat, bool printDiff = true)
    real `getMin`()
    real `getMax`()
    void `randomizeUniform`()
    void `classificationError`(MatrixPtr output, IVectorPtr label)

      calulate the error of classification

      output[i] = 1 if row i is an error.

      output[i] = 0 if row i is correct.

    void `addByBitCode`(size_t numClasses, const IVector &codes, const Matrix &vec)

          For j < codeLength:
            this(i, j) += vec(index(i, j), 0)
          where index(i, j) = ((codes(i) + numClasses) >> (j + 1)) - 1

    void `addByBitCodeBackward`(size_t numClasses, const IVector &codes, Matrix &vec)

          For j < codeLength:
            vec(index(i, j), 0) += this(i, j)
          where index is same as the index for addByBitCode

    void `mulByBitCode`(size_t numClasses, const IVector &codes, const Matrix &mat, const Matrix &input)

          For j < codeLength:
            this(i, j) += <mat.row(index(i, j)), input.row(i)>
          where index is same as the index for addByBitCode

    void `mulByBitCodeBackwardWeight`(size_t numClasses, const IVector &codes, Matrix &mat, const Matrix &input)

          For j < codeLength:
            mat.row(index(i, j)) += this(i, j) * input.row(i)
          where index is same as the index for addByBitCode

    void `mulByBitCodeBackwardError`(size_t numClasses, const IVector &codes, const Matrix &mat, Matrix &input)

          For j < codeLength:
            input.row(i) += this(i, j) * mat.row(index(i, j))
          where index is same as the index for addByBitCode

    void `sumByBitCode`(size_t numClasses, IVector &codes, Matrix &sum, real scaleSum)

          For j < codeLength
            sum(i, 0) = scaleSum * \sum_j  bit(i, j) * this(i, j)
          where bit(i, j) = ((codes(i) + numClasses) & 2^j) ? 1 : 0

    void `subByBitCode`(size_t numClasses_, IVector &codes)

          For j < codeLength
           this(i, j) -= bit(i, j)
          where bit(i, j) is same as that for sumByBitCode

    void `multiBinaryLabelCrossEntropy`(Matrix &output, Matrix &label)

      cross entropy for multi binary labels

          this[i] = -sum(label[i][j]*log(output[i][j])
                    + (1-label[i][j])*log(1-output[i][j]))

    void `multiBinaryLabelCrossEntropyBp`(Matrix &output, Matrix &label)

      The gradient of cross entropy for multi binary labels on output.

          this[i][j] = -label[i][j]/output[i][j]
                       + (1-label[i][j])/(1-output[i][j])

    void `classificationErrorMulti`(Matrix &output, Matrix &label, real threshold)

      Calculate the classification error for multi binary labels.

          this[i] = sum((output[i][j] >= threshold && label[i][j] == 0)
                     || (output[i][j] < threshold && label[i][j] == 1))
                     / output->getWidth()

    void `bilinearForward`(const Matrix &in, const size_t inImgH, const size_t inImgW, const size_t outImgH, const size_t outImgW, const size_t numChannels, const real ratioH, const real ratioW)
    void `bilinearBackward`(const Matrix &out, const size_t outImgH, const size_t outImgW, const size_t inImgH, const size_t inImgW, const size_t numChannels, const real ratioH, const real ratioW)

    Public Static Functions

    void `mul`(CpuMatrix *a, CpuMatrix *b, CpuSparseMatrix *c, real scaleAB, real scaleT)
    template <typename MatBType, typename MatCType>
    void `mul`(CpuSparseMatrix *a, MatBType *b, MatCType *c, real scaleAB, real scaleT)

      c = a * b

      use abstract getRow() to get row from B,C. Define B,C as template instead of virtual class for performance sake.

  class `SharedCpuMatrix`

    Inherits from paddle::CpuMatrix

    Public Functions

    `SharedCpuMatrix`(int blockNum, size_t height, size_t width, bool trans = false)
    `SharedCpuMatrix`(int blockNum, real *data, size_t height, size_t width, bool trans = false)
    `SharedCpuMatrix`(int blockNum, CpuMemHandlePtr dataHandle, size_t height, size_t width, bool trans = false)
    `SharedCpuMatrix`(CpuMemHandlePtr dataHandle, size_t height, size_t width, bool trans = false)
    `~SharedCpuMatrix`()
    void `mul`(CpuSparseMatrix *a, CpuMatrix *b, real scaleAB, real scaleT)
    void `add`(Matrix &b, real p1, real p2)
    void `add`(real p1, real p2)

    Private Functions

    void `initShared`(int blockNum)
    void `initBlock`(int blockNum)

    Private Members

    int `blockNum_`
    std::vector<std::unique_ptr<std::mutex>> `blockLocks_`
    ThreadLocal<CpuMatrixPtr> `localBuf_`
    ThreadLocal<std::vector<int>> `localBufRows_`
    ThreadLocal<std::vector<int>> `blockSeq_`
  struct `sparse_non_value_t`

    Public Members

    unsigned int `col`
  struct `sparse_float_value_t`

    Public Members

    unsigned int `col`
    float `value`

namespace `paddle`

  Typedefs

  typedef VectorT<real> `Vector`
  typedef CpuVectorT<real> `CpuVector`
  typedef GpuVectorT<real> `GpuVector`
  typedef VectorT<int> `IVector`
  typedef CpuVectorT<int> `CpuIVector`
  typedef GpuVectorT<int> `GpuIVector`
  typedef std::shared_ptr<Vector> `VectorPtr`
  typedef std::shared_ptr<CpuVector> `CpuVectorPtr`
  typedef std::shared_ptr<GpuVector> `GpuVectorPtr`
  typedef std::shared_ptr<IVector> `IVectorPtr`
  typedef std::shared_ptr<CpuIVector> `CpuIVectorPtr`
  typedef std::shared_ptr<GpuIVector> `GpuIVectorPtr`
  typedef CpuGpuVectorT<real> `CpuGpuVector`
  typedef CpuGpuVectorT<int> `ICpuGpuVector`
  typedef std::shared_ptr<CpuGpuVector> `CpuGpuVectorPtr`
  typedef std::shared_ptr<ICpuGpuVector> `ICpuGpuVectorPtr`

  Functions

  template <class T>
  std::ostream &`operator<<`(std::ostream &os, const VectorT<T> &vec)
  template <class T>
  class `GpuVectorT`

    Inherits from paddle::VectorT< T >

    Public Functions

    `GpuVectorT`(size_t size)
    `GpuVectorT`(size_t size, GpuMemHandlePtr memHandle, size_t offset)
    `GpuVectorT`(size_t size, T *data)
    virtual MemoryHandlePtr `newMemory`(size_t size)
    void `zeroMem`()
    void `reset`(const T &value)
    void `fillSequence`()
    void `copyFrom`(const T *src, size_t size)

      copy size elements from src

      If this is GpuVector, src can be cpu or gpu memory

      If this is CpuVector, src is assumed to be cpu memory

    void `copyFrom`(const T *src, size_t size, hl_stream_t stream)

      copy size elements from src

      If this is GpuVector, src can be cpu or gpu memory

      If this is CpuVector, src is assumed to be cpu memory,

    void `copyFrom`(const VectorT<T> &src)

      This function will crash if the size of src and dest is different.

    void `copyFrom`(const VectorT<T> &src, hl_stream_t stream)

      If use_gpu, this function will push the copy-task to the specifed-stream and return immediately.

      If not use GPU, this function is same as the copyFrom(const VectorT<T>& src), which use stream HPPL_STREAM_DEFAULT.

    T `getElement`(size_t i) const

      Get the value for the i’th element.

    void `setElement`(size_t i, const T &value)
    T *`getPoint`(const uint64_t beginPos)

      Get the buffer point with beginPos.

    virtual T `getAbsSum`()
    virtual T `getSum`()
    virtual T `getMax`()
    virtual T `getAbsMax`()
    virtual T `getMin`()
    void `isEqualTo`(const VectorT<T> &b, const T &value)

      element-wise calc: this = (b == value)

    void `selectFrom`(const VectorT<T> &src, const VectorT<int> &ids)

      select elements indexed by ids from vector src

    void `histogram`(std::ostream &os, int type)

      print histogram of vector values

      Note
        only exponent histogram supported currently
    virtual void `rand`()

      generate uniform random value for each element

    virtual void `rand`(size_t classes)

      generate uniform random value for each element, data range is from 0 to (classes - 1).

    void `randnorm`(real mean, real standardDeviation)

      generate univariate Gaussian distributed random numbers with given mean and standardDeviation.

    void `uniform`(real left, real right)

      generate uniform distributed random numbers with given range.

    T `get`(size_t pos)

      Debug use only. Very inefficient for GPU vector. get the value at pos.

    virtual void `print`(std::ostream &os, size_t num) const

      print the first “num” elements of the Vector

    virtual void `printOneElement`(std::ostream &os, size_t idx) const

      print the “idx” element of the Vector

    Protected Functions

    void `copyTo`(CpuVectorT<T> *dest) const
    void `copyTo`(GpuVectorT<T> *dest) const
  template <class T>
  class `CpuVectorT`

    Inherits from paddle::VectorT< T >

    Subclassed by paddle::ParallelCpuVectorT< T >

    Public Functions

    `CpuVectorT`(size_t size)
    `CpuVectorT`(size_t size, MemoryHandlePtr memoryHandle, size_t offset)
    `CpuVectorT`(size_t size, T *data)
    `CpuVectorT`(const VectorT<T> &src)

      If src is a CpuVector, the new CpuVector will share the data with src

      If src is a GpuVector, the new CpuVector will copy data from src

    virtual MemoryHandlePtr `newMemory`(size_t size)
    void `zeroMem`()
    void `reset`(const T &value)
    void `fillSequence`()
    void `copyFrom`(const T *src, size_t size)

      copy size elements from src

      If this is GpuVector, src can be cpu or gpu memory

      If this is CpuVector, src is assumed to be cpu memory

    void `copyFrom`(const T *src, size_t size, hl_stream_t stream)

      copy size elements from src

      If this is GpuVector, src can be cpu or gpu memory

      If this is CpuVector, src is assumed to be cpu memory,

    void `copyFrom`(const VectorT<T> &src)

      This function will crash if the size of src and dest is different.

    void `copyFrom`(const VectorT<T> &src, hl_stream_t stream)

      If use_gpu, this function will push the copy-task to the specifed-stream and return immediately.

      If not use GPU, this function is same as the copyFrom(const VectorT<T>& src), which use stream HPPL_STREAM_DEFAULT.

    void `copyTo`(CpuVectorT<T> *dest) const
    void `copyTo`(GpuVectorT<T> *dest) const
    virtual T *`getPoint`(const uint64_t beginPos)

      Get the buffer point with beginPos.

    virtual T `getElement`(size_t i) const

      Get the value for the i’th element.

    virtual void `setElement`(size_t i, const T &value)
    T `getAbsSum`()
    T `getSum`()
    T `getMax`()
    T `getAbsMax`()
    T `getMin`()
    void `isEqualTo`(const VectorT<T> &b, const T &value)

      element-wise calc: this = (b == value)

    void `selectFrom`(const VectorT<T> &src, const VectorT<int> &ids)

      select elements indexed by ids from vector src

    void `histogram`(std::ostream &os, int type)

      print histogram of vector values

      Note
        only exponent histogram supported currently
    virtual void `rand`()

      generate uniform random value for each element

    virtual void `rand`(size_t classes)

      generate uniform random value for each element, data range is from 0 to (classes - 1).

    void `randnorm`(real mean, real standardDeviation)

      generate univariate Gaussian distributed random numbers with given mean and standardDeviation.

    void `uniform`(real left, real right)

      generate uniform distributed random numbers with given range.

    T `get`(size_t pos)

      Debug use only. Very inefficient for GPU vector. get the value at pos.

    virtual void `print`(std::ostream &os, size_t num) const

      print the first “num” elements of the Vector

    virtual void `printOneElement`(std::ostream &os, size_t idx) const

      print the “idx” element of the Vector

  template <class T>
  class `BaseVector`

    Inherits from paddle::BaseMatrixT< T >

    Subclassed by paddle::VectorT< T >

    Public Functions

    `BaseVector`(size_t size, T *data, bool useGpu)
    `~BaseVector`()

    Protected Attributes

    size_t &`size_`
  template <class T>
  class `VectorT`
    #include <Vector.h>

    Copy or assignemnt constructor will share the data as opposed to making a copy of the original data. To make a copy of the orinal data, use copyFrom() instead.

    Inherits from paddle::BaseVector< T >

    Subclassed by paddle::CpuVectorT< T >, paddle::GpuVectorT< T >

    Public Types

    enum `HistogramType`

      Values:

      `HISTOGRAM_EXPONENT` = 0

    Public Functions

    virtual `~VectorT`()
    size_t `getSize`() const
    const T *`getData`() const
    T *`getData`()
    virtual void `zeroMem`() = 0
    virtual void `reset`(const T &value) = 0
    virtual void `fillSequence`() = 0
    MemoryHandlePtr `getMemoryHandle`() const
    void `resize`(size_t newSize)

      resizing to a big vector will not preserve old values.

    virtual MemoryHandlePtr `newMemory`(size_t size) = 0
    void `subVecFrom`(const VectorT<T> &src, size_t start, size_t size)

      form sub vector from src, shallow copy

    std::shared_ptr<VectorT<T>> `subVec`(size_t start, size_t size)
    void `subVecFrom`(const T *src, size_t start, size_t size)

      form sub vector from src, shallow copy

    void `subVecFrom`(const VectorT<T> &src, std::pair<size_t, size_t> interval)

      form sub vector from src, shallow copy in interval [interval.first, interval.second)

    std::shared_ptr<Matrix> `toOneHotSparseMatrix`(size_t idRange, bool useGpu)

      convert the vector to a sparse one_hot matrix of width idRange only applies to IVector

    virtual void `copyFrom`(const VectorT<T> &src) = 0

      This function will crash if the size of src and dest is different.

    virtual void `copyFrom`(const VectorT<T> &src, hl_stream_t stream) = 0

      If use_gpu, this function will push the copy-task to the specifed-stream and return immediately.

      If not use GPU, this function is same as the copyFrom(const VectorT<T>& src), which use stream HPPL_STREAM_DEFAULT.

    virtual void `copyFrom`(const T *src, size_t size) = 0

      copy size elements from src

      If this is GpuVector, src can be cpu or gpu memory

      If this is CpuVector, src is assumed to be cpu memory

    virtual void `copyFrom`(const T *src, size_t size, hl_stream_t stream) = 0

      copy size elements from src

      If this is GpuVector, src can be cpu or gpu memory

      If this is CpuVector, src is assumed to be cpu memory,

    virtual void `exec`(SyncThreadPool::JobFunc func)

      exec a func in single/multi thread

    virtual T *`getPoint`(const uint64_t beginPos) = 0

      Get the buffer point with beginPos.

    virtual T `getElement`(size_t i) const = 0

      Get the value for the i’th element.

    virtual void `setElement`(size_t i, const T &value) = 0
    virtual T `getAbsSum`() = 0
    virtual T `getSum`() = 0
    virtual T `getMax`() = 0
    virtual T `getAbsMax`() = 0
    virtual T `getMin`() = 0
    virtual void `isEqualTo`(const VectorT<T> &b, const T &value) = 0

      element-wise calc: this = (b == value)

    virtual void `selectFrom`(const VectorT<T> &src, const VectorT<int> &ids) = 0

      select elements indexed by ids from vector src

    virtual void `histogram`(std::ostream &os, int type = HISTOGRAM_EXPONENT) = 0

      print histogram of vector values

      Note
        only exponent histogram supported currently
    virtual void `rand`() = 0

      generate uniform random value for each element

    virtual void `rand`(size_t classes) = 0

      generate uniform random value for each element, data range is from 0 to (classes - 1).

    virtual T `get`(size_t pos) = 0

      Debug use only. Very inefficient for GPU vector. get the value at pos.

    virtual void `randnorm`(real mean, real standardDeviation) = 0

      generate univariate Gaussian distributed random numbers with given mean and standardDeviation.

    virtual void `uniform`(real left, real right) = 0

      generate uniform distributed random numbers with given range.

    virtual void `print`(std::ostream &os, size_t num) const = 0

      print the first “num” elements of the Vector

    virtual void `printOneElement`(std::ostream &os, size_t idx) const = 0

      print the “idx” element of the Vector

    Public Static Functions

    std::shared_ptr<VectorT<T>> `create`(size_t size, bool useGpu)
    std::shared_ptr<VectorT<T>> `create`(T *data, size_t size, bool useGpu)
    std::shared_ptr<VectorT<T>> `create`(size_t size, MemoryHandlePtr memoryHandle, size_t offset = 0)
    std::shared_ptr<VectorT<T>> `createParallelVector`(size_t size, bool useGpu, SyncThreadPool *pool = nullptr)
    static void `resizeOrCreate`(std::shared_ptr<VectorT<T>> &vec, size_t size, bool useGpu)

    Protected Functions

    `VectorT`(size_t size, MemoryHandlePtr memoryHandle, size_t offset, bool useGpu)
    `VectorT`(size_t size, T *data, bool useGpu)
    virtual void `copyTo`(CpuVectorT<T> *dest) const = 0
    virtual void `copyTo`(GpuVectorT<T> *dest) const = 0

    Protected Attributes

    MemoryHandlePtr `memoryHandle_`

    Friends

    friend `paddle::GpuVectorT< T >`
    friend `paddle::CpuVectorT< T >`
  template <class T>
  class `ParallelCpuVectorT`

    Inherits from paddle::CpuVectorT< T >

    Public Functions

    `ParallelCpuVectorT`(size_t size, SyncThreadPool *pool)
    virtual void `zeroMem`()
    virtual void `randnorm`(real mean, real standardDeviation)

      generate univariate Gaussian distributed random numbers with given mean and standardDeviation.

    virtual void `uniform`(real left, real right)

      generate uniform distributed random numbers with given range.

    void `exec`(SyncThreadPool::JobFunc func)

      exec a func in single/multi thread

    Private Types

    typedef std::function<void(CpuVectorT<T> &vec)> `ExecFunc`

    Private Functions

    void `parallelExec`(ExecFunc func)

    Private Members

    SyncThreadPool *`pool_`
  template <class T>
  class `CpuGpuVectorT`
    #include <Vector.h>

    A class to do conversion between CpuVector and GpuVector automatically.

    Public Types

    enum `SyncedFlag`

      An enum type of SyncedFlag using to mark data memory is in CPU or GPU.

      DATA_AT_CPU: data is located in CPU.

      DATA_AT_GPU: data is located in GPU.

      SYNCED: data is located in CPU and GPU simultaneously.

      Values:

      `DATA_AT_CPU` = 0
      `DATA_AT_GPU` = 1
      `SYNCED` = 2

    Public Functions

    `CpuGpuVectorT`(size_t size, bool useGpu)

      A constructor, create cpuVectorT_ or gpuVectorT_.

      Parameters
        - `size`: data size.
        - `useGpu`: use gpu or not.
    `CpuGpuVectorT`(const std::shared_ptr<VectorT<T>> &src)

      A constructor, create CpuGpuVectorT by VectorT.

      If src is CpuVector, cpuVectorT_ is shared data with src.

      If src is GpuVector, gpuVectorT_ is shared data with src.

    `CpuGpuVectorT`(size_t size, T *data, bool useGpu)

      A constructor.

      If useGpu is true, data should be located in device and create gpuVectorT_ with data.

      If useGpu is false, data should be located in host and create cpuVectorT_ with data.

      Note
        Data is owned by the caller and should be valid during the life of this vector. Caller is responsible for release the memory.
    `CpuGpuVectorT`(CpuGpuVectorT<T> &src, size_t offset, size_t size)
    virtual `~CpuGpuVectorT`()
    void `resize`(size_t size, bool useGpu)

      resize vector.

      If useGpu is true, resize gpuVectorT_ and set syncFlag_ to DATA_AT_GPU,

      otherwise resize cpuVectorT_ and set syncFlag_ to DATA_AT_CPU.

    std::shared_ptr<const VectorT<T>> `getVector`(bool useGpu) const

      return a const cpuVectorT_ or gpuVectorT_.

      If useGpu is true, return gpuVectorT_.

      If useGpu is false, return cpuVectorT_.

      Note
        Caller should not change the data. If caller changes const attribute, should set syncFlag_.
    std::shared_ptr<VectorT<T>> &`getMutableVector`(bool useGpu)

      return a const cpuVectorT_ or gpuVectorT_.

      Note
        : This interface will change syncFlag_, so if you will not change the data, you should call getVector.
    const T *`getData`(bool useGpu) const

      return const T* data.

      If useGpu is true, return device data.

      If useGpu is false, return host data.

    T *`getMutableData`(bool useGpu)
    void `zeroMem`(bool useGpu)

      If useGpu is true, gpuVectorT_->Op().

      If useGpu is false, cpuVectorT_->Op().

      Op is zeroMem, fillSequence, ...

    void `fillSequence`(bool useGpu)
    void `setElement`(size_t i, const T &value, bool useGpu)
    T `getElement`(size_t i) const

      return i-th element.

    size_t `getSize`() const

      return vector size.

    void `copyToCpu`(const T *data, size_t size)

      copy data to cpuVectorT_.

    void `copyToCpu`(const T *data, size_t size, hl_stream_t stream)

      copy data to cpuVectorT_ using specifed-stream.

    void `copyToGpu`(const T *data, size_t size)

      copy data to gpuVectorT_.

    void `copyToGpu`(const T *data, size_t size, hl_stream_t stream)

      copy data to gpuVectorT_ using specifed-stream.

    void `copyFrom`(const VectorT<T> &src, hl_stream_t stream)

      copy from src using specifed-stream.

      If src is CpuVectorT, copy to cpuVectorT_.

      If src is GpuVectorT, copy to gpuVectorT_.

    void `copyFrom`(const T *data, size_t size, bool useGpu)

      copy data.

      If useGpu is false, copy host data to cpuVectorT_.

      If useGpu is true, copy device data to gpuVectorT_.

      Note
        data address should consistent with useGpu.
    void `copyFrom`(const T *data, size_t size, hl_stream_t stream, bool useGpu)
    void `copyFrom`(CpuGpuVectorT<T> &src, size_t offset, size_t size, bool useGpu, hl_stream_t stream)

      copy from (src + offset) using specifed-stream.

    void `copyFrom`(CpuGpuVectorT<T> &src, hl_stream_t stream)

      copy from src using specifed-stream.

    SyncedFlag *`getSync`() const

      return sync_.

    void `setSync`(SyncedFlag *sync)

      set sync_.

    void `setSync`(SyncedFlag syncFlag)
    void `setSync`(bool useGpu)

    Public Static Functions

    std::shared_ptr<CpuGpuVectorT<T>> `create`(size_t size, bool useGpu)
    void `resizeOrCreate`(std::shared_ptr<CpuGpuVectorT<T>> &vec, size_t size, bool useGpu)

      resize or create CpuGpuVectorT.

    Protected Functions

    void `resizeOrCreate`(size_t size, bool useGpu)
    void `copyToCpu`()

      copy between cpuVectorT_ and gpuVectorT_.

      If syncFlag_ is DATA_AT_CPU and SYNCED, do nothing.

      If syncFlag_ is DATA_AT_GPU, copy gpuVectorT_ to cpuVectorT_ and set syncFlag_ to SYNCED.

    void `copyToGpu`()

      copy between cpuVectorT_ and gpuVectorT_.

      If syncFlag_ is DATA_AT_GPU and SYNCED, do nothing.

      If syncFlag_ is DATA_AT_CPU, copy cpuVectorT_ to gpuVectorT_ and set syncFlag_ to SYNCED.

    Protected Attributes

    std::shared_ptr<VectorT<T>> `cpuVectorT_`

      host pointer.

    std::shared_ptr<VectorT<T>> `gpuVectorT_`

      device pointer.

    SyncedFlag `syncFlag_`

      specify current data address.

    SyncedFlag *`sync_`

namespace `paddle`

  Typedefs

  typedef std::shared_ptr<_hl_sparse_matrix_s> `hl_sparse_matrix_s_ptr`
  class `GpuSparseMatrix`

    Inherits from paddle::Matrix

    Public Functions

    `GpuSparseMatrix`(size_t height, size_t width, size_t nnz, SparseValueType valueType = FLOAT_VALUE, SparseFormat format_ = SPARSE_CSR, bool trans = false)
    `GpuSparseMatrix`(GpuMemHandlePtr dataHandle, hl_sparse_matrix_s_ptr sMatrix, size_t height, size_t width, size_t nnz, SparseValueType valueType = FLOAT_VALUE, SparseFormat format_ = SPARSE_CSR, bool trans = false, MemoryHandlePtr sMemoryHandle = NULL)
    `GpuSparseMatrix`(real *value, int *rows, int *cols, size_t height, size_t width, size_t nnz, SparseValueType valueType, SparseFormat format, bool trans)
    `GpuSparseMatrix`(hl_sparse_matrix_s_ptr sMatrix, size_t height, size_t width, size_t nnz, SparseValueType valueType, SparseFormat format, bool trans, MemoryHandlePtr sMemoryHandle)
    `~GpuSparseMatrix`()
    void `resize`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType, SparseFormat format)

      Note
        This should only be used for sparse matrix.
    void `resize`(size_t newHeight, size_t newWidth)

      Note
        Original data may not be preserved after resize().
    void `sparseResizeCSR`()
    void `sparseResizeCSC`()
    void `resizeCSR`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType)
    void `resizeCSC`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType)
    void `mul`(const GpuMatrixPtr a, const GpuMatrixPtr b, real scaleAB, real scaleT)
    MatrixPtr `getTranspose`()

      B = A , B.trans = !A.trans.

    void `transpose`(MatrixPtr matTrans, bool memAlloc)

      B = A’.

    void `copyFrom`(const Matrix &src)
    void `copyFrom`(const Matrix &src, hl_stream_t stream)
    void `copyFromCSR`(CpuSparseMatrix &src, hl_stream_t stream)
    void `copyFromCSC`(CpuSparseMatrix &src, hl_stream_t stream)
    void `copyFrom`(const IVector &src)

      convert a int vector to a real matrix.

      (1) source and dest are both in CPU.

      (2) sizes are exactly match.

    void `copyFrom`(const IVector &src, hl_stream_t stream)
    template <class T>
    void `copyFrom`(int64_t *ids, int64_t *indices, T *data, hl_stream_t stream)
    void `setRow`(size_t row, size_t colNum, const unsigned int *cols, const real *values)

      This should only be used for sparse matrix.

      Currently must be called for each row in order. The matrix is not valid until setRow is called for the last row.

    SparseValueType `getValueType`() const
    SparseFormat `getFormat`() const
    const int *`getRowCols`(size_t x) const
    const real *`getRowValues`(size_t x) const
    size_t `getColNum`(size_t x) const
    void `print`(std::ostream &os) const

      print out the values of elements to os

    void `zeroMem`()

      only set value_ of FLOAT_VALUE sparse matrix to zero

    void `add3`(GpuMatrix *b)

      sparseMatrix += denseMatrix

      Named add3 just because add/add2 has been used in BaseMatrix.cu and they are not virtual function.

      Only add value of same (row, col) index in dense matrix and do not use others values.

      Parameters
        - `b`: dense matrix
    void `add3`(MatrixPtr b)

      matrix elment-wise add

      Named add3 just because add/add2 has been used in BaseMatrix.cu and they are not virtual function.

    void `addBias`(Matrix &b, real scale)

      sparseMatrix[i,j] += bias[j], (j is the col index of sparse matrix)

      Parameters
        - `b`: bias, dense matrix and height = 1
        - `scale`: scale of b
    int *`getRows`() const

      return rows, which is gpu address

    int *`getCols`() const

      return cols, which is gpu address

    real *`getValue`() const

      return value, which is gpu address

    real *`getData`()

      return value_ of sparse matrix

      Some times CpuSparseMatrix maybe Matrix, if getValue, must dynamic_cast to CpuSparseMatrix, getData is convenient to get value

    const real *`getData`() const
    void `rowMax`(IVector &maxIds, Matrix &maxVal)

      Get top k value of each row in sparse matrix.

      Store the value in maxVal and theirs index in maxIds. k = maxVal.width

      Parameters
        - `maxIds`: index of top k
        - `maxVal`: value of top k
    void `mul`(const MatrixPtr a, const MatrixPtr b, real scaleAB, real scaleT)

          this = scaleAB*(a*b) + scaleT*this

    void `copyFrom`(CpuSparseMatrix &src, hl_stream_t stream)
    void `copyFrom`(GpuSparseMatrix &src, hl_stream_t stream)
    void `trimFrom`(const CpuSparseMatrix &src)
    void `trimFromCSR`(const CpuSparseMatrix &src)
    void `trimFromCSC`(const CpuSparseMatrix &src)
    bool `isSparse`() const

    Public Members

    MemoryHandlePtr `sMemoryHandle_`
    int *`rows_`
    int *`cols_`
    real *`value_`
    const char *`end_`
    hl_sparse_matrix_s_ptr `sMatrix_`
    SparseValueType `valueType_`
    SparseFormat `format_`

    Protected Functions

    void `sparseResize`()
    void `copyRow`(int offsets, size_t colNum, const sparse_non_value_t *row)
    void `copyRow`(int offsets, size_t colNum, const sparse_float_value_t *row)
    struct `Element`

      Public Functions

      `Element`(int rowIn, int colIn, real valIn)

      Public Members

      int `row`
      int `col`
      real `val`

Functions

`P_DECLARE_bool`(allow_inefficient_sparse_update)

namespace `paddle`
  class `SparseRowCpuMatrix`
    #include <SparseRowMatrix.h>

    Sparse Row

    Inherits from paddle::CpuMatrix

    Subclassed by paddle::SparseAutoGrowRowCpuMatrix, paddle::SparsePrefetchRowCpuMatrix

    Public Types

    typedef std::shared_ptr<IndexDict> `IndexDictPtr`

    Public Functions

    `SparseRowCpuMatrix`(CpuMemHandlePtr dataHandle, size_t height, size_t width, IndexDictPtr indexDictHandle = nullptr, bool trans = false)

      heightStore is max number of rows of the sparse matrix.

    virtual `~SparseRowCpuMatrix`()
    real *`getRow`(size_t row)

      Get the row buf

      Parameters
        - `row`: row id in the original matrix
    real *`getLocalRow`(size_t row)

      Get the row buf

      Parameters
        - `row`: row id in local storage
    void `reserveStore`()

      reserve the storage for rows according to current size of indexDictHandle.

      This is only used when SparseRowCpuMatrix is constructed with indexDictHandle.

    virtual real *`getRowBuf`(size_t row)
    void `mul`(CpuSparseMatrix *a, CpuMatrix *b, real scaleAB, real scaleT)
    void `copyFrom`(const real *src, size_t size)

      Fill data according to row indexs added, setup indices inside.

      src and size are data and size of normal dense CpuMatrix.

    void `zeroMem`()
    void `applyL1Decay`(real learningRate, real decayRate)

      apply L1 to all sparse rows, should be apply after indices ready.

    void `clearIndices`()
    void `zeroMemThread`(size_t tid, size_t numThreads)
    void `sgdUpdate`(BaseMatrix &value, IVector &t0, real learningRate, int currentTime, real decayRate, bool useL1, bool fini = false)

      value -= grad * learningRate, this is gradient.

      If L1 decay set use L1, else if L2 set use L2, otherwise no decay atall.

      t0 is a int vector used by L1/L2 decay, size = height of parameter matrix, store the time that each weight row last updated.

      Time is batchId, currentTime is current batchId.

      While pass finished, caller should call this func one more time with (fini=true) to let weight decay catch up current time.

    void `addTo`(BaseMatrix &dest, std::vector<uint32_t> &ids, size_t tid, size_t numThreads)

      merge rows in this to dest for designated thread

      values add to dest matrix

      ids occured in this append to ids filtered by (id % numThreads == tid)

    void `addTo`(SparseRowCpuMatrix &dest, size_t tid, size_t numThreads)

      the second version addTo(), dest is a SparseRowCpuMatrix.

      The dest’s indices should be setup already, addTo() will check src ids is exist in dest’s indices.

    const IndexDictPtr &`getIndexDictHandle`() const
    void `checkIndices`()

      check all local and global indices consistency

    void `checkIndex`(size_t i)

      check whether row i exist in indices

    std::vector<unsigned int> &`getLocalIndices`() const

    Protected Functions

    template <typename Func>
    void `apply`(Func f)
    void `init`(size_t height, size_t width)
    void `clearRows`()

      clear row indices.

    void `checkStoreSize`()

    Protected Attributes

    CpuMatrix `storeMat_`
    std::vector<real, AlignedAllocator<real, 32>> `rowStore_`
    IndexDictPtr `indexDictHandle_`
    std::vector<unsigned int> *`localIndices_`
    unsigned int *`globalIndices_`

    Protected Static Attributes

    const unsigned int `kUnusedId_`
    struct `IndexDict`

      Public Members

      std::vector<unsigned int> `localIndices`
      std::vector<unsigned int> `globalIndices`
  class `SparsePrefetchRowCpuMatrix`
    #include <SparseRowMatrix.h>

    For prefetching parameters from remote Parameter server.

    Inherits from paddle::SparseRowCpuMatrix

    Public Functions

    `SparsePrefetchRowCpuMatrix`(CpuMemHandlePtr dataHandle, size_t height, size_t width, IndexDictPtr indexDictHandle = nullptr, SyncThreadPool *pool = nullptr, bool trans = false)
    void `addRows`(MatrixPtr input)

      Extract feature ids from input, to fill row indexs.

      input must be sparse matrix.

      Can call many times before setup.

    void `addRows`(IVectorPtr ids)
    void `setupIndices`()

      setup global indices of SparseRowMatrix after finish add rows.

    Protected Functions

    void `addRows`(const unsigned int *ids, size_t len)

    Protected Attributes

    SyncThreadPool *`pool_`
  class `SparseAutoGrowRowCpuMatrix`

    Inherits from paddle::SparseRowCpuMatrix

    Subclassed by paddle::CacheRowCpuMatrix

    Public Functions

    `SparseAutoGrowRowCpuMatrix`(size_t height, size_t width, IndexDictPtr indexDictHandle = nullptr, bool trans = false)
    real *`getRow`(size_t row)
    virtual real *`getRowBuf`(size_t row)
    void `mul`(CpuSparseMatrix *a, CpuMatrix *b, real scaleAB, real scaleT)
  class `CacheRowCpuMatrix`

    Inherits from paddle::SparseAutoGrowRowCpuMatrix

    Public Functions

    `CacheRowCpuMatrix`(size_t height, size_t width, IndexDictPtr indexDictHandle = nullptr, bool trans = false)
    void `setSourceData`(CpuVectorPtr sourceVec)
    real *`getRow`(size_t row)
    virtual real *`getRowBuf`(size_t row)
    void `mul`(CpuSparseMatrix *a, CpuMatrix *b, real scaleAB, real scaleT)

    Public Members

    CpuVectorPtr `sourceDataVec_`
    real *`sourceData_`
  class `SparseRowIdsCpuMatrix`
    #include <SparseRowMatrix.h>

    Sparse Row Ids Matrix.

    mostly same as CpuMatrix, but maintain sparse row ids occured, ids are hashed by worker thread id.

    Inherits from paddle::CpuMatrix

    Public Functions

    `SparseRowIdsCpuMatrix`(CpuMemHandlePtr dataHandle, size_t height, size_t width, bool trans = false)
    void `setNumOfThreads`(size_t numOfThreads)
    std::vector<uint32_t> &`getIds`(size_t threadId)

    Private Members

    std::vector<std::vector<uint32_t>> `idsArray_`

namespace `paddle`
  class `CpuSparseMatrix`

    Inherits from paddle::Matrix

    Public Functions

    `CpuSparseMatrix`(size_t height, size_t width, size_t nnz, SparseValueType valueType = FLOAT_VALUE, SparseFormat format = SPARSE_CSR, bool trans = false)
    `CpuSparseMatrix`(CpuMemHandlePtr memHandle, size_t height, size_t width, size_t nnz, SparseValueType valueType, SparseFormat format, bool trans)
    `CpuSparseMatrix`(real *data, int *rows, int *cols, size_t height, size_t width, size_t nnz, SparseValueType valueType, SparseFormat format, bool trans)
    `~CpuSparseMatrix`()
    void `resize`(size_t newHeight, size_t newWidth, size_t newNnz, SparseValueType valueType, SparseFormat format)

      Note
        This should only be used for sparse matrix.
    void `resize`(size_t newHeight, size_t newWidth)

      Note
        Original data may not be preserved after resize().
    MatrixPtr `getTranspose`()
    SparseValueType `getValueType`()
    real *`getRowValues`(size_t i) const
    int *`getRowCols`(size_t i) const
    void `fillRowIndices`(IVectorPtr &outVec) const

      fill row indices of each value in CSR matrix

    size_t `getColNum`(size_t i) const
    real *`getColumn`(size_t i) const
    size_t `getColStartIdx`(size_t i) const
    size_t `getRowStartIdx`(size_t i) const
    size_t `getRowNum`(size_t i) const
    virtual real `getSum`()
    virtual void `square`()
    virtual real `getMin`()

      only consider nonzero values. the actual min value should compare with 0.0.

    virtual real `getMax`()

      only consider nonzero values. the actual max value should compare with 0.0.

    void `rowMax`(IVector &maxIds, Matrix &max)

      Get the top k elements of each row of this matrix.

      The column ids and values of these elements are stored in maxIds and max respectively. where k is the size of maxIds. And note that the top k elements are not sorted.

    int *`getRows`() const
    int *`getCols`() const
    real *`getValue`() const
    SparseFormat `getFormat`() const
    SparseValueType `getValueType`() const
    real *`getData`()

      return value_ of sparse matrix

      Some times CpuSparseMatrix maybe Matrix, if getValue, must dynamic_cast to CpuSparseMatrix, getData is convenient to get value

    const real *`getData`() const
    void `zeroMem`()

      only set value_ of FLOAT_VALUE sparse matrix to zero

    void `transpose`(MatrixPtr matTrans, bool memAlloc)

      mem MUST be alloced outside (memAlloc=false)

    void `mul`(MatrixPtr a, MatrixPtr b, real scaleAB, real scaleT)

          this = scaleAB*(a*b) + scaleT*this

    void `add3`(CpuMatrix *b)

      sparseMatrix += denseMatrix

      Named add3 just because add/add2 has been used in BaseMatrix.cu and they are not virtual function.

      Only add value of same (row, col) index in dense matrix and do not use others values whoes postions are not in sparse matirx.

      Parameters
        - `b`: dense matrix
    void `add3`(MatrixPtr b)

      matrix elment-wise add

      Named add3 just because add/add2 has been used in BaseMatrix.cu and they are not virtual function.

    void `addBias`(Matrix &b, real scale)

      sparseMatrix[i,j] += bias[j], (j is the col index of sparse matrix)

      Parameters
        - `b`: bias, dense matrix and height = 1
        - `scale`: scale of b
    void `print`(std::ostream &os) const

      print out the values of elements to os

    void `printOneRow`(std::ostream &os, size_t idx) const

      print one row to os

    void `setRow`(size_t row, size_t colNum, const unsigned int *cols, const real *values)

      This should only be used for sparse matrix.

      Currently must be called for each row in order. The matrix is not valid until setRow is called for the last row.

    void `randomizeUniform`()
    void `copyFrom`(const GpuSparseMatrix &src, hl_stream_t stream)
    void `copyFrom`(const Matrix &src, hl_stream_t stream = HPPL_STREAM_DEFAULT)
    void `copyFrom`(const Matrix &src)
    CpuSparseMatrixPtr `getTmpSparseMatrix`(size_t height, size_t width)

      Get a temporary matrix. This is threadsafe. It should be only used temporarily, i.e. do not store it or use it as return value.

      Note
        Do NOT use large amount of tmp matrix.
    MatrixPtr `subMatrix`(size_t startRow, size_t numRows)
    void `copyFrom`(std::vector<int> &rows, std::vector<int> &cols, std::vector<real> &values)
    void `copyFrom`(const CpuMatrix &src)
    void `copyFrom`(const CpuSparseMatrix &src)
    void `trimFrom`(const CpuSparseMatrix &src)
    void `copyRow`(int offsets, size_t colNum, const sparse_non_value_t *row)
    void `copyRow`(int offsets, size_t colNum, const sparse_float_value_t *row)
    template <class T>
    void `copyFrom`(int64_t *ids, int64_t *indices, T *data)
    template <class T>
    void `copyFrom`(int64_t *indices, T *data)
    void `copyFrom`(const real *src, size_t size)

      If this is GpuMatrix, src is assumed to be CPU memory

      If this is CpuMatrix, src is assumed to be CPU memory

    bool `isSparse`() const

    Protected Functions

    void `sparseResize`()

    Protected Attributes

    int *`rows_`
    int *`cols_`
    real *`value_`
    SparseFormat `format_`
    SparseValueType `valueType_`

    Protected Static Attributes

    const size_t `DEFAULT_AVG_WIDTH`
    ThreadLocal<std::vector<CpuSparseMatrixPtr>> `cpuLocalMats_`

    Private Functions

    MatrixPtr `clone`(size_t height = 0, size_t width = 0, bool useGpu = false)

      Create a matrix with the same type (GpuMatrix, CpuMatrix, NonValueSparseMatrix, etc.) as this.

      If height and width is zero, the new matrix will have the same size as this, otherwise the new matrix will have the specified size.

## Others

namespace `paddle`

  Functions

  template <class T>
  void `gemm`(const CBLAS_TRANSPOSE transA, const CBLAS_TRANSPOSE transB, const int M, const int N, const int K, const T alpha, const T *A, const int lda, const T *B, const int ldb, const T beta, T *C, const int ldc)
  template <class T>
  int `getrf`(const CBLAS_ORDER Order, const int M, const int N, T *A, const int lda, int *ipiv)
  template <class T>
  int `getri`(const CBLAS_ORDER Order, const int N, T *A, const int lda, const int *ipiv)
  template <class T>
  void `axpy`(const int n, const T alpha, const T *x, T *y)
  template <class T>
  T `dotProduct`(const int n, const T *x, const T *y)

namespace `paddle`
  namespace `simd`

    Functions

    template <typename Type>
    void `addTo`(Type *a, const Type *b, size_t len)
    template <typename Type>
    void `batchAddTo`(Type *a, const Type *b[], int batch, size_t len)
    template <typename Type>
    void `colMax`(Type *result, const Type *data, int dim, int numSamples)
    template <typename Type>
    void `decayL1`(Type *dst, Type *src, Type *lr, Type lambda, size_t len)
    template <typename Type>
    void `decayL1`(Type *dst, Type *src, Type lambda, size_t len)
    template <size_t AlignSize>
    bool `isPointerAlign`(void *ptr)
    bool `vec_check`(size_t len)
    template <>
    void `addTo`(float *a, const float *b, size_t len)
    template <>
    void `batchAddTo`(float *a, const float *b[], int batch, size_t len)
    template <>
    void `colMax`(float *result, const float *data, int dim, int numSamples)
    template <>
    void `decayL1`(float *dst, float *src, float lambda, size_t len)
    template <>
    void `decayL1`(float *dst, float *src, float *lr, float lambda, size_t len)
    namespace `naive`

      Functions

      template <typename Type>
      void `addTo`(Type *a, const Type *b, size_t len)
      template <typename Type>
      void `batchAddTo`(Type *a, const Type *b[], int batch, size_t len)
      template <typename Type>
      void `colMax`(Type *result, const Type *data, int dim, int numSamples)

        Note
          this method is unused in paddle.
      template <typename Type>
      void `decayL1`(Type *dst, Type *src, Type *lr, Type lambda, size_t len)
      template <class Type>
      void `decayL1`(Type *dst, Type *src, Type lambda, size_t len)