Posterior_group

Classes
class	PosteriorHolder
class	GaussPostHolder
struct	CompareReverseSecond

Typedefs
typedef std::vector< std::vector< std::pair< int32, BaseFloat > > >	Posterior
	Posterior is a typedef for storing acoustic-state (actually, transition-id) posteriors over an utterance. More...
typedef std::vector< std::vector< std::pair< int32, Vector< BaseFloat > > > >	GaussPost
	GaussPost is a typedef for storing Gaussian-level posteriors for an utterance. More...
typedef TableWriter< PosteriorHolder >	PosteriorWriter
typedef SequentialTableReader< PosteriorHolder >	SequentialPosteriorReader
typedef RandomAccessTableReader< PosteriorHolder >	RandomAccessPosteriorReader
typedef TableWriter< GaussPostHolder >	GaussPostWriter
typedef SequentialTableReader< GaussPostHolder >	SequentialGaussPostReader
typedef RandomAccessTableReader< GaussPostHolder >	RandomAccessGaussPostReader

Functions
void	WritePosterior (std::ostream &os, bool binary, const Posterior &post)
	stand-alone function for writing a Posterior. More...
void	ReadPosterior (std::istream &os, bool binary, Posterior *post)
	stand-alone function for reading a Posterior. More...
void	ScalePosterior (BaseFloat scale, Posterior *post)
	Scales the BaseFloat (weight) element in the posterior entries. More...
BaseFloat	TotalPosterior (const Posterior &post)
	Returns the total of all the weights in "post". More...
bool	PosteriorEntriesAreDisjoint (const std::vector< std::pair< int32, BaseFloat > > &post_elem1, const std::vector< std::pair< int32, BaseFloat > > &post_elem2)
	Returns true if the two lists of pairs have no common .first element. More...
int32	MergePosteriors (const Posterior &post1, const Posterior &post2, bool merge, bool drop_frames, Posterior *post)
	Merge two sets of posteriors, which must have the same length. More...
BaseFloat	VectorToPosteriorEntry (const VectorBase< BaseFloat > &log_likes, int32 num_gselect, BaseFloat min_post, std::vector< std::pair< int32, BaseFloat > > *post_entry)
	Given a vector of log-likelihoods (typically of Gaussians in a GMM but could be of pdf-ids), a number gselect >= 1 and a minimum posterior 0 <= min_post < 1, it gets the posterior for each element of log-likes by applying Softmax(), then prunes the posteriors using "gselect" and "min_post" (keeping at least one), and outputs the result into "post_entry", sorted from greatest to least posterior. More...
void	AlignmentToPosterior (const std::vector< int32 > &ali, Posterior *post)
	Convert an alignment to a posterior (with a scale of 1.0 on each entry). More...
void	SortPosteriorByPdfs (const TransitionModel &tmodel, Posterior *post)
	Sorts posterior entries so that transition-ids with same pdf-id are next to each other. More...
void	ConvertPosteriorToPdfs (const TransitionModel &tmodel, const Posterior &post_in, Posterior *post_out)
	Converts a posterior over transition-ids to be a posterior over pdf-ids. More...
void	ConvertPosteriorToPhones (const TransitionModel &tmodel, const Posterior &post_in, Posterior *post_out)
	Converts a posterior over transition-ids to be a posterior over phones. More...
