Matrix and vector classes

For an overview of the matrix library, see The Kaldi Matrix library. More...

Collaboration diagram for Matrix and vector classes:

Modules
	Matrix-vector functions returning scalars
	Miscellaneous matrix/vector library functions and classes

Classes
class	CompressedMatrix
class	MatrixBase< Real >
	Base class which provides matrix operations not involving resizing or allocation. More...
class	Matrix< Real >
	A class for storing matrices. More...
class	VectorBase< Real >
	Provides a vector abstraction class. More...
class	Vector< Real >
	A class representing a vector. More...
class	SubVector< Real >
	Represents a non-allocating general vector which can be defined as a sub-vector of higher-level vector [or as the row of a matrix]. More...
class	PackedMatrix< Real >
	Packed matrix: base class for triangular and symmetric matrices. More...
class	SpMatrix< Real >
	Packed symetric matrix class. More...
class	SparseVector< Real >
class	SparseMatrix< Real >
class	GeneralMatrix
	This class is a wrapper that enables you to store a matrix in one of three forms: either as a Matrix<BaseFloat>, or a CompressedMatrix, or a SparseMatrix<BaseFloat>. More...
class	TpMatrix< Real >
	Packed symetric matrix class. More...

Enumerations
enum	CompressionMethod {   kAutomaticMethod = 1, kSpeechFeature = 2, kTwoByteAuto = 3, kTwoByteSignedInteger = 4,   kOneByteAuto = 5, kOneByteUnsignedInteger = 6, kOneByteZeroOne = 7 }
enum	GeneralMatrixType { kFullMatrix, kCompressedMatrix, kSparseMatrix }

Functions
template<typename Real >
Real	VecSvec (const VectorBase< Real > &vec, const SparseVector< Real > &svec)
template<typename Real >
Real	TraceMatSmat (const MatrixBase< Real > &A, const SparseMatrix< Real > &B, MatrixTransposeType trans)
void	AppendGeneralMatrixRows (const std::vector< const GeneralMatrix * > &src, GeneralMatrix *mat)
	Appends all the matrix rows of a list of GeneralMatrixes, to get a single GeneralMatrix. More...
template<typename Real >
void	FilterSparseMatrixRows (const SparseMatrix< Real > &in, const std::vector< bool > &keep_rows, SparseMatrix< Real > *out)
	Outputs a SparseMatrix<Real> containing only the rows r of "in" such that keep_rows[r] == true. More...
template<typename Real >
void	FilterMatrixRows (const Matrix< Real > &in, const std::vector< bool > &keep_rows, Matrix< Real > *out)
	Outputs a Matrix<Real> containing only the rows r of "in" such that keep_keep_rows[r] == true. More...
void	FilterCompressedMatrixRows (const CompressedMatrix &in, const std::vector< bool > &keep_rows, Matrix< BaseFloat > *out)
	Outputs a Matrix<Real> containing only the rows r of "in" such that keep_rows[r] == true. More...
void	FilterGeneralMatrixRows (const GeneralMatrix &in, const std::vector< bool > &keep_rows, GeneralMatrix *out)
	Outputs a GeneralMatrix containing only the rows r of "in" such that keep_rows[r] == true. More...
void	ExtractRowRangeWithPadding (const GeneralMatrix &in, int32 row_offset, int32 num_rows, GeneralMatrix *out)
	This function extracts a row-range of a GeneralMatrix and writes as a GeneralMatrix containing the same type of underlying matrix. More...

Detailed Description

For an overview of the matrix library, see The Kaldi Matrix library.

Enumeration Type Documentation

CompressionMethod

enum CompressionMethod

Enumerator
kAutomaticMethod
kSpeechFeature
kTwoByteAuto
kTwoByteSignedInteger
kOneByteAuto
kOneByteUnsignedInteger
kOneByteZeroOne

