KwsTermsAligner Class Reference

#include <kws-scoring.h>

Collaboration diagram for KwsTermsAligner:

Public Member Functions
void	AddRef (const KwsTerm &ref)
void	AddHyp (const KwsTerm &hyp)
int	nof_hyps () const
int	nof_refs () const
	KwsTermsAligner (const KwsTermsAlignerOptions &opts)
KwsAlignment	AlignTerms ()
virtual float	AlignerScore (const KwsTerm &ref, const KwsTerm &hyp)

Private Types
typedef std::vector< KwsTerm >	TermArray
typedef std::vector< KwsTerm >::iterator	TermIterator
typedef unordered_map< int, bool >	TermUseMap

Private Member Functions
int	FindBestRefIndex (const KwsTerm &term)
TermIterator	FindNextRef (const KwsTerm &hyp, const TermIterator &prev, const TermIterator &last)
bool	RefExistsMaybe (const KwsTerm &term)
void	FillUnmatchedRefs (KwsAlignment *ali)

Private Attributes
unordered_map< int, unordered_map< std::string, TermArray > >	refs_
unordered_map< int, unordered_map< std::string, TermUseMap > >	used_ref_terms_
std::list< KwsTerm >	hyps_
KwsTermsAlignerOptions	opts_
int	nof_refs_
int	nof_hyps_

Detailed Description

Definition at line 136 of file kws-scoring.h.

Member Typedef Documentation

TermArray

typedef std::vector<KwsTerm> TermArray

private

Definition at line 160 of file kws-scoring.h.

TermIterator

typedef std::vector<KwsTerm>::iterator TermIterator

private

Definition at line 161 of file kws-scoring.h.

TermUseMap

typedef unordered_map<int, bool> TermUseMap

private

Definition at line 162 of file kws-scoring.h.

Constructor & Destructor Documentation

KwsTermsAligner()

KwsTermsAligner ( const KwsTermsAlignerOptions &  opts )

explicit

Definition at line 119 of file kws-scoring.cc.

                                                                  :
  opts_(opts),
  nof_refs_(0),
  nof_hyps_(0) { }

Member Function Documentation

AddHyp()

void AddHyp ( const KwsTerm &  hyp )

inline

Definition at line 143 of file kws-scoring.h.

Referenced by main().

                                  {
    hyps_.push_back(hyp);
    nof_hyps_++;
  }

AddRef()

void AddRef ( const KwsTerm &  ref )

inline

Definition at line 138 of file kws-scoring.h.

References KwsTerm::kw_id(), and KwsTerm::utt_id().

Referenced by main().

                                  {
    refs_[ref.utt_id()][ref.kw_id()].push_back(ref);
    nof_refs_++;
  }

AlignerScore()

float AlignerScore ( const KwsTerm &  ref, const KwsTerm &  hyp  )

virtual

Definition at line 236 of file kws-scoring.cc.

References KwsTerm::end_time(), and KwsTerm::start_time().

Referenced by KwsTermsAligner::AlignTerms(), and KwsTermsAligner::FindBestRefIndex().

                                                                          {
  float overlap = std::min(ref.end_time(), hyp.end_time())
                  - std::max(ref.start_time(), hyp.start_time());
  float join = std::max(ref.end_time(), hyp.end_time())
               - std::min(ref.start_time(), hyp.start_time());
  return static_cast<float>(overlap) / join;
}

AlignTerms()

KwsAlignment AlignTerms

(

)

Definition at line 125 of file kws-scoring.cc.

References KwsAlignment::Add(), AlignedTermsPair::aligner_score, KwsTermsAligner::AlignerScore(), KwsTermsAligner::FillUnmatchedRefs(), KwsTermsAligner::FindBestRefIndex(), AlignedTermsPair::hyp, KwsTermsAligner::hyps_, KALDI_LOG, AlignedTermsPair::ref, KwsTermsAligner::refs_, KwsAlignment::size(), and KwsTermsAligner::used_ref_terms_.

Referenced by main().

                                         {
  KwsAlignment alignment;

  used_ref_terms_.clear();
  std::list<KwsTerm>::iterator it = hyps_.begin();
  for (; it != hyps_.end(); ++it) {
    AlignedTermsPair ref_hyp_pair;
    ref_hyp_pair.hyp = *it;
    ref_hyp_pair.aligner_score = -std::numeric_limits<float>::infinity();

    int ref_idx = FindBestRefIndex(*it);
    if (ref_idx >= 0) {  // If found
      int utt_id = it->utt_id();
      std::string kw_id = it->kw_id();

      ref_hyp_pair.ref = refs_[utt_id][kw_id][ref_idx];
      used_ref_terms_[utt_id][kw_id][ref_idx] = true;
      ref_hyp_pair.aligner_score = AlignerScore(ref_hyp_pair.ref,
                                                ref_hyp_pair.hyp);
    }

    alignment.Add(ref_hyp_pair);
  }
  KALDI_LOG << "Alignment size before adding unseen: " << alignment.size();
  // Finally, find the terms in ref which have not been seen in hyp
  // and add them into the alignment
  FillUnmatchedRefs(&alignment);
  KALDI_LOG << "Alignment size after  adding unseen: " << alignment.size();
  return alignment;
}

FillUnmatchedRefs()

void FillUnmatchedRefs ( KwsAlignment *  ali )

private

Definition at line 156 of file kws-scoring.cc.

References KwsAlignment::Add(), AlignedTermsPair::aligner_score, AlignedTermsPair::ref, KwsTermsAligner::refs_, and KwsTermsAligner::used_ref_terms_.

