ContextDependency Class Reference

#include <context-dep.h>

Inheritance diagram for ContextDependency:

Collaboration diagram for ContextDependency:

Public Member Functions
virtual int32	ContextWidth () const
	ContextWidth() returns the value N (e.g. More...
virtual int32	CentralPosition () const
	Central position P of the phone context, in 0-based numbering, e.g. More...
virtual bool	Compute (const std::vector< int32 > &phoneseq, int32 pdf_class, int32 *pdf_id) const
	returns success or failure; outputs pdf to pdf_id For positions that were outside the sequence (due to end effects), put zero. More...
virtual int32	NumPdfs () const
	NumPdfs() returns the number of acoustic pdfs (they are numbered 0.. NumPdfs()-1). More...
virtual ContextDependencyInterface *	Copy () const
	Returns pointer to new object which is copy of current one. More...
void	Read (std::istream &is, bool binary)
	Read context-dependency object from disk; throws on error. More...
	ContextDependency ()
	ContextDependency (int32 N, int32 P, EventMap *to_pdf)
void	Write (std::ostream &os, bool binary) const
	~ContextDependency ()
const EventMap &	ToPdfMap () const
virtual void	GetPdfInfo (const std::vector< int32 > &phones, const std::vector< int32 > &num_pdf_classes, std::vector< std::vector< std::pair< int32, int32 > > > *pdf_info) const
	GetPdfInfo returns a vector indexed by pdf-id, saying for each pdf which pairs of (phone, pdf-class) it can correspond to. More...
virtual void	GetPdfInfo (const std::vector< int32 > &phones, const std::vector< std::vector< std::pair< int32, int32 > > > &pdf_class_pairs, std::vector< std::vector< std::vector< std::pair< int32, int32 > > > > *pdf_info) const
	This function outputs information about what possible pdf-ids can be generated for HMM-states; it covers the general case where the self-loop pdf-class may be different from the forward-transition pdf-class, so we are asking not about the set of possible pdf-ids for a given (phone, pdf-class), but the set of possible ordered pairs (forward-transition-pdf, self-loop-pdf) for a given (phone, forward-transition-pdf-class, self-loop-pdf-class). More...
Public Member Functions inherited from ContextDependencyInterface
virtual	~ContextDependencyInterface ()
	ContextDependencyInterface ()

Private Member Functions
void	EnumeratePairs (const std::vector< int32 > &phones, int32 self_loop_pdf_class, int32 forward_pdf_class, const std::vector< int32 > &context, unordered_set< std::pair< int32, int32 >, PairHasher< int32 > > *pairs) const
	KALDI_DISALLOW_COPY_AND_ASSIGN (ContextDependency)

Private Attributes
int32	N_
int32	P_
EventMap *	to_pdf_

Detailed Description

Definition at line 59 of file context-dep.h.

Constructor & Destructor Documentation

ContextDependency() [1/2]

ContextDependency ( )

inline

Definition at line 88 of file context-dep.h.

Referenced by ContextDependency::Copy(), kaldi::GenRandContextDependency(), kaldi::GenRandContextDependencyLarge(), kaldi::MonophoneContextDependency(), and kaldi::MonophoneContextDependencyShared().

: N_(0), P_(0), to_pdf_(NULL) { }

ContextDependency() [2/2]

ContextDependency ( int32  N, int32  P, EventMap *  to_pdf  )

inline

Definition at line 91 of file context-dep.h.

References ContextDependency::Write().

                                     :
      N_(N), P_(P), to_pdf_(to_pdf) { }

~ContextDependency()

~ContextDependency ( )

inline

Definition at line 96 of file context-dep.h.

References ContextDependency::to_pdf_.

{ delete to_pdf_; }

Member Function Documentation

CentralPosition()

virtual int32 CentralPosition ( ) const

inlinevirtual

Central position P of the phone context, in 0-based numbering, e.g.

P = 1 for typical triphone system. We have to see if we can do without this function.

Implements ContextDependencyInterface.

Definition at line 62 of file context-dep.h.

References ContextDependency::Compute(), and ContextDependency::P_.

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), kaldi::InitAmGmmFromOld(), main(), and TrainingGraphCompiler::TrainingGraphCompiler().

