SparseVector< Real > Class Template Reference

#include <sparse-matrix.h>

Collaboration diagram for SparseVector< Real >:

Public Member Functions
MatrixIndexT	Dim () const
Real	Sum () const
template<class OtherReal >
void	CopyElementsToVec (VectorBase< OtherReal > *vec) const
template<class OtherReal >
void	AddToVec (Real alpha, VectorBase< OtherReal > *vec) const
template<class OtherReal >
void	CopyFromSvec (const SparseVector< OtherReal > &other)
SparseVector< Real > &	operator= (const SparseVector< Real > &other)
	SparseVector (const SparseVector< Real > &other)
void	Swap (SparseVector< Real > *other)
Real	Max (int32 *index) const
MatrixIndexT	NumElements () const
	Returns the number of nonzero elements. More...
const std::pair< MatrixIndexT, Real > &	GetElement (MatrixIndexT i) const
	get an indexed element (0 <= i < NumElements()). More...
std::pair< MatrixIndexT, Real > *	Data ()
const std::pair< MatrixIndexT, Real > *	Data () const
void	SetRandn (BaseFloat zero_prob)
	Sets elements to zero with probability zero_prob, else normally distributed. More...
	SparseVector ()
	SparseVector (MatrixIndexT dim)
	SparseVector (MatrixIndexT dim, const std::vector< std::pair< MatrixIndexT, Real > > &pairs)
	SparseVector (const VectorBase< Real > &vec)
void	Resize (MatrixIndexT dim, MatrixResizeType resize_type=kSetZero)
	Resizes to this dimension. More...
void	Write (std::ostream &os, bool binary) const
void	Read (std::istream &os, bool binary)
void	Scale (Real alpha)
	Scale all elements of sparse vector. More...

Private Attributes
MatrixIndexT	dim_
std::vector< std::pair< MatrixIndexT, Real > >	pairs_

Detailed Description

template<typename Real>
class kaldi::SparseVector< Real >

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

Constructor & Destructor Documentation

SparseVector() [1/5]

SparseVector ( const SparseVector< Real > &  other )

inline

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

References SparseVector< Real >::Max(), and SparseVector< Real >::Swap().

{ *this = other; }

SparseVector() [2/5]

SparseVector ( )

inline

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

Referenced by SparseVector< Real >::SparseVector().

: dim_(0) { }

SparseVector() [3/5]

SparseVector ( MatrixIndexT  dim )

inlineexplicit

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

References KALDI_ASSERT, kaldi::kSetZero, SparseVector< Real >::Read(), SparseVector< Real >::Resize(), SparseVector< Real >::Scale(), SparseVector< Real >::SparseVector(), and SparseVector< Real >::Write().

: dim_(dim) { KALDI_ASSERT(dim >= 0); }

SparseVector() [4/5]

SparseVector	(	MatrixIndexT	dim,
		const std::vector< std::pair< MatrixIndexT, Real > > &	pairs
	)

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

References SparseVector< Real >::dim_, KALDI_ASSERT, and SparseVector< Real >::pairs_.

                                                                           :
    dim_(dim),
    pairs_(pairs) {
  std::sort(pairs_.begin(), pairs_.end(),
            sparse_vector_utils::CompareFirst<Real>());
  typename std::vector<std::pair<MatrixIndexT, Real> >::iterator
      out = pairs_.begin(), in = out,  end = pairs_.end();
  // special case: while there is nothing to be changed, skip over
  // initial input (avoids unnecessary copying).
  while (in + 1 < end && in[0].first != in[1].first && in[0].second != 0.0) {
    in++;
    out++;
  }
  while (in < end) {
    // We reach this point only at the first element of
    // each stretch of identical .first elements.
    *out = *in;
    ++in;
    while (in < end && in->first == out->first) {
      out->second += in->second;  // this is the merge operation.
      ++in;
    }
    if (out->second != Real(0.0))  // Don't keep zero elements.
      out++;
  }
  pairs_.erase(out, end);
  if (!pairs_.empty()) {
    // range check.
    KALDI_ASSERT(pairs_.front().first >= 0 && pairs_.back().first < dim_);
  }
}

SparseVector() [5/5]

SparseVector ( const VectorBase< Real > &  vec )

explicit

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

References VectorBase< Real >::Data(), VectorBase< Real >::Dim(), and rnnlm::i.

                                                            {
  MatrixIndexT dim = vec.Dim();
  dim_ = dim;
  if (dim == 0)
    return;
  const Real *ptr = vec.Data();
  for (MatrixIndexT i = 0; i < dim; i++) {
    Real val = ptr[i];
    if (val != 0.0)
      pairs_.push_back(std::pair<MatrixIndexT,Real>(i,val));
  }
}

Member Function Documentation

AddToVec()