Definition at line 75 of file compressed-matrix.h.

                       {
  kAutomaticMethod = 1,
  kSpeechFeature = 2,
  kTwoByteAuto = 3,
  kTwoByteSignedInteger = 4,
  kOneByteAuto = 5,
  kOneByteUnsignedInteger = 6,
  kOneByteZeroOne = 7
};

GeneralMatrixType

enum GeneralMatrixType

Enumerator
kFullMatrix
kCompressedMatrix
kSparseMatrix

Definition at line 271 of file sparse-matrix.h.

                       {
  kFullMatrix,
  kCompressedMatrix,
  kSparseMatrix
};

Function Documentation

AppendGeneralMatrixRows()

void AppendGeneralMatrixRows	(	const std::vector< const GeneralMatrix * > &	src,
		GeneralMatrix *	mat
	)

Appends all the matrix rows of a list of GeneralMatrixes, to get a single GeneralMatrix.

Preserves sparsity if all inputs were sparse (or empty). Does not preserve compression, if inputs were compressed; you have to re-compress manually, if that's what you need.

Definition at line 929 of file sparse-matrix.cc.

References SparseMatrix< Real >::AppendSparseMatrixRows(), GeneralMatrix::Clear(), GeneralMatrix::CopyToMat(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, kaldi::kSparseMatrix, kaldi::kUndefined, GeneralMatrix::NumCols(), GeneralMatrix::NumRows(), GeneralMatrix::SwapFullMatrix(), and GeneralMatrix::SwapSparseMatrix().

Referenced by kaldi::nnet3::MergeIo().

                                                 {
  mat->Clear();
  int32 size = src.size();
  if (size == 0)
    return;
  bool all_sparse = true;
  for (int32 i = 0; i < size; i++) {
    if (src[i]->Type() != kSparseMatrix && src[i]->NumRows() != 0) {
      all_sparse = false;
      break;
    }
  }
  if (all_sparse) {
    std::vector<SparseMatrix<BaseFloat> > sparse_mats(size);
    for (int32 i = 0; i < size; i++)
      sparse_mats[i] = src[i]->GetSparseMatrix();
    SparseMatrix<BaseFloat> appended_mat;
    appended_mat.AppendSparseMatrixRows(&sparse_mats);
    mat->SwapSparseMatrix(&appended_mat);
  } else {
    int32 tot_rows = 0, num_cols = -1;
    for (int32 i = 0; i < size; i++) {
      const GeneralMatrix &src_mat = *(src[i]);
      int32 src_rows = src_mat.NumRows(), src_cols = src_mat.NumCols();
      if (src_rows != 0) {
        tot_rows += src_rows;
        if (num_cols == -1) num_cols = src_cols;
        else if (num_cols != src_cols)
          KALDI_ERR << "Appending rows of matrices with inconsistent num-cols: "
                    << num_cols << " vs. " << src_cols;
      }
    }
    Matrix<BaseFloat> appended_mat(tot_rows, num_cols, kUndefined);
    int32 row_offset = 0;
    for (int32 i = 0; i < size; i++) {
      const GeneralMatrix &src_mat = *(src[i]);
      int32 src_rows = src_mat.NumRows();
      if (src_rows != 0) {
        SubMatrix<BaseFloat> dest_submat(appended_mat, row_offset, src_rows,
                                         0, num_cols);
        src_mat.CopyToMat(&dest_submat);
        row_offset += src_rows;
      }
    }
    KALDI_ASSERT(row_offset == tot_rows);
    mat->SwapFullMatrix(&appended_mat);
  }
}

ExtractRowRangeWithPadding()

void ExtractRowRangeWithPadding	(	const GeneralMatrix &	in,
		int32	row_offset,
		int32	num_rows,
		GeneralMatrix *	out
	)

This function extracts a row-range of a GeneralMatrix and writes as a GeneralMatrix containing the same type of underlying matrix.

If the row-range is partly outside the row-range of 'in' (i.e. if row_offset < 0 or row_offset + num_rows > in.NumRows()) then it will pad with copies of the first and last row as needed. This is more efficient than un-compressing and re-compressing the underlying CompressedMatrix, and causes less accuracy loss due to re-compression (no loss in most cases).

Definition at line 1233 of file sparse-matrix.cc.

References VectorBase< Real >::CopyFromVec(), GeneralMatrix::GetCompressedMatrix(), GeneralMatrix::GetFullMatrix(), GeneralMatrix::GetSparseMatrix(), KALDI_ASSERT, KALDI_ERR, kaldi::kCompressedMatrix, kaldi::kFullMatrix, kaldi::kSparseMatrix, kaldi::kUndefined, MatrixBase< Real >::NumCols(), SparseMatrix< Real >::NumCols(), CompressedMatrix::NumCols(), MatrixBase< Real >::NumRows(), SparseMatrix< Real >::NumRows(), SparseMatrix< Real >::Row(), SparseMatrix< Real >::SetRow(), GeneralMatrix::SwapCompressedMatrix(), GeneralMatrix::SwapFullMatrix(), GeneralMatrix::SwapSparseMatrix(), and GeneralMatrix::Type().

Referenced by kaldi::nnet3::ProcessFile(), and kaldi::UnitTestGeneralMatrix().

                        {
  // make sure 'out' is empty to start with.
  Matrix<BaseFloat> empty_mat;
  *out = empty_mat;
  if (num_rows == 0) return;
  switch (in.Type()) {
    case kFullMatrix: {
      const Matrix<BaseFloat> &mat_in = in.GetFullMatrix();
      int32 num_rows_in = mat_in.NumRows(), num_cols = mat_in.NumCols();
      KALDI_ASSERT(num_rows_in > 0);  // we can't extract >0 rows from an empty
                                      // matrix.
      Matrix<BaseFloat> mat_out(num_rows, num_cols, kUndefined);
      for (int32 row = 0; row < num_rows; row++) {
        int32 row_in = row + row_offset;
        if (row_in < 0) row_in = 0;
        else if (row_in >= num_rows_in) row_in = num_rows_in - 1;
        SubVector<BaseFloat> vec_in(mat_in, row_in),
            vec_out(mat_out, row);
        vec_out.CopyFromVec(vec_in);
      }
      out->SwapFullMatrix(&mat_out);
      break;
    }
    case kSparseMatrix: {
      const SparseMatrix<BaseFloat> &smat_in = in.GetSparseMatrix();
      int32 num_rows_in = smat_in.NumRows(),
          num_cols = smat_in.NumCols();
      KALDI_ASSERT(num_rows_in > 0);  // we can't extract >0 rows from an empty
                                      // matrix.
      SparseMatrix<BaseFloat> smat_out(num_rows, num_cols);
      for (int32 row = 0; row < num_rows; row++) {
        int32 row_in = row + row_offset;
        if (row_in < 0) row_in = 0;
        else if (row_in >= num_rows_in) row_in = num_rows_in - 1;
        smat_out.SetRow(row, smat_in.Row(row_in));
      }
      out->SwapSparseMatrix(&smat_out);
      break;
    }
    case kCompressedMatrix: {
      const CompressedMatrix &cmat_in = in.GetCompressedMatrix();
      bool allow_padding = true;
      CompressedMatrix cmat_out(cmat_in, row_offset, num_rows,
                                0, cmat_in.NumCols(), allow_padding);
      out->SwapCompressedMatrix(&cmat_out);
      break;
    }
    default:
      KALDI_ERR << "Bad matrix type.";
  }
}

FilterCompressedMatrixRows()

void FilterCompressedMatrixRows	(	const CompressedMatrix &	in,
		const std::vector< bool > &	keep_rows,
		Matrix< BaseFloat > *	out
	)

Outputs a Matrix<Real> containing only the rows r of "in" such that keep_rows[r] == true.

keep_rows.size() must equal in.NumRows(), and rows must contain at least one "true" element.

Definition at line 979 of file sparse-matrix.cc.

References CompressedMatrix::CopyRowToVec(), CompressedMatrix::CopyToMat(), kaldi::FilterMatrixRows(), KALDI_ASSERT, KALDI_ERR, kaldi::kUndefined, CompressedMatrix::NumCols(), CompressedMatrix::NumRows(), and Matrix< Real >::Resize().

Referenced by kaldi::FilterGeneralMatrixRows().

                                                        {
  KALDI_ASSERT(keep_rows.size() == static_cast<size_t>(in.NumRows()));
  int32 num_kept_rows = 0;
  std::vector<bool>::const_iterator iter = keep_rows.begin(),
                                     end = keep_rows.end();
  for (; iter != end; ++iter)
    if (*iter)
      num_kept_rows++;
  if (num_kept_rows == 0)
    KALDI_ERR << "No kept rows";
  if (num_kept_rows == static_cast<int32>(keep_rows.size())) {
    out->Resize(in.NumRows(), in.NumCols(), kUndefined);
    in.CopyToMat(out);
    return;
  }
  const BaseFloat heuristic = 0.33;
  // should be > 0 and < 1.0.  represents the performance hit we get from
  // iterating row-wise versus column-wise in compressed-matrix uncompression.

  if (num_kept_rows > heuristic * in.NumRows()) {
    // if quite a few of the the rows are kept, it may be more efficient
    // to uncompress the entire compressed matrix, since per-column operation
    // is more efficient.
    Matrix<BaseFloat> full_mat(in);
    FilterMatrixRows(full_mat, keep_rows, out);
  } else {
    out->Resize(num_kept_rows, in.NumCols(), kUndefined);

    iter = keep_rows.begin();
    int32 out_row = 0;
    for (int32 in_row = 0; iter != end; ++iter, ++in_row) {
      if (*iter) {
        SubVector<BaseFloat> dest(*out, out_row);
        in.CopyRowToVec(in_row, &dest);
        out_row++;
      }
    }
    KALDI_ASSERT(out_row == num_kept_rows);
  }
}

FilterGeneralMatrixRows()

void FilterGeneralMatrixRows	(	const GeneralMatrix &	in,
		const std::vector< bool > &	keep_rows,
		GeneralMatrix *	out
	)

Outputs a GeneralMatrix containing only the rows r of "in" such that keep_rows[r] == true.

keep_rows.size() must equal in.NumRows(), and keep_rows must contain at least one "true" element. If in.Type() is kCompressedMatrix, the result will not be compressed; otherwise, the type is preserved.

Definition at line 1101 of file sparse-matrix.cc.

References GeneralMatrix::Clear(), kaldi::FilterCompressedMatrixRows(), kaldi::FilterMatrixRows(), kaldi::FilterSparseMatrixRows(), GeneralMatrix::GetCompressedMatrix(), GeneralMatrix::GetFullMatrix(), GeneralMatrix::GetSparseMatrix(), KALDI_ASSERT, KALDI_ERR, kaldi::kCompressedMatrix, kaldi::kFullMatrix, kaldi::kSparseMatrix, GeneralMatrix::NumRows(), GeneralMatrix::SwapFullMatrix(), GeneralMatrix::SwapSparseMatrix(), and GeneralMatrix::Type().

Referenced by kaldi::nnet3::FilterExample().

                                                 {
  out->Clear();
  KALDI_ASSERT(keep_rows.size() == static_cast<size_t>(in.NumRows()));
  int32 num_kept_rows = 0;
  std::vector<bool>::const_iterator iter = keep_rows.begin(),
                                     end = keep_rows.end();
  for (; iter != end; ++iter)
    if (*iter)
      num_kept_rows++;
  if (num_kept_rows == 0)
    KALDI_ERR << "No kept rows";
  if (num_kept_rows == static_cast<int32>(keep_rows.size())) {
    *out = in;
    return;
  }
  switch (in.Type()) {
    case kCompressedMatrix: {
      const CompressedMatrix &cmat = in.GetCompressedMatrix();
      Matrix<BaseFloat> full_mat;
      FilterCompressedMatrixRows(cmat, keep_rows, &full_mat);
      out->SwapFullMatrix(&full_mat);
      return;
    }
    case kSparseMatrix: {
      const SparseMatrix<BaseFloat> &smat = in.GetSparseMatrix();
      SparseMatrix<BaseFloat> smat_out;
      FilterSparseMatrixRows(smat, keep_rows, &smat_out);
      out->SwapSparseMatrix(&smat_out);
      return;
    }
    case kFullMatrix: {
      const Matrix<BaseFloat> &full_mat = in.GetFullMatrix();
      Matrix<BaseFloat> full_mat_out;
      FilterMatrixRows(full_mat, keep_rows, &full_mat_out);
      out->SwapFullMatrix(&full_mat_out);
      return;
    }
    default:
      KALDI_ERR << "Invalid general-matrix type.";
  }
}

FilterMatrixRows()

void FilterMatrixRows	(	const Matrix< Real > &	in,
		const std::vector< bool > &	keep_rows,
		Matrix< Real > *	out
	)

Outputs a Matrix<Real> containing only the rows r of "in" such that keep_keep_rows[r] == true.

keep_rows.size() must equal in.NumRows(), and keep_rows must contain at least one "true" element.

Definition at line 1023 of file sparse-matrix.cc.

References VectorBase< Real >::CopyFromVec(), kaldi::FilterMatrixRows(), KALDI_ASSERT, KALDI_ERR, kaldi::kUndefined, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

                                         {
  KALDI_ASSERT(keep_rows.size() == static_cast<size_t>(in.NumRows()));
  int32 num_kept_rows = 0;
  std::vector<bool>::const_iterator iter = keep_rows.begin(),
                                     end = keep_rows.end();
  for (; iter != end; ++iter)
    if (*iter)
      num_kept_rows++;
  if (num_kept_rows == 0)
    KALDI_ERR << "No kept rows";
  if (num_kept_rows == static_cast<int32>(keep_rows.size())) {
    *out = in;
    return;
  }
  out->Resize(num_kept_rows, in.NumCols(), kUndefined);
  iter = keep_rows.begin();
  int32 out_row = 0;
  for (int32 in_row = 0; iter != end; ++iter, ++in_row) {
    if (*iter) {
      SubVector<Real> src(in, in_row);
      SubVector<Real> dest(*out, out_row);
      dest.CopyFromVec(src);
      out_row++;
    }
  }
  KALDI_ASSERT(out_row == num_kept_rows);
}

FilterSparseMatrixRows()

void FilterSparseMatrixRows	(	const SparseMatrix< Real > &	in,
		const std::vector< bool > &	keep_rows,
		SparseMatrix< Real > *	out
	)

Outputs a SparseMatrix<Real> containing only the rows r of "in" such that keep_rows[r] == true.

keep_rows.size() must equal in.NumRows(), and rows must contain at least one "true" element.

Definition at line 1063 of file sparse-matrix.cc.

References kaldi::FilterSparseMatrixRows(), KALDI_ASSERT, KALDI_ERR, kaldi::kUndefined, SparseMatrix< Real >::NumCols(), SparseMatrix< Real >::NumRows(), SparseMatrix< Real >::Resize(), SparseMatrix< Real >::Row(), and SparseMatrix< Real >::SetRow().

                                                     {
  KALDI_ASSERT(keep_rows.size() == static_cast<size_t>(in.NumRows()));
  int32 num_kept_rows = 0;
  std::vector<bool>::const_iterator iter = keep_rows.begin(),
                                     end = keep_rows.end();
  for (; iter != end; ++iter)
    if (*iter)
      num_kept_rows++;
  if (num_kept_rows == 0)
    KALDI_ERR << "No kept rows";
  if (num_kept_rows == static_cast<int32>(keep_rows.size())) {
    *out = in;
    return;
  }
  out->Resize(num_kept_rows, in.NumCols(), kUndefined);
  iter = keep_rows.begin();
  int32 out_row = 0;
  for (int32 in_row = 0; iter != end; ++iter, ++in_row) {
    if (*iter) {
      out->SetRow(out_row, in.Row(in_row));
      out_row++;
    }
  }
  KALDI_ASSERT(out_row == num_kept_rows);
}

TraceMatSmat()

Real TraceMatSmat	(	const MatrixBase< Real > &	A,
		const SparseMatrix< Real > &	B,
		MatrixTransposeType	trans
	)

Definition at line 704 of file sparse-matrix.cc.

References MatrixBase< Real >::Data(), SparseVector< Real >::Data(), rnnlm::i, KALDI_ASSERT, kaldi::kTrans, MatrixBase< Real >::NumCols(), SparseMatrix< Real >::NumCols(), SparseVector< Real >::NumElements(), MatrixBase< Real >::NumRows(), SparseMatrix< Real >::NumRows(), MatrixBase< Real >::Row(), SparseMatrix< Real >::Row(), MatrixBase< Real >::Stride(), kaldi::TraceMatSmat(), and kaldi::VecSvec().

Referenced by kaldi::nnet3::ComputeObjectiveFunction(), kaldi::TestCuSparseMatrixTraceMatSmat(), kaldi::UnitTestCuSparseMatrixTraceMatSmat(), kaldi::UnitTestMatrixAddMatSmat(), kaldi::UnitTestMatrixAddSmatMat(), and kaldi::UnitTestSparseMatrixTraceMatSmat().

                                             {
  Real sum = 0.0;
  if (trans == kTrans) {
    MatrixIndexT num_rows = A.NumRows();
    KALDI_ASSERT(B.NumRows() == num_rows);
    for (MatrixIndexT r = 0; r < num_rows; r++)
      sum += VecSvec(A.Row(r), B.Row(r));
  } else {
    const Real *A_col_data = A.Data();
    MatrixIndexT Astride = A.Stride(), Acols = A.NumCols(), Arows = A.NumRows();
    KALDI_ASSERT(Arows == B.NumCols() && Acols == B.NumRows());
    sum = 0.0;
    for (MatrixIndexT i = 0; i < Acols; i++, A_col_data++) {
      Real col_sum = 0.0;
      const SparseVector<Real> &svec = B.Row(i);
      MatrixIndexT num_elems = svec.NumElements();
      const std::pair<MatrixIndexT, Real> *sdata = svec.Data();
      for (MatrixIndexT e = 0; e < num_elems; e++)
        col_sum += A_col_data[Astride * sdata[e].first] * sdata[e].second;
      sum += col_sum;
    }
  }
  return sum;
}

VecSvec()

Real VecSvec	(	const VectorBase< Real > &	vec,
		const SparseVector< Real > &	svec
	)

Definition at line 523 of file sparse-matrix.cc.

References VectorBase< Real >::Data(), SparseVector< Real >::Data(), SparseVector< Real >::Dim(), VectorBase< Real >::Dim(), rnnlm::i, KALDI_ASSERT, rnnlm::n, and SparseVector< Real >::NumElements().

Referenced by kaldi::UnitTestSparseVectorVecSvec().

                                             {
  KALDI_ASSERT(vec.Dim() == svec.Dim());
  MatrixIndexT n = svec.NumElements();
  const std::pair<MatrixIndexT, Real> *sdata = svec.Data();
  const Real *data = vec.Data();
  Real ans = 0.0;
  for (MatrixIndexT i = 0; i < n; i++)
    ans += data[sdata[i].first] * sdata[i].second;
  return ans;
}