Referenced by KwsTermsAligner::AlignTerms().

                                                         {
  // We have to traverse the whole ref_ structure and check
  // against the used_ref_terms_ structure if the given ref term
  // was already used or not. If not, we will add it to the alignment
  typedef unordered_map<std::string, TermArray> KwList;
  typedef KwList::iterator KwIndex;
  typedef unordered_map<int, KwList >::iterator  UttIndex;

  for (UttIndex utt = refs_.begin(); utt != refs_.end(); ++utt) {
    int utt_id = utt->first;
    for (KwIndex kw = refs_[utt_id].begin(); kw != refs_[utt_id].end(); ++kw) {
      std::string kw_id = kw->first;
      for (TermIterator term = refs_[utt_id][kw_id].begin();
                        term != refs_[utt_id][kw_id].end(); ++term ) {
        int idx = term - refs_[utt_id][kw_id].begin();
        if (!used_ref_terms_[utt_id][kw_id][idx]) {
          AlignedTermsPair missed_hyp;
          missed_hyp.aligner_score = -std::numeric_limits<float>::infinity();
          missed_hyp.ref = refs_[utt_id][kw_id][idx];
          ali->Add(missed_hyp);
        }
      }
    }
  }
}

FindBestRefIndex()

int FindBestRefIndex ( const KwsTerm &  term )

private

Definition at line 182 of file kws-scoring.cc.

References KwsTermsAligner::AlignerScore(), KwsTermsAligner::FindNextRef(), KwsTerm::kw_id(), KwsTermsAligner::RefExistsMaybe(), KwsTermsAligner::refs_, KwsTermsAligner::used_ref_terms_, and KwsTerm::utt_id().

Referenced by KwsTermsAligner::AlignTerms().

                                                         {
  if (!RefExistsMaybe(term)) {
    return -1;
  }
  int utt_id = term.utt_id();
  std::string kw_id = term.kw_id();

  TermIterator start_mark = refs_[utt_id][kw_id].begin();
  TermIterator end_mark = refs_[utt_id][kw_id].end();

  TermIterator it = FindNextRef(term, start_mark, end_mark);
  if (it == end_mark) {
    return  -1;
  }

  int   best_ref_idx = -1;
  float best_ref_score = -std::numeric_limits<float>::infinity();
  do {
    float current_score = AlignerScore(*it, term);
    int current_index = it - start_mark;
    if ((current_score > best_ref_score) &&
        (!used_ref_terms_[utt_id][kw_id][current_index])) {
      best_ref_idx = current_index;
      best_ref_score = current_score;
    }

    it = FindNextRef(term, ++it, end_mark);
  } while (it != end_mark);

  return best_ref_idx;
}

FindNextRef()

KwsTermsAligner::TermIterator FindNextRef ( const KwsTerm &  hyp, const TermIterator &  prev, const TermIterator &  last  )

private

Definition at line 228 of file kws-scoring.cc.

References KwsTermsAlignerOptions::max_distance, and KwsTermsAligner::opts_.

Referenced by KwsTermsAligner::FindBestRefIndex().

                                                                    {
  return std::find_if(prev, last,
      kws_internal::KwTermEqual(opts_.max_distance, ref));
}

nof_hyps()

int nof_hyps ( ) const

inline

Definition at line 148 of file kws-scoring.h.

Referenced by main().

{return nof_hyps_;}

nof_refs()

int nof_refs ( ) const

inline

Definition at line 149 of file kws-scoring.h.

Referenced by main().

{return nof_refs_;}

RefExistsMaybe()

bool RefExistsMaybe ( const KwsTerm &  term )

private

Definition at line 215 of file kws-scoring.cc.

References count, KwsTerm::kw_id(), KwsTermsAligner::refs_, and KwsTerm::utt_id().

Referenced by KwsTermsAligner::FindBestRefIndex().

                                                        {
  int utt_id = term.utt_id();
  std::string kw_id = term.kw_id();
  if (refs_.count(utt_id) != 0) {
    if (refs_[utt_id].count(kw_id) != 0) {
      return true;
    }
  }
  return false;
}

Member Data Documentation

hyps_

std::list<KwsTerm> hyps_

private

Definition at line 165 of file kws-scoring.h.

Referenced by KwsTermsAligner::AlignTerms().

nof_hyps_

int nof_hyps_

private

Definition at line 168 of file kws-scoring.h.

nof_refs_

int nof_refs_

private

Definition at line 167 of file kws-scoring.h.

opts_

KwsTermsAlignerOptions opts_

private

Definition at line 166 of file kws-scoring.h.

Referenced by KwsTermsAligner::FindNextRef().

refs_

unordered_map<int, unordered_map<std::string, TermArray > > refs_

private

Definition at line 163 of file kws-scoring.h.

Referenced by KwsTermsAligner::AlignTerms(), KwsTermsAligner::FillUnmatchedRefs(), KwsTermsAligner::FindBestRefIndex(), and KwsTermsAligner::RefExistsMaybe().

used_ref_terms_

unordered_map<int, unordered_map<std::string, TermUseMap > > used_ref_terms_

private

Definition at line 164 of file kws-scoring.h.

Referenced by KwsTermsAligner::AlignTerms(), KwsTermsAligner::FillUnmatchedRefs(), and KwsTermsAligner::FindBestRefIndex().

---

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

• kws/kws-scoring.h
• kws/kws-scoring.cc