template void AddToVec	(	Real	alpha,
		VectorBase< OtherReal > *	vec
	)		const

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

References VectorBase< Real >::Data(), VectorBase< Real >::Dim(), and KALDI_ASSERT.

Referenced by SparseVector< Real >::Dim(), and kaldi::UnitTestSparseVectorAddToVec().

                                                                    {
  KALDI_ASSERT(vec->Dim() == dim_);
  OtherReal *other_data = vec->Data();
  typename std::vector<std::pair<MatrixIndexT, Real> >::const_iterator
      iter = pairs_.begin(), end = pairs_.end();
  if (alpha == 1.0) {  // treat alpha==1.0 case specially.
    for (; iter != end; ++iter)
      other_data[iter->first] += iter->second;
  } else {
    for (; iter != end; ++iter)
      other_data[iter->first] += alpha * iter->second;
  }
}

CopyElementsToVec()

template void CopyElementsToVec

(

VectorBase< OtherReal > *

vec

)

const

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

References VectorBase< Real >::Data(), VectorBase< Real >::Dim(), KALDI_ASSERT, and VectorBase< Real >::SetZero().

Referenced by SparseVector< Real >::Dim(), kaldi::UnitTestSparseVectorAddToVec(), kaldi::UnitTestSparseVectorMax(), kaldi::UnitTestSparseVectorSum(), and kaldi::UnitTestSparseVectorVecSvec().

                                                                           {
  KALDI_ASSERT(vec->Dim() == this->dim_);
  vec->SetZero();
  OtherReal *other_data = vec->Data();
  typename std::vector<std::pair<MatrixIndexT, Real> >::const_iterator
      iter = pairs_.begin(), end = pairs_.end();
  for (; iter != end; ++iter)
    other_data[iter->first] = iter->second;
}

CopyFromSvec()

template void CopyFromSvec

(

const SparseVector< OtherReal > &

other

)

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

References SparseVector< Real >::Dim(), SparseVector< Real >::GetElement(), rnnlm::i, and SparseVector< Real >::NumElements().

Referenced by SparseVector< Real >::Dim().

                                                                          {
  dim_ = other.Dim();
  pairs_.clear();
  if (dim_ == 0) return;
  for (int32 i = 0; i < other.NumElements(); ++i) {
    pairs_.push_back(std::make_pair(
        other.GetElement(i).first,
        static_cast<Real>(other.GetElement(i).second)));
  }
}

Data() [1/2]

std::pair< MatrixIndexT, Real > * Data

(

)

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

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), SparseMatrix< float >::AddToMat(), SparseMatrix< float >::CopyToMat(), SparseVector< Real >::GetElement(), SparseMatrix< float >::SparseMatrix(), kaldi::TraceMatSmat(), and kaldi::VecSvec().

                                                      {
  if (pairs_.empty())
    return NULL;
  else
    return &(pairs_[0]);
}

Data() [2/2]

const std::pair< MatrixIndexT, Real > * Data

(

)

const

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

                                                                  {
  if (pairs_.empty())
    return NULL;
  else
    return &(pairs_[0]);
}

Dim()

MatrixIndexT Dim ( ) const

inline

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

References SparseVector< Real >::AddToVec(), SparseVector< Real >::CopyElementsToVec(), SparseVector< Real >::CopyFromSvec(), SparseVector< Real >::dim_, SparseVector< Real >::operator=(), and SparseVector< Real >::Sum().

Referenced by SparseVector< Real >::CopyFromSvec(), SparseMatrix< float >::SetRow(), and kaldi::VecSvec().

{ return dim_; }

GetElement()

const std::pair<MatrixIndexT, Real>& GetElement ( MatrixIndexT  i ) const

inline

get an indexed element (0 <= i < NumElements()).

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

References SparseVector< Real >::Data(), rnnlm::i, SparseVector< Real >::pairs_, and SparseVector< Real >::SetRandn().

Referenced by MatrixBase< float >::AddMatSmat(), MatrixBase< float >::AddSmat(), MatrixBase< float >::AddSmatMat(), and SparseVector< Real >::CopyFromSvec().

                                                                      {
    return pairs_[i];
  }

Max()

Real Max

(

int32 *

index

)

const

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

References KALDI_ASSERT.