{ return P_; }

Compute()

bool Compute ( const std::vector< int32 > &  phoneseq, int32  pdf_class, int32 *  pdf_id  ) const

virtual

returns success or failure; outputs pdf to pdf_id For positions that were outside the sequence (due to end effects), put zero.

Naturally phoneseq[CentralPosition()] must be nonzero.

Implements ContextDependencyInterface.

Definition at line 26 of file context-dep.cc.

References rnnlm::i, KALDI_ASSERT, KALDI_COMPILE_TIME_ASSERT, kaldi::kPdfClass, EventMap::Map(), ContextDependency::N_, and ContextDependency::to_pdf_.

Referenced by ContextDependency::CentralPosition().

                                                      {
  KALDI_ASSERT(static_cast<int32>(phoneseq.size()) == N_);
  EventType  event_vec;
  event_vec.reserve(N_+1);
  event_vec.push_back(std::make_pair
                      (static_cast<EventKeyType>(kPdfClass),  // -1
                       static_cast<EventValueType>(pdf_class)));
  KALDI_COMPILE_TIME_ASSERT(kPdfClass < 0);  // or it would not be sorted.
  for (int32 i = 0;i < N_;i++) {
    event_vec.push_back(std::make_pair
                        (static_cast<EventKeyType>(i),
                         static_cast<EventValueType>(phoneseq[i])));
    KALDI_ASSERT(static_cast<EventAnswerType>(phoneseq[i]) >= 0);
  }
  KALDI_ASSERT(pdf_id != NULL);
  return to_pdf_->Map(event_vec, pdf_id);
}

ContextWidth()

virtual int32 ContextWidth ( ) const

inlinevirtual

ContextWidth() returns the value N (e.g.

3 for triphone models) that says how many phones are considered for computing context.

Implements ContextDependencyInterface.

Definition at line 61 of file context-dep.h.

References ContextDependency::N_.

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), kaldi::InitAmGmmFromOld(), main(), and TrainingGraphCompiler::TrainingGraphCompiler().

{ return N_; }

Copy()

virtual ContextDependencyInterface* Copy ( ) const

inlinevirtual

Returns pointer to new object which is copy of current one.

Implements ContextDependencyInterface.

Definition at line 79 of file context-dep.h.

References ContextDependency::ContextDependency(), EventMap::Copy(), ContextDependency::N_, ContextDependency::P_, ContextDependency::Read(), and ContextDependency::to_pdf_.

                                                   {
    return new ContextDependency(N_, P_, to_pdf_->Copy());
  }

EnumeratePairs()

void EnumeratePairs ( const std::vector< int32 > &  phones, int32  self_loop_pdf_class, int32  forward_pdf_class, const std::vector< int32 > &  context, unordered_set< std::pair< int32, int32 >, PairHasher< int32 > > *  pairs  ) const

private

Definition at line 181 of file context-dep.cc.

References rnnlm::i, KALDI_ASSERT, kaldi::kPdfClass, EventMap::MultiMap(), rnnlm::n, ContextDependency::N_, ContextDependency::P_, kaldi::SortAndUniq(), and ContextDependency::to_pdf_.

