@ -62,9 +62,7 @@ class MatrixBase {
}
/// Gives pointer to raw data (const).
inline const Real * Data ( ) const {
return data_ ;
}
inline const Real * Data ( ) const { return data_ ; }
/// Gives pointer to raw data (non-const).
inline Real * Data ( ) { return data_ ; }
@ -86,7 +84,8 @@ class MatrixBase {
/// Indexing operator, non-const
/// (only checks sizes if compiled with -DKALDI_PARANOID)
inline Real & operator ( ) ( MatrixIndexT r , MatrixIndexT c ) {
KALDI_PARANOID_ASSERT ( static_cast < UnsignedMatrixIndexT > ( r ) <
KALDI_PARANOID_ASSERT (
static_cast < UnsignedMatrixIndexT > ( r ) <
static_cast < UnsignedMatrixIndexT > ( num_rows_ ) & &
static_cast < UnsignedMatrixIndexT > ( c ) <
static_cast < UnsignedMatrixIndexT > ( num_cols_ ) ) ;
@ -99,7 +98,8 @@ class MatrixBase {
/// Indexing operator, const
/// (only checks sizes if compiled with -DKALDI_PARANOID)
inline const Real operator ( ) ( MatrixIndexT r , MatrixIndexT c ) const {
KALDI_PARANOID_ASSERT ( static_cast < UnsignedMatrixIndexT > ( r ) <
KALDI_PARANOID_ASSERT (
static_cast < UnsignedMatrixIndexT > ( r ) <
static_cast < UnsignedMatrixIndexT > ( num_rows_ ) & &
static_cast < UnsignedMatrixIndexT > ( c ) <
static_cast < UnsignedMatrixIndexT > ( num_cols_ ) ) ;
@ -138,7 +138,8 @@ class MatrixBase {
/// if v.Dim() == NumCols(), it sets each row of *this to a copy of v.
void CopyRowsFromVec ( const VectorBase < Real > & v ) ;
/// This version of CopyRowsFromVec is implemented in ../cudamatrix/cu-vector.cc
/// This version of CopyRowsFromVec is implemented in
/// ../cudamatrix/cu-vector.cc
// void CopyRowsFromVec(const CuVectorBase<Real> &v);
template < typename OtherReal >
@ -177,8 +178,8 @@ class MatrixBase {
const MatrixIndexT num_rows ,
const MatrixIndexT col_offset ,
const MatrixIndexT num_cols ) const {
return SubMatrix < Real > ( * this , row_offset , num_rows ,
col_offset , num_cols ) ;
return SubMatrix < Real > (
* this , row_offset , num_rows , col_offset , num_cols ) ;
}
inline SubMatrix < Real > RowRange ( const MatrixIndexT row_offset ,
const MatrixIndexT num_rows ) const {
@ -223,7 +224,8 @@ class MatrixBase {
/// each row by a scalar taken from that dimension of the vector.
void MulRowsVec ( const VectorBase < Real > & scale ) ;
/// Divide each row into src.NumCols() equal groups, and then scale i'th row's
/// Divide each row into src.NumCols() equal groups, and then scale i'th
row ' s
/// j'th group of elements by src(i, j). Requires src.NumRows() ==
/// this->NumRows() and this->NumCols() % src.NumCols() == 0.
void MulRowsGroupMat ( const MatrixBase < Real > & src ) ;
@ -256,15 +258,13 @@ class MatrixBase {
/// As a special case, if indexes[i] == -1, sets column i to zero.
/// all elements of "indices" must be in [-1, src.NumCols()-1],
/// and src.NumRows() must equal this.NumRows()
void CopyCols ( const MatrixBase < Real > & src ,
const MatrixIndexT * indices ) ;
void CopyCols ( const MatrixBase < Real > & src , const MatrixIndexT * indices ) ;
/// Copies row r from row indices[r] of src (does nothing
/// As a special case, if indexes[i] == -1, sets row i to zero.
/// all elements of "indices" must be in [-1, src.NumRows()-1],
/// and src.NumCols() must equal this.NumCols()
void CopyRows ( const MatrixBase < Real > & src ,
const MatrixIndexT * indices ) ;
void CopyRows ( const MatrixBase < Real > & src , const MatrixIndexT * indices ) ;
/// Add column indices[r] of src to column r.
/// As a special case, if indexes[i] == -1, skip column i
@ -274,26 +274,30 @@ class MatrixBase {
// void AddCols(const MatrixBase<Real> &src,
// const MatrixIndexT *indices);
/// Copies row r of this matrix from an array of floats at the location given
/// Copies row r of this matrix from an array of floats at the location
/// given
/// by src[r]. If any src[r] is NULL then this.Row(r) will be set to zero.
/// Note: we are using "pointer to const pointer to const object" for "src",
/// because we may create "src" by calling Data() of const CuArray
void CopyRows ( const Real * const * src ) ;
/// Copies row r of this matrix to the array of floats at the location given
/// by dst[r]. If dst[r] is NULL, does not copy anywhere. Requires that none
/// by dst[r]. If dst[r] is NULL, does not copy anywhere. Requires that
/// none
/// of the memory regions pointed to by the pointers in "dst" overlap (e.g.
/// none of the pointers should be the same).
void CopyToRows ( Real * const * dst ) const ;
/// Does for each row r, this.Row(r) += alpha * src.row(indexes[r]).
/// If indexes[r] < 0, does not add anything. all elements of "indexes" must
/// be in [-1, src.NumRows()-1], and src.NumCols() must equal this.NumCols().
/// be in [-1, src.NumRows()-1], and src.NumCols() must equal
/// this.NumCols().
// void AddRows(Real alpha,
// const MatrixBase<Real> &src,
// const MatrixIndexT *indexes);
/// Does for each row r, this.Row(r) += alpha * src[r], treating src[r] as the
/// Does for each row r, this.Row(r) += alpha * src[r], treating src[r] as
/// the
/// beginning of a region of memory representing a vector of floats, of the
/// same length as this.NumCols(). If src[r] is NULL, does not add anything.
// void AddRows(Real alpha, const Real *const *src);
@ -350,48 +354,63 @@ class MatrixBase {
this - > Log ( * this ) ;
}
*/
/// Eigenvalue Decomposition of a square NxN matrix into the form (*this) = P D
/// P^{-1}. Be careful: the relationship of D to the eigenvalues we output is
/// slightly complicated, due to the need for P to be real. In the symmetric
/// Eigenvalue Decomposition of a square NxN matrix into the form (*this) =
/// P D
/// P^{-1}. Be careful: the relationship of D to the eigenvalues we output
/// is
/// slightly complicated, due to the need for P to be real. In the
/// symmetric
/// case D is diagonal and real, but in
/// the non-symmetric case there may be complex-conjugate pairs of eigenvalues.
/// In this case, for the equation (*this) = P D P^{-1} to hold, D must actually
/// be block diagonal, with 2x2 blocks corresponding to any such pairs. If a
/// the non-symmetric case there may be complex-conjugate pairs of
/// eigenvalues.
/// In this case, for the equation (*this) = P D P^{-1} to hold, D must
/// actually
/// be block diagonal, with 2x2 blocks corresponding to any such pairs. If
/// a
/// pair is lambda +- i*mu, D will have a corresponding 2x2 block
/// [lambda, mu; -mu, lambda].
/// Note that if the input matrix (*this) is non-invertible, P may not be invertible
/// so in this case instead of the equation (*this) = P D P^{-1} holding, we have
/// Note that if the input matrix (*this) is non-invertible, P may not be
/// invertible
/// so in this case instead of the equation (*this) = P D P^{-1} holding, we
/// have
/// instead (*this) P = P D.
///
/// The non-member function CreateEigenvalueMatrix creates D from eigs_real and eigs_imag.
/// The non-member function CreateEigenvalueMatrix creates D from eigs_real
/// and eigs_imag.
// void Eig(MatrixBase<Real> *P,
// VectorBase<Real> *eigs_real,
// VectorBase<Real> *eigs_imag) const;
/// The Power method attempts to take the matrix to a power using a method that
/// works in general for fractional and negative powers. The input matrix must
/// The Power method attempts to take the matrix to a power using a method
/// that
/// works in general for fractional and negative powers. The input matrix
/// must
/// be invertible and have reasonable condition (or we don't guarantee the
/// results. The method is based on the eigenvalue decomposition. It will
/// return false and leave the matrix unchanged, if at entry the matrix had
/// real negative eigenvalues (or if it had zero eigenvalues and the power was
/// real negative eigenvalues (or if it had zero eigenvalues and the power
/// was
/// negative).
// bool Power(Real pow);
/** Singular value decomposition
Major limitations :
For nonsquare matrices , we assume m > = n ( NumRows > = NumCols ) , and we return
For nonsquare matrices , we assume m > = n ( NumRows > = NumCols ) , and we
return
the " skinny " Svd , i . e . the matrix in the middle is diagonal , and the
one on the left is rectangular .
In Svd , * this = U * diag ( S ) * Vt .
Null pointers for U and / or Vt at input mean we do not want that output . We
Null pointers for U and / or Vt at input mean we do not want that output .
We
expect that S . Dim ( ) = = m , U is either NULL or m by n ,
and v is either NULL or n by n .
The singular values are not sorted ( use SortSvd for that ) . */
// void DestructiveSvd(VectorBase<Real> *s, MatrixBase<Real> *U,
// MatrixBase<Real> *Vt); // Destroys calling matrix.
/// Compute SVD (*this) = U diag(s) Vt. Note that the V in the call is already
/// Compute SVD (*this) = U diag(s) Vt. Note that the V in the call is
/// already
/// transposed; the normal formulation is U diag(s) V^T.
/// Null pointers for U or V mean we don't want that output (this saves
/// compute). The singular values are not sorted (use SortSvd for that).
@ -408,7 +427,8 @@ class MatrixBase {
// return tmp.Min();
//}
//void TestUninitialized() const; // This function is designed so that if any element
// void TestUninitialized() const; // This function is designed so that if
// any element
// if the matrix is uninitialized memory, valgrind will complain.
/// Returns condition number by computing Svd. Works even if cols > rows.
@ -422,16 +442,19 @@ class MatrixBase {
/// Returns true if matrix is Diagonal.
bool IsDiagonal ( Real cutoff = 1.0e-05 ) const ; // replace magic number
/// Returns true if the matrix is all zeros, except for ones on diagonal. (it
/// Returns true if the matrix is all zeros, except for ones on diagonal.
( it
/// does not have to be square). More specifically, this function returns
/// false if for any i, j, (*this)(i, j) differs by more than cutoff from the
/// false if for any i, j, (*this)(i, j) differs by more than cutoff from
the
/// expression (i == j ? 1 : 0).
bool IsUnit ( Real cutoff = 1.0e-05 ) const ; // replace magic number
/// Returns true if matrix is all zeros.
bool IsZero ( Real cutoff = 1.0e-05 ) const ; // replace magic number
/// Frobenius norm, which is the sqrt of sum of square elements. Same as Schatten 2-norm,
/// Frobenius norm, which is the sqrt of sum of square elements. Same as
Schatten 2 - norm ,
/// or just "2-norm".
Real FrobeniusNorm ( ) const ;
@ -461,7 +484,8 @@ class MatrixBase {
/// Sets each element to the Heaviside step function (x > 0 ? 1 : 0) of the
/// corresponding element in "src". Note: in general you can make different
/// choices for x = 0, but for now please leave it as it (i.e. returning zero)
/// choices for x = 0, but for now please leave it as it (i.e. returning
zero )
/// because it affects the RectifiedLinearComponent in the neural net code.
void Heaviside ( const MatrixBase < Real > & src ) ;
@ -477,7 +501,8 @@ class MatrixBase {
/// If the power is negative and the input to the power is zero,
/// The output will be set zero. If include_sign is true, it will
/// multiply the result by the sign of the input.
void PowAbs ( const MatrixBase < Real > & src , Real power , bool include_sign = false ) ;
void PowAbs ( const MatrixBase < Real > & src , Real power , bool
include_sign = false ) ;
void Floor ( const MatrixBase < Real > & src , Real floor_val ) ;
@ -492,36 +517,52 @@ class MatrixBase {
/// Floor(src, lower_limit);
/// Ceiling(src, upper_limit);
/// Exp(src)
void ExpLimited ( const MatrixBase < Real > & src , Real lower_limit , Real upper_limit ) ;
void ExpLimited ( const MatrixBase < Real > & src , Real lower_limit , Real
upper_limit ) ;
/// Set each element to y = log(1 + exp(x))
void SoftHinge ( const MatrixBase < Real > & src ) ;
/// Apply the function y(i) = (sum_{j = i*G}^{(i+1)*G-1} x_j^(power))^(1 / p).
/// Requires src.NumRows() == this->NumRows() and src.NumCols() % this->NumCols() == 0.
/// Apply the function y(i) = (sum_{j = i*G}^{(i+1)*G-1} x_j^(power))^(1 /
p ) .
/// Requires src.NumRows() == this->NumRows() and src.NumCols() %
this - > NumCols ( ) = = 0.
void GroupPnorm ( const MatrixBase < Real > & src , Real power ) ;
/// Calculate derivatives for the GroupPnorm function above...
/// if "input" is the input to the GroupPnorm function above (i.e. the "src" variable),
/// and "output" is the result of the computation (i.e. the "this" of that function
/// call), and *this has the same dimension as "input", then it sets each element
/// of *this to the derivative d(output-elem)/d(input-elem) for each element of "input", where
/// "output-elem" is whichever element of output depends on that input element.
void GroupPnormDeriv ( const MatrixBase < Real > & input , const MatrixBase < Real > & output ,
/// if "input" is the input to the GroupPnorm function above (i.e. the "src"
variable ) ,
/// and "output" is the result of the computation (i.e. the "this" of that
function
/// call), and *this has the same dimension as "input", then it sets each
element
/// of *this to the derivative d(output-elem)/d(input-elem) for each element
of " input " , where
/// "output-elem" is whichever element of output depends on that input
element .
void GroupPnormDeriv ( const MatrixBase < Real > & input , const MatrixBase < Real >
& output ,
Real power ) ;
/// Apply the function y(i) = (max_{j = i*G}^{(i+1)*G-1} x_j
/// Requires src.NumRows() == this->NumRows() and src.NumCols() % this->NumCols() == 0.
/// Requires src.NumRows() == this->NumRows() and src.NumCols() %
this - > NumCols ( ) = = 0.
void GroupMax ( const MatrixBase < Real > & src ) ;
/// Calculate derivatives for the GroupMax function above, where
/// "input" is the input to the GroupMax function above (i.e. the "src" variable),
/// and "output" is the result of the computation (i.e. the "this" of that function
/// "input" is the input to the GroupMax function above (i.e. the "src"
variable ) ,
/// and "output" is the result of the computation (i.e. the "this" of that
function
/// call), and *this must have the same dimension as "input". Each element
/// of *this will be set to 1 if the corresponding input equals the output of
/// the group, and 0 otherwise. The equals the function derivative where it is
/// defined (it's not defined where multiple inputs in the group are equal to the output).
void GroupMaxDeriv ( const MatrixBase < Real > & input , const MatrixBase < Real > & output ) ;
/// of *this will be set to 1 if the corresponding input equals the output
of
/// the group, and 0 otherwise. The equals the function derivative where it
is
/// defined (it's not defined where multiple inputs in the group are equal
to the output ) .
void GroupMaxDeriv ( const MatrixBase < Real > & input , const MatrixBase < Real >
& output ) ;
/// Set each element to the tanh of the corresponding element of "src".
void Tanh ( const MatrixBase < Real > & src ) ;
@ -540,11 +581,14 @@ class MatrixBase {
* semi - definite matrix : ( * this ) = rP * diag ( rS ) * rP ^ T , with rP an
* orthogonal matrix so rP ^ { - 1 } = rP ^ T . Throws exception if input was not
* positive semi - definite ( check_thresh controls how stringent the check is ;
* set it to 2 to ensure it won ' t ever complain , but it will zero out negative
* set it to 2 to ensure it won ' t ever complain , but it will zero out
* negative
* dimensions in your matrix .
*
* Caution : if you want the eigenvalues , it may make more sense to convert to
* SpMatrix and use Eig ( ) function there , which uses eigenvalue decomposition
* Caution : if you want the eigenvalues , it may make more sense to convert
* to
* SpMatrix and use Eig ( ) function there , which uses eigenvalue
* decomposition
* directly rather than SVD .
*/
@ -557,18 +601,18 @@ class MatrixBase {
// Below is internal methods for Svd, user does not have to know about this.
protected :
/// Initializer, callable only from child.
explicit MatrixBase ( Real * data , MatrixIndexT cols , MatrixIndexT rows , MatrixIndexT stride ) :
data_ ( data ) , num_cols_ ( cols ) , num_rows_ ( rows ) , stride_ ( stride ) {
explicit MatrixBase ( Real * data ,
MatrixIndexT cols ,
MatrixIndexT rows ,
MatrixIndexT stride )
: data_ ( data ) , num_cols_ ( cols ) , num_rows_ ( rows ) , stride_ ( stride ) {
KALDI_ASSERT_IS_FLOATING_TYPE ( Real ) ;
}
/// Initializer, callable only from child.
/// Empty initializer, for un-initialized matrix.
explicit MatrixBase ( ) : data_ ( NULL ) {
KALDI_ASSERT_IS_FLOATING_TYPE ( Real ) ;
}
explicit MatrixBase ( ) : data_ ( NULL ) { KALDI_ASSERT_IS_FLOATING_TYPE ( Real ) ; }
// Make sure pointers to MatrixBase cannot be deleted.
~ MatrixBase ( ) { }
@ -578,9 +622,7 @@ class MatrixBase {
/// "public const" inheritance or anything like that, so it would require
/// a lot of work to make the SubMatrix class totally const-correct--
/// we would have to override many of the Matrix functions.
inline Real * Data_workaround ( ) const {
return data_ ;
}
inline Real * Data_workaround ( ) const { return data_ ; }
/// data memory area
Real * data_ ;
@ -592,6 +634,7 @@ class MatrixBase {
/** True number of columns for the internal matrix. This number may differ
* from num_cols_ as memory alignment might be used . */
MatrixIndexT stride_ ;
private :
KALDI_DISALLOW_COPY_AND_ASSIGN ( MatrixBase ) ;
} ;
@ -600,15 +643,17 @@ class MatrixBase {
template < typename Real >
class Matrix : public MatrixBase < Real > {
public :
/// Empty constructor.
Matrix ( ) ;
/// Basic constructor.
Matrix ( const MatrixIndexT r , const MatrixIndexT c ,
Matrix ( const MatrixIndexT r ,
const MatrixIndexT c ,
MatrixResizeType resize_type = kSetZero ,
MatrixStrideType stride_type = kDefaultStride ) :
MatrixBase < Real > ( ) { Resize ( r , c , resize_type , stride_type ) ; }
MatrixStrideType stride_type = kDefaultStride )
: MatrixBase < Real > ( ) {
Resize ( r , c , resize_type , stride_type ) ;
}
/// Swaps the contents of *this and *other. Shallow swap.
void Swap ( Matrix < Real > * other ) ;
@ -694,13 +739,14 @@ class Matrix : public MatrixBase<Real> {
void Destroy ( ) ;
/// Init assumes the current class contents are invalid (i.e. junk or have
/// already been freed), and it sets the matrix to newly allocated memory with
/// the specified number of rows and columns. r == c == 0 is acceptable. The data
/// already been freed), and it sets the matrix to newly allocated memory
/// with
/// the specified number of rows and columns. r == c == 0 is acceptable.
/// The data
/// memory contents will be undefined.
void Init ( const MatrixIndexT r ,
const MatrixIndexT c ,
const MatrixStrideType stride_type ) ;
} ;
/// @} end "addtogroup matrix_group"
@ -735,9 +781,9 @@ class SubMatrix : public MatrixBase<Real> {
/// This type of constructor is needed for Range() to work [in Matrix base
/// class]. Cannot make it explicit.
SubMatrix < Real > ( const SubMatrix & other ) :
MatrixBase < Real > ( other . data_ , other . num_cols_ , other . num_rows_ ,
other . stride_ ) { }
SubMatrix < Real > ( const SubMatrix & other )
: MatrixBase < Real > (
other . data_ , other . num_cols_ , other . num_rows_ , other . stride_ ) { }
private :
/// Disallow assignment.
@ -794,25 +840,33 @@ Real TraceMatMatMatMat(const MatrixBase<Real> &A, MatrixTransposeType transA,
/// the same as U->NumCols(), and we sort s from greatest to least absolute
/// value (if sort_on_absolute_value == true) or greatest to least value
/// otherwise, moving the columns of U, if it exists, and the rows of Vt, if it
/// exists, around in the same way. Note: the "absolute value" part won't matter
/// exists, around in the same way. Note: the "absolute value" part won't
matter
/// if this is an actual SVD, since singular values are non-negative.
template < typename Real > void SortSvd ( VectorBase < Real > * s , MatrixBase < Real > * U ,
MatrixBase < Real > * Vt = NULL ,
bool sort_on_absolute_value = true ) ;
/// Creates the eigenvalue matrix D that is part of the decomposition used Matrix::Eig.
/// Creates the eigenvalue matrix D that is part of the decomposition used
Matrix : : Eig .
/// D will be block-diagonal with blocks of size 1 (for real eigenvalues) or 2x2
/// for complex pairs. If a complex pair is lambda +- i*mu, D will have a corresponding
/// for complex pairs. If a complex pair is lambda +- i*mu, D will have a
corresponding
/// 2x2 block [lambda, mu; -mu, lambda].
/// This function will throw if any complex eigenvalues are not in complex conjugate
/// This function will throw if any complex eigenvalues are not in complex
conjugate
/// pairs (or the members of such pairs are not consecutively numbered).
template < typename Real >
void CreateEigenvalueMatrix ( const VectorBase < Real > & real , const VectorBase < Real > & imag ,
void CreateEigenvalueMatrix ( const VectorBase < Real > & real , const VectorBase < Real >
& imag ,
MatrixBase < Real > * D ) ;
/// The following function is used in Matrix::Power, and separately tested, so we
/// declare it here mainly for the testing code to see. It takes a complex value to
/// a power using a method that will work for noninteger powers (but will fail if the
/// The following function is used in Matrix::Power, and separately tested, so
we
/// declare it here mainly for the testing code to see. It takes a complex
value to
/// a power using a method that will work for noninteger powers (but will fail
if the
/// complex value is real and negative).
template < typename Real >
bool AttemptComplexPower ( Real * x_re , Real * x_im , Real power ) ;
@ -844,7 +898,6 @@ bool SameDim(const MatrixBase<Real> &M, const MatrixBase<Real> &N) {
} // namespace kaldi
// we need to include the implementation and some
// template specializations.
# include "matrix/kaldi-matrix-inl.h"
Hui Zhang
2 years ago
committed by
GitHub