Referenced by kaldi::nnet3::ComputeAccuracy(), SparseVector< Real >::SparseVector(), and kaldi::UnitTestSparseVectorMax().

                                                   {
  KALDI_ASSERT(dim_ > 0 && pairs_.size() <= static_cast<size_t>(dim_));
  Real ans = -std::numeric_limits<Real>::infinity();
  int32 index = 0;
  typename std::vector<std::pair<MatrixIndexT, Real> >::const_iterator
      iter = pairs_.begin(), end = pairs_.end();
  for (; iter != end; ++iter) {
    if (iter->second > ans) {
      ans = iter->second;
      index = iter->first;
    }
  }
  if (ans >= 0 || pairs_.size() == dim_) {
    // ans >= 0 will be the normal case.
    // if pairs_.size() == dim_ then we need to return
    // even a negative answer as there are no spaces (hence no unlisted zeros).
    *index_out = index;
    return ans;
  }
  // all the stored elements are < 0, but there are unlisted
  // elements -> pick the first unlisted element.
  // Note that this class requires that the indexes are sorted
  // and unique.
  index = 0;  // "index" will always be the next index, that
              // we haven't seen listed yet.
  iter = pairs_.begin();
  for (; iter != end; ++iter) {
    if (iter->first > index) {  // index "index" is not listed.
      *index_out = index;
      return 0.0;
    } else {
      // index is the next potential gap in the indexes.
      index = iter->first + 1;
    }
  }
  // we can reach here if either pairs_.empty(), or
  // pairs_ is nonempty but contains a sequence (0, 1, 2,...).
  if (!pairs_.empty())
    index = pairs_.back().first + 1;
  // else leave index at zero
  KALDI_ASSERT(index < dim_);
  *index_out = index;
  return 0.0;
}

NumElements()

MatrixIndexT NumElements ( ) const

inline

Returns the number of nonzero elements.

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

References SparseVector< Real >::pairs_.

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), MatrixBase< float >::AddMatSmat(), MatrixBase< float >::AddSmat(), MatrixBase< float >::AddSmatMat(), SparseMatrix< float >::AddToMat(), SparseMatrix< float >::CopyElementsToVec(), SparseVector< Real >::CopyFromSvec(), SparseMatrix< float >::CopyToMat(), kaldi::TraceMatSmat(), and kaldi::VecSvec().

{ return pairs_.size(); }

operator=()

SparseVector< Real > & operator=

(

const SparseVector< Real > &

other

)

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

References SparseVector< Real >::dim_, and SparseVector< Real >::pairs_.

Referenced by SparseVector< Real >::Dim(), and GeneralMatrix::GeneralMatrix().

                                     {
  this->CopyFromSvec(other);
  dim_ = other.dim_;
  pairs_ = other.pairs_;
  return *this;
}

Read()

void Read	(	std::istream &	os,
		bool	binary
	)

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