Referenced by ContextDependency::GetPdfInfo().

                                                                           {
  std::vector<int32> new_phone_window(phone_window);
  EventType vec;

  std::vector<EventAnswerType> forward_pdfs, self_loop_pdfs;

  // get list of possible forward pdfs
  vec.clear();
  for (size_t i = 0; i < N_; i++)
    if (phone_window[i] >= 0)
      vec.push_back(std::make_pair(static_cast<EventKeyType>(i),
                                   static_cast<EventValueType>(phone_window[i])));
  vec.push_back(std::make_pair(kPdfClass, static_cast<EventValueType>(forward_pdf_class)));
  std::sort(vec.begin(), vec.end());
  to_pdf_->MultiMap(vec, &forward_pdfs);
  SortAndUniq(&forward_pdfs);

  if (self_loop_pdf_class < 0) {
    // Invalid pdf-class because there was no self-loop.  Return pairs
    // where the self-loop pdf-id is -1.
    for (int32 forward_pdf: forward_pdfs) {
      pairs->insert(std::pair<int32,int32>(forward_pdf, -1));
    }
    return;
  }

  // get list of possible self-loop pdfs
  vec.clear();
  for (size_t i = 0; i < N_; i++)
    if (phone_window[i] >= 0)
      vec.push_back(std::make_pair(static_cast<EventKeyType>(i),
                                   static_cast<EventValueType>(phone_window[i])));
  vec.push_back(std::make_pair(kPdfClass, static_cast<EventValueType>(self_loop_pdf_class)));
  std::sort(vec.begin(), vec.end());
  to_pdf_->MultiMap(vec, &self_loop_pdfs);
  SortAndUniq(&self_loop_pdfs);

  if (forward_pdfs.size() == 1 || self_loop_pdfs.size() == 1) {
    for (size_t m = 0; m < forward_pdfs.size(); m++)
      for (size_t n = 0; n < self_loop_pdfs.size(); n++)
        pairs->insert(std::make_pair(forward_pdfs[m], self_loop_pdfs[n]));
  } else {
    // Choose 'position' as a phone position in 'context' that's currently
    // -1, and that is as close as possible to the central position P.
    int32 position = 0;
    int32 min_dist = N_ - 1;
    for (int32 i = 0; i < N_; i++) {
      int32 dist = (P_ - i > 0) ? (P_ - i) : (i - P_);
      if (phone_window[i] == -1 && dist < min_dist) {
        position = i;
        min_dist = dist;
      }
    }
    KALDI_ASSERT(min_dist < N_);
    KALDI_ASSERT(position != P_);

    // The next two lines have to do with how BOS/EOS effects are handled in
    // phone context.  Zero phone value in a non-central position (i.e. not
    // position P_...  and 'position' will never equal P_) means 'there is no
    // phone here because we're at BOS or EOS'.
    new_phone_window[position] = 0;
    EnumeratePairs(phones, self_loop_pdf_class, forward_pdf_class,
                   new_phone_window, pairs);

    for (size_t i = 0 ; i < phones.size(); i++) {
      new_phone_window[position] = phones[i];
      EnumeratePairs(phones, self_loop_pdf_class, forward_pdf_class,
                     new_phone_window, pairs);
    }
  }
}

GetPdfInfo() [1/2]

void GetPdfInfo ( const std::vector< int32 > &  phones, const std::vector< int32 > &  num_pdf_classes, std::vector< std::vector< std::pair< int32, int32 > > > *  pdf_info  ) const

virtual

GetPdfInfo returns a vector indexed by pdf-id, saying for each pdf which pairs of (phone, pdf-class) it can correspond to.

(Usually just one). c.f. hmm/hmm-topology.h for meaning of pdf-class. This is the old, simpler interface of GetPdfInfo(), and that this one can only be called if the HmmTopology object's IsHmm() function call returns true.

Implements ContextDependencyInterface.

Definition at line 287 of file context-dep.cc.

References rnnlm::i, kaldi::IsSortedAndUniq(), rnnlm::j, KALDI_ASSERT, KALDI_WARN, kaldi::kPdfClass, EventMap::MultiMap(), ContextDependency::NumPdfs(), ContextDependency::P_, kaldi::SortAndUniq(), and ContextDependency::to_pdf_.