void	WeightSilencePost (const TransitionModel &trans_model, const ConstIntegerSet< int32 > &silence_set, BaseFloat silence_scale, Posterior *post)
	Weight any silence phones in the posterior (i.e. More...
void	WeightSilencePostDistributed (const TransitionModel &trans_model, const ConstIntegerSet< int32 > &silence_set, BaseFloat silence_scale, Posterior *post)
	This is similar to WeightSilencePost, except that on each frame it works out the amount by which the overall posterior would be reduced, and scales down everything on that frame by the same amount. More...
template<typename Real >
void	PosteriorToMatrix (const Posterior &post, const int32 post_dim, Matrix< Real > *mat)
	This converts a Posterior to a Matrix. More...
template<typename Real >
void	PosteriorToPdfMatrix (const Posterior &post, const TransitionModel &model, Matrix< Real > *mat)
	This converts a Posterior to a Matrix. More...

Detailed Description

Typedef Documentation

GaussPost

typedef std::vector<std::vector<std::pair<int32, Vector<BaseFloat> > > > GaussPost

GaussPost is a typedef for storing Gaussian-level posteriors for an utterance.

the "int32" is a transition-id, and the Vector<BaseFloat> is a vector of Gaussian posteriors. WARNING: We changed "int32" from transition-id to pdf-id, and the change is applied for all programs using GaussPost. This is for efficiency purpose. We also changed the name slightly from GauPost to GaussPost to reduce the chance that the change will go un-noticed in downstream code.

Definition at line 51 of file posterior.h.

GaussPostWriter

typedef TableWriter<GaussPostHolder> GaussPostWriter

Definition at line 144 of file posterior.h.

Posterior

typedef std::vector<std::vector<std::pair<int32, BaseFloat> > > Posterior

Posterior is a typedef for storing acoustic-state (actually, transition-id) posteriors over an utterance.

The "int32" is a transition-id, and the BaseFloat is a probability (typically between zero and one).

Definition at line 42 of file posterior.h.

PosteriorWriter

typedef TableWriter<PosteriorHolder> PosteriorWriter

Definition at line 138 of file posterior.h.

RandomAccessGaussPostReader

typedef RandomAccessTableReader<GaussPostHolder> RandomAccessGaussPostReader

Definition at line 146 of file posterior.h.

RandomAccessPosteriorReader

typedef RandomAccessTableReader<PosteriorHolder> RandomAccessPosteriorReader

Definition at line 140 of file posterior.h.

SequentialGaussPostReader

typedef SequentialTableReader<GaussPostHolder> SequentialGaussPostReader

Definition at line 145 of file posterior.h.

SequentialPosteriorReader

typedef SequentialTableReader<PosteriorHolder> SequentialPosteriorReader

Definition at line 139 of file posterior.h.

Function Documentation

AlignmentToPosterior()

void AlignmentToPosterior	(	const std::vector< int32 > &	ali,
		Posterior *	post
	)

Convert an alignment to a posterior (with a scale of 1.0 on each entry).

Definition at line 290 of file posterior.cc.

References rnnlm::i.

Referenced by DiscriminativeComputation::ComputeObjfAndDeriv(), kaldi::LatticeForwardBackwardMmi(), main(), and CompareReverseSecond::operator()().

                                           {
  post->clear();
  post->resize(ali.size());
  for (size_t i = 0; i < ali.size(); i++) {
    (*post)[i].resize(1);
    (*post)[i][0].first = ali[i];
    (*post)[i][0].second = 1.0;
  }
}

ConvertPosteriorToPdfs()

void ConvertPosteriorToPdfs	(	const TransitionModel &	tmodel,
		const Posterior &	post_in,
		Posterior *	post_out
	)

Converts a posterior over transition-ids to be a posterior over pdf-ids.

Definition at line 322 of file posterior.cc.

References rnnlm::i, rnnlm::j, and TransitionModel::TransitionIdToPdf().

Referenced by kaldi::AccStatsForUtterance(), kaldi::AccumulateForUtterance(), DiscriminativeComputation::ComputeObjfAndDeriv(), kaldi::nnet2::ExampleToPdfPost(), NnetDiscriminativeUpdater::GetDiscriminativePosteriors(), SingleUtteranceGmmDecoder::GetGaussianPosteriors(), kaldi::LatticeForwardBackwardMmi(), main(), and CompareReverseSecond::operator()().

                                                 {
  post_out->clear();
  post_out->resize(post_in.size());
  for (size_t i = 0; i < post_out->size(); i++) {
    unordered_map<int32, BaseFloat> pdf_to_post;
    for (size_t j = 0; j < post_in[i].size(); j++) {
      int32 tid = post_in[i][j].first,
          pdf_id = tmodel.TransitionIdToPdf(tid);
      BaseFloat post = post_in[i][j].second;
      if (pdf_to_post.count(pdf_id) == 0)
        pdf_to_post[pdf_id] = post;
      else
        pdf_to_post[pdf_id] += post;
    }
    (*post_out)[i].reserve(pdf_to_post.size());
    for (unordered_map<int32, BaseFloat>::const_iterator iter =
             pdf_to_post.begin(); iter != pdf_to_post.end(); ++iter) {
      if (iter->second != 0.0)
        (*post_out)[i].push_back(
            std::make_pair(iter->first, iter->second));
    }
  }
}

ConvertPosteriorToPhones()

void ConvertPosteriorToPhones	(	const TransitionModel &	tmodel,
		const Posterior &	post_in,
		Posterior *	post_out
	)

Converts a posterior over transition-ids to be a posterior over phones.

Definition at line 348 of file posterior.cc.

References rnnlm::i, rnnlm::j, and TransitionModel::TransitionIdToPhone().

Referenced by main(), and CompareReverseSecond::operator()().

                                                   {
  post_out->clear();
  post_out->resize(post_in.size());
  for (size_t i = 0; i < post_out->size(); i++) {
    std::map<int32, BaseFloat> phone_to_post;
    for (size_t j = 0; j < post_in[i].size(); j++) {
      int32 tid = post_in[i][j].first,
          phone_id = tmodel.TransitionIdToPhone(tid);
      BaseFloat post = post_in[i][j].second;
      if (phone_to_post.count(phone_id) == 0)
        phone_to_post[phone_id] = post;
      else
        phone_to_post[phone_id] += post;
    }
    (*post_out)[i].reserve(phone_to_post.size());
    for (std::map<int32, BaseFloat>::const_iterator iter =
             phone_to_post.begin(); iter != phone_to_post.end(); ++iter) {
      if (iter->second != 0.0)
        (*post_out)[i].push_back(
            std::make_pair(iter->first, iter->second));
    }
  }
}

MergePosteriors()

int32 MergePosteriors	(	const Posterior &	post1,
		const Posterior &	post2,
		bool	merge,
		bool	drop_frames,
		Posterior *	post
	)

Merge two sets of posteriors, which must have the same length.

If "merge" is true, it will make a common entry whenever there are duplicated entries, adding up the weights. If "drop_frames" is true, for frames where the two sets of posteriors were originally disjoint, makes no entries for that frame (relates to frame dropping, or drop_frames, see Vesely et al, ICASSP 2013). Returns the number of frames for which the two posteriors were disjoint (i.e. no common transition-ids or whatever index we are using).

Definition at line 258 of file posterior.cc.

References rnnlm::i, KALDI_ASSERT, kaldi::MergePairVectorSumming(), and kaldi::PosteriorEntriesAreDisjoint().

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

                                       {
  KALDI_ASSERT(post1.size() == post2.size()); // precondition.
  post->resize(post1.size());

  int32 num_disjoint = 0;
  for (size_t i = 0; i < post->size(); i++) {
    (*post)[i].reserve(post1[i].size() + post2[i].size());
    (*post)[i].insert((*post)[i].end(),
                      post1[i].begin(), post1[i].end());
    (*post)[i].insert((*post)[i].end(),
                      post2[i].begin(), post2[i].end());
    if (merge) { // combine and sum up entries with same transition-id.
      MergePairVectorSumming(&((*post)[i])); // This sorts on
      // the transition-id merges the entries with the same
      // key (i.e. same .first element; same transition-id), and
      // gets rid of entries with zero .second element.
    } else { // just to keep them pretty, merge them.
      std::sort( (*post)[i].begin(), (*post)[i].end() );
    }
    if (PosteriorEntriesAreDisjoint(post1[i], post2[i])) {
      num_disjoint++;
      if (drop_frames)
        (*post)[i].clear();
    }
  }
  return num_disjoint;
}

PosteriorEntriesAreDisjoint()

bool PosteriorEntriesAreDisjoint	(	const std::vector< std::pair< int32, BaseFloat > > &	post_elem1,
		const std::vector< std::pair< int32, BaseFloat > > &	post_elem2
	)

Returns true if the two lists of pairs have no common .first element.

Definition at line 242 of file posterior.cc.

References rnnlm::i.

Referenced by kaldi::MergePosteriors().

                                                            {
  unordered_set<int32> set1;
  for (size_t i = 0; i < post_elem1.size(); i++) set1.insert(post_elem1[i].first);
  for (size_t i = 0; i < post_elem2.size(); i++)
    if (set1.count(post_elem2[i].first) != 0) return false;
  return true; // The sets are disjoint.
}

PosteriorToMatrix()

void PosteriorToMatrix	(	const Posterior &	post,
		const int32	post_dim,
		Matrix< Real > *	mat
	)

This converts a Posterior to a Matrix.

The number of matrix-rows is the same as the 'post.size()', the number of matrix-columns is defined by 'post_dim'. The elements which are not specified in 'Posterior' are equal to zero.

Definition at line 512 of file posterior.cc.

References rnnlm::i, KALDI_ERR, kaldi::kSetZero, kaldi::PosteriorToMatrix< double >(), kaldi::PosteriorToMatrix< float >(), and Matrix< Real >::Resize().

Referenced by kaldi::AppendPostToFeats(), main(), and CompareReverseSecond::operator()().

                                                                {
  // Make a host-matrix,
  int32 num_rows = post.size();
  mat->Resize(num_rows, post_dim, kSetZero);  // zero-filled
  // Fill from Posterior,
  for (int32 t = 0; t < post.size(); t++) {
    for (int32 i = 0; i < post[t].size(); i++) {
      int32 col = post[t][i].first;
      if (col >= post_dim) {
        KALDI_ERR << "Out-of-bound Posterior element with index " << col
                  << ", higher than number of columns " << post_dim;
      }
      (*mat)(t, col) = post[t][i].second;
    }
  }
}

PosteriorToPdfMatrix()

void PosteriorToPdfMatrix	(	const Posterior &	post,
		const TransitionModel &	model,
		Matrix< Real > *	mat
	)

This converts a Posterior to a Matrix.

The number of matrix-rows is the same as the 'post.size()', the number of matrix-columns is defined by 'NumPdfs' in the TransitionModel. The elements which are not specified in 'Posterior' are equal to zero.

Definition at line 539 of file posterior.cc.

References rnnlm::i, KALDI_ERR, kaldi::kSetZero, TransitionModel::NumPdfs(), kaldi::PosteriorToPdfMatrix< double >(), kaldi::PosteriorToPdfMatrix< float >(), Matrix< Real >::Resize(), and TransitionModel::TransitionIdToPdf().

Referenced by CompareReverseSecond::operator()().

                                             {
  // Allocate the matrix,
  int32 num_rows = post.size(),
        num_cols = model.NumPdfs();
  mat->Resize(num_rows, num_cols, kSetZero);  // zero-filled,
  // Fill from Posterior,
  for (int32 t = 0; t < post.size(); t++) {
    for (int32 i = 0; i < post[t].size(); i++) {
      int32 col = model.TransitionIdToPdf(post[t][i].first);
      if (col >= num_cols) {
        KALDI_ERR << "Out-of-bound Posterior element with index " << col
                  << ", higher than number of columns " << num_cols;
      }
      (*mat)(t, col) += post[t][i].second;  // sum,
    }
  }
}

ReadPosterior()

void ReadPosterior	(	std::istream &	is,
		bool	binary,
		Posterior *	post
	)

stand-alone function for reading a Posterior.

Definition at line 64 of file posterior.cc.

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

Referenced by main(), PosteriorHolder::Read(), and kaldi::TestPosteriorIo().

                                                                 {
  post->clear();
  if (binary) {
    int32 sz;
    ReadBasicType(is, true, &sz);
    if (sz < 0 || sz > 10000000)
      KALDI_ERR << "Reading posterior: got negative or improbably large size"
                << sz;
    post->resize(sz);
    for (Posterior::iterator iter = post->begin(); iter != post->end(); ++iter) {
      int32 sz2;
      ReadBasicType(is, true, &sz2);
      if (sz2 < 0)
        KALDI_ERR << "Reading posteriors: got negative size";
      iter->resize(sz2);
      for (std::vector<std::pair<int32, BaseFloat> >::iterator iter2=iter->begin();
           iter2 != iter->end();
           iter2++) {
        ReadBasicType(is, true, &(iter2->first));
        ReadBasicType(is, true, &(iter2->second));
      }
    }
  } else {
    std::string line;
    getline(is, line);  // This will discard the \n, if present.
                        // The Posterior is terminated by a newlinhe.
    if (is.fail())
      KALDI_ERR << "holder of Posterior: error reading line " << (is.eof() ? "[eof]" : "");
    std::istringstream line_is(line);
    while (1) {
      std::string str;
      line_is >> std::ws;  // eat up whitespace.
      if (line_is.eof()) break;
      line_is >> str;
      if (str != "[") {
        int32 str_int;
        // if str is an integer, we can give a slightly more concrete suggestion
        // of what might have gone wrong.
        KALDI_ERR << "Reading Posterior object: expecting [, got '" << str
                  << (ConvertStringToInteger(str, &str_int) ?
                      "': did you provide alignments instead of posteriors?" :
                      "'.");
      }
      std::vector<std::pair<int32, BaseFloat> > this_vec;
      while (1) {
        line_is >> std::ws;
        if (line_is.peek() == ']') {
          line_is.get();
          break;
        }
        int32 i; BaseFloat p;
        line_is >> i >> p;
        if (line_is.fail())
          KALDI_ERR << "Error reading Posterior object (could not get data after \"[\");";
        this_vec.push_back(std::make_pair(i, p));
      }
      post->push_back(this_vec);
    }
  }
}

ScalePosterior()

void ScalePosterior	(	BaseFloat	scale,
		Posterior *	post
	)

Scales the BaseFloat (weight) element in the posterior entries.

Definition at line 218 of file posterior.cc.

References rnnlm::i, and rnnlm::j.

Referenced by kaldi::nnet2::ExampleToPdfPost(), NnetDiscriminativeUpdater::LatticeComputations(), kaldi::LatticeForwardBackwardMmi(), main(), and kaldi::RunPerSpeaker().

                                                      {
  if (scale == 1.0) return;
  for (size_t i = 0; i < post->size(); i++) {
    if (scale == 0.0) {
      (*post)[i].clear();
    } else {
      for (size_t j = 0; j < (*post)[i].size(); j++)
        (*post)[i][j].second *= scale;
    }
  }
}

SortPosteriorByPdfs()

void SortPosteriorByPdfs	(	const TransitionModel &	tmodel,
		Posterior *	post
	)

Sorts posterior entries so that transition-ids with same pdf-id are next to each other.

Definition at line 314 of file posterior.cc.

References rnnlm::i.

Referenced by main(), and CompareReverseSecond::operator()().

                                          {
  ComparePosteriorByPdfs compare(tmodel);
  for (size_t i = 0; i < post->size(); i++) {
    sort((*post)[i].begin(), (*post)[i].end(), compare);
  }
}

TotalPosterior()

BaseFloat TotalPosterior

(

const Posterior &

post

)

Returns the total of all the weights in "post".

Definition at line 230 of file posterior.cc.

References rnnlm::i.

Referenced by main(), and IvectorExtractTask::~IvectorExtractTask().

                                                {
  double sum =  0.0;
  size_t T = post.size();
  for (size_t t = 0; t < T; t++) {
    size_t I = post[t].size();
    for (size_t i = 0; i < I; i++) {
      sum += post[t][i].second;
    }
  }
  return sum;
}

VectorToPosteriorEntry()

BaseFloat VectorToPosteriorEntry	(	const VectorBase< BaseFloat > &	log_likes,
		int32	num_gselect,
		BaseFloat	min_post,
		std::vector< std::pair< int32, BaseFloat > > *	post_entry
	)

Given a vector of log-likelihoods (typically of Gaussians in a GMM but could be of pdf-ids), a number gselect >= 1 and a minimum posterior 0 <= min_post < 1, it gets the posterior for each element of log-likes by applying Softmax(), then prunes the posteriors using "gselect" and "min_post" (keeping at least one), and outputs the result into "post_entry", sorted from greatest to least posterior.

It returns the log of the sum of the selected log-likes that contributed to the posterior.

Definition at line 440 of file posterior.cc.

References VectorBase< Real >::Dim(), kaldi::Exp(), kaldi::GetTotalPosterior(), KALDI_ASSERT, kaldi::Log(), and VectorBase< Real >::Max().

Referenced by main(), CompareReverseSecond::operator()(), kaldi::TestVectorToPosteriorEntry(), and OnlineIvectorFeature::UpdateStatsForFrames().

                                                       {
  KALDI_ASSERT(num_gselect > 0 && min_post >= 0 && min_post < 1.0);
  // we name num_gauss assuming each entry in log_likes represents a Gaussian;
  // it doesn't matter if they don't.

  int32 num_gauss = log_likes.Dim();
  KALDI_ASSERT(num_gauss > 0);
  if (num_gselect > num_gauss)
    num_gselect = num_gauss;
  std::vector<std::pair<int32, BaseFloat> > temp_post;
  BaseFloat max_like = log_likes.Max();
  if (min_post != 0.0) {
    BaseFloat like_cutoff = max_like + Log(min_post);
    for (int32 g = 0; g < num_gauss; g++) {
      BaseFloat like = log_likes(g);
      if (like > like_cutoff) {
        BaseFloat post = exp(like - max_like);
        temp_post.push_back(std::pair<int32, BaseFloat>(g, post));
      }
    }
  }
  if (temp_post.empty()) {
    // we reach here if min_post was 0.0 or if no posteriors reached the
    // threshold min_post (we need at least one).
    temp_post.resize(num_gauss);
    for (int32 g = 0; g < num_gauss; g++)
      temp_post[g] = std::pair<int32, BaseFloat>(g, Exp(log_likes(g) - max_like));
  }

  CompareReverseSecond compare;
  if (static_cast<int32>(temp_post.size()) > num_gselect * 2) {
    // Sort in decreasing order on posterior.  For efficiency we
    // first do nth_element and then sort, as we only need the part we're
    // going to output, to be sorted.
    std::nth_element(temp_post.begin(),
                     temp_post.begin() + num_gselect, temp_post.end(),
                     compare);
    std::sort(temp_post.begin(), temp_post.begin() + num_gselect,
              compare);
  } else {
    std::sort(temp_post.begin(), temp_post.end(), compare);
  }

  size_t num_to_insert = std::min<size_t>(temp_post.size(),
                                          num_gselect);

  post_entry->clear();
  post_entry->insert(post_entry->end(),
                     temp_post.begin(), temp_post.begin() + num_to_insert);

  BaseFloat tot_post = GetTotalPosterior(*post_entry),
      cutoff = min_post * tot_post;

  while (post_entry->size() > 1 && post_entry->back().second < cutoff) {
    tot_post -= post_entry->back().second;
    post_entry->pop_back();
  }
  // Now renormalize to sum to one after pruning.
  BaseFloat inv_tot = 1.0 / tot_post;
  auto end = post_entry->end();
  for (auto iter = post_entry->begin(); iter != end; ++iter)
    iter->second *= inv_tot;

  return max_like + log(tot_post);
}

WeightSilencePost()

void WeightSilencePost	(	const TransitionModel &	trans_model,
		const ConstIntegerSet< int32 > &	silence_set,
		BaseFloat	silence_scale,
		Posterior *	post
	)

Weight any silence phones in the posterior (i.e.

any phones in the set "silence_set" by scale "silence_scale". The interface was changed in Feb 2014 to do the modification "in-place" rather than having separate input and output.

Definition at line 375 of file posterior.cc.

References ConstIntegerSet< I >::count(), rnnlm::i, rnnlm::j, and TransitionModel::TransitionIdToPhone().

Referenced by SingleUtteranceGmmDecoder::GetGaussianPosteriors(), main(), and CompareReverseSecond::operator()().

                                        {
  for (size_t i = 0; i < post->size(); i++) {
    std::vector<std::pair<int32, BaseFloat> > this_post;
    this_post.reserve((*post)[i].size());
    for (size_t j = 0; j < (*post)[i].size(); j++) {
      int32 tid = (*post)[i][j].first,
          phone = trans_model.TransitionIdToPhone(tid);
      BaseFloat weight = (*post)[i][j].second;
      if (silence_set.count(phone) != 0) {  // is a silence.
        if (silence_scale != 0.0)
          this_post.push_back(std::make_pair(tid, weight*silence_scale));
      } else {
        this_post.push_back(std::make_pair(tid, weight));
      }
    }
    (*post)[i].swap(this_post);
  }
}

WeightSilencePostDistributed()

void WeightSilencePostDistributed	(	const TransitionModel &	trans_model,
		const ConstIntegerSet< int32 > &	silence_set,
		BaseFloat	silence_scale,
		Posterior *	post
	)

This is similar to WeightSilencePost, except that on each frame it works out the amount by which the overall posterior would be reduced, and scales down everything on that frame by the same amount.

It has the effect that frames that are mostly silence get down-weighted. The interface was changed in Feb 2014 to do the modification "in-place" rather than having separate input and output.

Definition at line 398 of file posterior.cc.

References ConstIntegerSet< I >::count(), rnnlm::i, rnnlm::j, KALDI_ASSERT, and TransitionModel::TransitionIdToPhone().

Referenced by main(), and CompareReverseSecond::operator()().

                                                   {
  for (size_t i = 0; i < post->size(); i++) {
    std::vector<std::pair<int32, BaseFloat> > this_post;
    this_post.reserve((*post)[i].size());
    BaseFloat sil_weight = 0.0, nonsil_weight = 0.0;
    for (size_t j = 0; j < (*post)[i].size(); j++) {
      int32 tid = (*post)[i][j].first,
          phone = trans_model.TransitionIdToPhone(tid);
      BaseFloat weight = (*post)[i][j].second;
      if (silence_set.count(phone) != 0) sil_weight += weight;
      else nonsil_weight += weight;
    }
    KALDI_ASSERT(sil_weight >= 0.0 && nonsil_weight >= 0.0); // This "distributed"
    // weighting approach doesn't make sense if we have negative weights.
    if (sil_weight + nonsil_weight == 0.0) continue;
    BaseFloat frame_scale = (sil_weight * silence_scale + nonsil_weight) /
                            (sil_weight + nonsil_weight);
    if (frame_scale != 0.0) {
      for (size_t j = 0; j < (*post)[i].size(); j++) {
        int32 tid = (*post)[i][j].first;
        BaseFloat weight = (*post)[i][j].second;
        this_post.push_back(std::make_pair(tid, weight * frame_scale));
      }
    }
    (*post)[i].swap(this_post);
  }
}

WritePosterior()

void WritePosterior	(	std::ostream &	os,
		bool	binary,
		const Posterior &	post
	)

stand-alone function for writing a Posterior.

Definition at line 32 of file posterior.cc.

References KALDI_ERR, and kaldi::WriteBasicType().

Referenced by kaldi::TestPosteriorIo(), and PosteriorHolder::Write().

                                                                        {
  if (binary) {
    int32 sz = post.size();
    WriteBasicType(os, binary, sz);
    for (Posterior::const_iterator iter = post.begin(); iter != post.end(); ++iter) {
      int32 sz2 = iter->size();
      WriteBasicType(os, binary, sz2);
      for (std::vector<std::pair<int32, BaseFloat> >::const_iterator
               iter2 = iter->begin(); iter2 != iter->end(); ++iter2) {
        WriteBasicType(os, binary, iter2->first);
        WriteBasicType(os, binary, iter2->second);
      }
    }
  } else {  // In text-mode, choose a human-friendly, script-friendly format.
    // format is [ 1235 0.6 12 0.4 ] [ 34 1.0 ] ...
    // We could have used the same code as in the binary case above,
    // but this would have resulted in less readable output.
    for (Posterior::const_iterator iter = post.begin(); iter != post.end(); ++iter) {
      os << "[ ";
      for (std::vector<std::pair<int32, BaseFloat> >::const_iterator iter2=iter->begin();
           iter2 != iter->end();
           iter2++) {
        os << iter2->first << ' ' << iter2->second << ' ';
      }
      os << "] ";
    }
    os << '\n';  // newline terminates the Posterior.
  }
  if (!os.good())
    KALDI_ERR << "Output stream error writing Posterior.";
}