References kaldi::ExpectToken(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, and kaldi::ReadBasicType().

Referenced by SparseMatrix< float >::Read(), SparseMatrix< float >::SparseMatrix(), and SparseVector< Real >::SparseVector().

                                                         {
  if (binary) {
    ExpectToken(is, binary, "SV");
    ReadBasicType(is, binary, &dim_);
    KALDI_ASSERT(dim_ >= 0);
    int32 num_elems;
    ReadBasicType(is, binary, &num_elems);
    KALDI_ASSERT(num_elems >= 0 && num_elems <= dim_);
    pairs_.resize(num_elems);
    typename std::vector<std::pair<MatrixIndexT, Real> >::iterator
        iter = pairs_.begin(), end = pairs_.end();
    for (; iter != end; ++iter) {
      ReadBasicType(is, binary, &(iter->first));
      ReadBasicType(is, binary, &(iter->second));
    }
  } else {
    // In text-mode, format is "dim=5 [ 0 0.2 3 0.9 ]
    std::string str;
    is >> str;
    if (str.substr(0, 4) != "dim=")
      KALDI_ERR << "Reading sparse vector, expected 'dim=xxx', got " << str;
    std::string dim_str = str.substr(4, std::string::npos);
    std::istringstream dim_istr(dim_str);
    int32 dim = -1;
    dim_istr >> dim;
    if (dim < 0 || dim_istr.fail()) {
      KALDI_ERR << "Reading sparse vector, expected 'dim=[int]', got " << str;
    }
    dim_ = dim;
    is >> std::ws;
    is >> str;
    if (str != "[")
      KALDI_ERR << "Reading sparse vector, expected '[', got " << str;
    pairs_.clear();
    while (1) {
      is >> std::ws;
      if (is.peek() == ']') {
        is.get();
        break;
      }
      MatrixIndexT i;
      BaseFloat p;
      is >> i >> p;
      if (is.fail())
        KALDI_ERR << "Error reading sparse vector, expecting numbers.";
      KALDI_ASSERT(i >= 0 && i < dim
                   && (pairs_.empty() || i > pairs_.back().first));
      pairs_.push_back(std::pair<MatrixIndexT, BaseFloat>(i, p));
    }
  }
}

Resize()

void Resize	(	MatrixIndexT	dim,
		MatrixResizeType	resize_type = kSetZero
	)

Resizes to this dimension.

resize_type == kUndefined behaves the same as kSetZero.

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

References SparseVector< Real >::dim_, KALDI_ASSERT, kaldi::kCopyData, and SparseVector< Real >::pairs_.

Referenced by SparseMatrix< float >::SelectRows(), SparseMatrix< float >::SparseMatrix(), and SparseVector< Real >::SparseVector().

                                                              {
  if (resize_type != kCopyData || dim == 0)
    pairs_.clear();
  KALDI_ASSERT(dim >= 0);
  if (dim < dim_ && resize_type == kCopyData)
    while (!pairs_.empty() && pairs_.back().first >= dim)
      pairs_.pop_back();
  dim_ = dim;
}

Scale()

void Scale

(

Real

alpha

)

Scale all elements of sparse vector.

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

References rnnlm::i.

Referenced by SparseMatrix< float >::SparseMatrix(), and SparseVector< Real >::SparseVector().

                                         {
  for (int32 i = 0; i < pairs_.size(); ++i)
    pairs_[i].second *= alpha;
}

SetRandn()

void SetRandn

(

BaseFloat

zero_prob

)

Sets elements to zero with probability zero_prob, else normally distributed.

Useful in testing.

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

References SparseVector< Real >::dim_, rnnlm::i, KALDI_ASSERT, SparseVector< Real >::pairs_, kaldi::RandGauss(), and kaldi::WithProb().

Referenced by SparseVector< Real >::GetElement(), SparseMatrix< float >::SparseMatrix(), kaldi::UnitTestSparseVectorAddToVec(), kaldi::UnitTestSparseVectorMax(), kaldi::UnitTestSparseVectorSum(), and kaldi::UnitTestSparseVectorVecSvec().

                                                     {
  pairs_.clear();
  KALDI_ASSERT(zero_prob >= 0 && zero_prob <= 1.0);
  for (MatrixIndexT i = 0; i < dim_; i++)
    if (WithProb(1.0 - zero_prob))
      pairs_.push_back(std::pair<MatrixIndexT, Real>(i, RandGauss()));
}

Sum()

Real Sum

(

)

const

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

References rnnlm::i.

Referenced by kaldi::nnet3::ComputeAccuracy(), SparseVector< Real >::Dim(), and kaldi::UnitTestSparseVectorSum().

                                   {
  Real sum = 0;
  for (int32 i = 0; i < pairs_.size(); ++i) {
    sum += pairs_[i].second;
  }
  return sum;
}

Swap()

void Swap

(

SparseVector< Real > *

other

)

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

References SparseVector< Real >::dim_, SparseVector< Real >::pairs_, and kaldi::swap().

Referenced by SparseMatrix< float >::CopyFromSmat(), GeneralMatrix::GeneralMatrix(), SparseMatrix< float >::SparseMatrix(), and SparseVector< Real >::SparseVector().

                                                       {
  pairs_.swap(other->pairs_);
  std::swap(dim_, other->dim_);
}

Write()

void Write	(	std::ostream &	os,
		bool	binary
	)		const

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

References kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by SparseMatrix< float >::SparseMatrix(), SparseVector< Real >::SparseVector(), and SparseMatrix< float >::Write().

                                                                {
  if (binary) {
    WriteToken(os, binary, "SV");
    WriteBasicType(os, binary, dim_);
    MatrixIndexT num_elems = pairs_.size();
    WriteBasicType(os, binary, num_elems);
    typename std::vector<std::pair<MatrixIndexT, Real> >::const_iterator
        iter = pairs_.begin(), end = pairs_.end();
    for (; iter != end; ++iter) {
      WriteBasicType(os, binary, iter->first);
      WriteBasicType(os, binary, iter->second);
    }
  } else {
    // In text-mode, use a human-friendly, script-friendly format;
    // format is "dim=5 [ 0 0.2 3 0.9 ] "
    os << "dim=" << dim_ << " [ ";
    typename std::vector<std::pair<MatrixIndexT, Real> >::const_iterator
        iter = pairs_.begin(), end = pairs_.end();
    for (; iter != end; ++iter)
      os << iter->first << ' ' << iter->second << ' ';
    os << "] ";
  }
}

Member Data Documentation

dim_

MatrixIndexT dim_

private

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

Referenced by SparseVector< Real >::Dim(), SparseVector< Real >::operator=(), SparseVector< Real >::Resize(), SparseVector< Real >::SetRandn(), SparseVector< Real >::SparseVector(), and SparseVector< Real >::Swap().

pairs_

std::vector<std::pair<MatrixIndexT, Real> > pairs_

private

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

Referenced by SparseVector< Real >::GetElement(), SparseVector< Real >::NumElements(), SparseVector< Real >::operator=(), SparseVector< Real >::Resize(), SparseVector< Real >::SetRandn(), SparseVector< Real >::SparseVector(), and SparseVector< Real >::Swap().

---

The documentation for this class was generated from the following files:

• matrix/sparse-matrix.h
• matrix/sparse-matrix.cc