Referenced by kaldi::TestGenRandContextDependency(), kaldi::TestMonophoneContextDependency(), and ContextDependency::ToPdfMap().

                                                                   {

  EventType vec;
  KALDI_ASSERT(pdf_info != NULL);
  pdf_info->resize(NumPdfs());
  for (size_t i = 0 ; i < phones.size(); i++) {
    int32 phone = phones[i];
    vec.clear();
    vec.push_back(std::make_pair(static_cast<EventKeyType>(P_),
                                 static_cast<EventValueType>(phone)));
    // Now get length.
    KALDI_ASSERT(static_cast<size_t>(phone) < num_pdf_classes.size());
    EventAnswerType len = num_pdf_classes[phone];

    for (int32 pos = 0; pos < len; pos++) {
      vec.resize(2);
      vec[0] = std::make_pair(static_cast<EventKeyType>(P_),
                              static_cast<EventValueType>(phone));
      vec[1] = std::make_pair(kPdfClass, static_cast<EventValueType>(pos));
      std::sort(vec.begin(), vec.end());
      std::vector<EventAnswerType> pdfs;  // pdfs that can be at this pos as this phone.
      to_pdf_->MultiMap(vec, &pdfs);
      SortAndUniq(&pdfs);
      if (pdfs.empty()) {
        KALDI_WARN << "ContextDependency::GetPdfInfo, no pdfs returned for position "<< pos << " of phone " << phone << ".   Continuing but this is a serious error.";
      }
      for (size_t j = 0; j < pdfs.size(); j++) {
        KALDI_ASSERT(static_cast<size_t>(pdfs[j]) < pdf_info->size());
        (*pdf_info)[pdfs[j]].push_back(std::make_pair(phone, pos));
      }
    }
  }
  for (size_t i = 0; i < pdf_info->size(); i++) {
    std::sort( ((*pdf_info)[i]).begin(),  ((*pdf_info)[i]).end());
    KALDI_ASSERT(IsSortedAndUniq( ((*pdf_info)[i])));  // should have no dups.
  }
}

GetPdfInfo() [2/2]

void GetPdfInfo ( const std::vector< int32 > &  phones, const std::vector< std::vector< std::pair< int32, int32 > > > &  pdf_class_pairs, std::vector< std::vector< std::vector< std::pair< int32, int32 > > > > *  pdf_info  ) const

virtual

This function outputs information about what possible pdf-ids can be generated for HMM-states; it covers the general case where the self-loop pdf-class may be different from the forward-transition pdf-class, so we are asking not about the set of possible pdf-ids for a given (phone, pdf-class), but the set of possible ordered pairs (forward-transition-pdf, self-loop-pdf) for a given (phone, forward-transition-pdf-class, self-loop-pdf-class).

Note: 'phones' is a list of integer ids of phones, and 'pdf-class-pairs', indexed by phone, is a list of pairs (forward-transition-pdf-class, self-loop-pdf-class) that we can have for that phone. The output 'pdf_info' is indexed first by phone and then by the same index that indexes each element of 'pdf_class_pairs', and tells us for each pair in 'pdf_class_pairs', what is the list of possible (forward-transition-pdf-id, self-loop-pdf-id) that we can have. This is less efficient than the other version of GetPdfInfo(). Note: if there is no self-loop, the corresponding entry (.second) in pdf_class_pairs and the output pdf_info would be -1.

Implements ContextDependencyInterface.

Definition at line 257 of file context-dep.cc.

References ContextDependency::EnumeratePairs(), rnnlm::i, rnnlm::j, KALDI_ASSERT, ContextDependency::N_, and ContextDependency::P_.

                                                                               {

  KALDI_ASSERT(pdf_info != NULL);
  pdf_info->resize(1 + *std::max_element(phones.begin(), phones.end()));
  std::vector<int32> phone_window(N_, -1);
  EventType vec;
  for (size_t i = 0 ; i < phones.size(); i++) {
    // loop over phones
    int32 phone = phones[i];
    (*pdf_info)[phone].resize(pdf_class_pairs[phone].size());
    for (size_t j = 0; j < pdf_class_pairs[phone].size(); j++) {
      // loop over pdf_class pairs
      int32 pdf_class = pdf_class_pairs[phone][j].first,
            self_loop_pdf_class = pdf_class_pairs[phone][j].second;
      phone_window[P_] = phone;

      unordered_set<std::pair<int32, int32>, PairHasher<int32> > pairs;
      EnumeratePairs(phones, self_loop_pdf_class, pdf_class, phone_window, &pairs);
      unordered_set<std::pair<int32, int32>, PairHasher<int32> >::iterator iter = pairs.begin(),
                           end = pairs.end();
      for (; iter != end; ++iter)
        (*pdf_info)[phone][j].push_back(*iter);
      std::sort( ((*pdf_info)[phone][j]).begin(),  ((*pdf_info)[phone][j]).end());
    }
  }
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( ContextDependency  )

private

NumPdfs()

virtual int32 NumPdfs ( ) const

inlinevirtual

NumPdfs() returns the number of acoustic pdfs (they are numbered 0.. NumPdfs()-1).

Implements ContextDependencyInterface.

Definition at line 71 of file context-dep.h.

References EventMap::MaxResult(), and ContextDependency::to_pdf_.

Referenced by ContextDependency::GetPdfInfo(), and main().

                                {
    // this routine could be simplified to return to_pdf_->MaxResult()+1.  we're a
    // bit more paranoid than that.
    if (!to_pdf_) return 0;
    EventAnswerType max_result = to_pdf_->MaxResult();
    if (max_result < 0 ) return 0;
    else return (int32) max_result+1;
  }

Read()

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

Read context-dependency object from disk; throws on error.

Definition at line 155 of file context-dep.cc.

References kaldi::ExpectToken(), KALDI_ERR, ContextDependency::N_, ContextDependency::P_, EventMap::Read(), kaldi::ReadBasicType(), kaldi::ReadToken(), and ContextDependency::to_pdf_.

Referenced by ContextDependency::Copy(), kaldi::InitAmGmmFromOld(), main(), and kaldi::TestGenRandContextDependency().

                                                         {
  if (to_pdf_) {
    delete to_pdf_;
    to_pdf_ = NULL;
  }
  ExpectToken(is, binary, "ContextDependency");
  ReadBasicType(is, binary, &N_);
  ReadBasicType(is, binary, &P_);
  EventMap *to_pdf = NULL;
  std::string token;
  ReadToken(is, binary, &token);
  if (token == "ToLength") {  // back-compat.
    EventMap *to_num_pdf_classes = EventMap::Read(is, binary);
    delete to_num_pdf_classes;
    ReadToken(is, binary, &token);
  }
  if (token == "ToPdf") {
    to_pdf = EventMap::Read(is , binary);
  } else {
    KALDI_ERR << "Got unexpected token " << token
              << " reading context-dependency object.";
  }
  ExpectToken(is, binary, "EndContextDependency");
  to_pdf_ = to_pdf;
}

ToPdfMap()

const EventMap& ToPdfMap ( ) const

inline

Definition at line 98 of file context-dep.h.

References ContextDependency::GetPdfInfo(), and ContextDependency::to_pdf_.

Referenced by kaldi::InitAmGmmFromOld(), and main().

{ return *to_pdf_; }

Write()

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

Definition at line 145 of file context-dep.cc.

References ContextDependency::N_, ContextDependency::P_, ContextDependency::to_pdf_, EventMap::Write(), kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by ContextDependency::ContextDependency(), main(), and kaldi::TestGenRandContextDependency().

                                                                {
  WriteToken(os, binary, "ContextDependency");
  WriteBasicType(os, binary, N_);
  WriteBasicType(os, binary, P_);
  WriteToken(os, binary, "ToPdf");
  to_pdf_->Write(os, binary);
  WriteToken(os, binary, "EndContextDependency");
}

Member Data Documentation

N_

int32 N_

private

Definition at line 138 of file context-dep.h.

Referenced by ContextDependency::Compute(), ContextDependency::ContextWidth(), ContextDependency::Copy(), ContextDependency::EnumeratePairs(), ContextDependency::GetPdfInfo(), ContextDependency::Read(), and ContextDependency::Write().

P_

int32 P_

private

Definition at line 139 of file context-dep.h.

Referenced by ContextDependency::CentralPosition(), ContextDependency::Copy(), ContextDependency::EnumeratePairs(), ContextDependency::GetPdfInfo(), ContextDependency::Read(), and ContextDependency::Write().

to_pdf_

EventMap* to_pdf_

private

Definition at line 140 of file context-dep.h.

Referenced by ContextDependency::Compute(), ContextDependency::Copy(), ContextDependency::EnumeratePairs(), ContextDependency::GetPdfInfo(), ContextDependency::NumPdfs(), ContextDependency::Read(), ContextDependency::ToPdfMap(), ContextDependency::Write(), and ContextDependency::~ContextDependency().

---

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

• tree/context-dep.h
• tree/context-dep.cc