PitchFrameInfo Class Reference

Collaboration diagram for PitchFrameInfo:

Classes
struct	StateInfo

Public Member Functions
void	Cleanup (PitchFrameInfo *prev_frame)
	This function resizes the arrays for this object and updates the reference counts for the previous object (by decrementing those reference counts when we destroy a StateInfo object). More...
void	SetBestState (int32 best_state, std::vector< std::pair< int32, BaseFloat > > &lag_nccf)
	This function may be called for the last (most recent) PitchFrameInfo object with the best state (obtained from the externally held forward-costs). More...
int32	ComputeLatency (int32 max_latency)
	This function may be called on the last (most recent) PitchFrameInfo object; it computes how many frames of latency there is because the traceback has not yet settled on a single value for frames in the past. More...
bool	UpdatePreviousBestState (PitchFrameInfo *prev_frame)
	This function updates. More...
	PitchFrameInfo (int32 num_states)
	This constructor is used for frame -1; it sets the costs to be all zeros the pov_nccf's to zero and the backpointers to -1. More...
	PitchFrameInfo (PitchFrameInfo *prev)
	This constructor is used for subsequent frames (not -1). More...
void	SetNccfPov (const VectorBase< BaseFloat > &nccf_pov)
	Record the nccf_pov value. More...
void	ComputeBacktraces (const PitchExtractionOptions &opts, const VectorBase< BaseFloat > &nccf_pitch, const VectorBase< BaseFloat > &lags, const VectorBase< BaseFloat > &prev_forward_cost, std::vector< std::pair< int32, int32 > > *index_info, VectorBase< BaseFloat > *this_forward_cost)
	This constructor is used for frames apart from frame -1; the bulk of the Viterbi computation takes place inside this constructor. More...

Private Attributes
std::vector< StateInfo >	state_info_
int32	state_offset_
	the state index of the first entry in "state_info"; this will initially be zero, but after cleanup might be nonzero. More...
int32	cur_best_state_
	The current best state in the backtrace from the end. More...
PitchFrameInfo *	prev_info_
	The structure for the previous frame. More...

Detailed Description

Definition at line 198 of file pitch-functions.cc.

Constructor & Destructor Documentation

PitchFrameInfo() [1/2]

PitchFrameInfo ( int32  num_states )

explicit

This constructor is used for frame -1; it sets the costs to be all zeros the pov_nccf's to zero and the backpointers to -1.

Definition at line 287 of file pitch-functions.cc.

    :state_info_(num_states), state_offset_(0),
    cur_best_state_(-1), prev_info_(NULL) { }

PitchFrameInfo() [2/2]

PitchFrameInfo

(

PitchFrameInfo *

prev

)

This constructor is used for subsequent frames (not -1).

Definition at line 295 of file pitch-functions.cc.

                                                       :
    state_info_(prev_info->state_info_.size()), state_offset_(0),
    cur_best_state_(-1), prev_info_(prev_info) { }

Member Function Documentation

Cleanup()

void Cleanup

(

PitchFrameInfo *

prev_frame

)

This function resizes the arrays for this object and updates the reference counts for the previous object (by decrementing those reference counts when we destroy a StateInfo object).

A StateInfo object is considered to be destroyed when we delete it, not when its reference counts goes to zero.

Definition at line 546 of file pitch-functions.cc.

References KALDI_ERR.

                                                       {
  KALDI_ERR << "Cleanup not implemented.";
}

ComputeBacktraces()

void ComputeBacktraces	(	const PitchExtractionOptions &	opts,
		const VectorBase< BaseFloat > &	nccf_pitch,
		const VectorBase< BaseFloat > &	lags,
		const VectorBase< BaseFloat > &	prev_forward_cost,
		std::vector< std::pair< int32, int32 > > *	index_info,
		VectorBase< BaseFloat > *	this_forward_cost
	)

This constructor is used for frames apart from frame -1; the bulk of the Viterbi computation takes place inside this constructor.

Parameters

opts	The options as provided by the user
nccf_pitch	The nccf as computed for the pitch computation (with ballast).
nccf_pov	The nccf as computed for the POV computation (without ballast).
lags	The log-spaced lags at which nccf_pitch and nccf_pov are sampled.
prev_frame_forward_cost	The forward-cost vector for the previous frame.
index_info	A pointer to a temporary vector used by this function
this_forward_cost	The forward-cost vector for this frame (to be computed).

Definition at line 306 of file pitch-functions.cc.

References VectorBase< Real >::AddVec(), kaldi::ComputeLocalCost(), PitchFrameInfo::cur_best_state_, VectorBase< Real >::Data(), PitchExtractionOptions::delta_pitch, VectorBase< Real >::Dim(), rnnlm::i, rnnlm::j, kaldi::kUndefined, kaldi::Log(), PitchExtractionOptions::penalty_factor, and PitchFrameInfo::state_info_.

                                                  {
  int32 num_states = nccf_pitch.Dim();

  Vector<BaseFloat> local_cost(num_states, kUndefined);
  ComputeLocalCost(nccf_pitch, lags, opts, &local_cost);

  const BaseFloat delta_pitch_sq = pow(Log(1.0 + opts.delta_pitch), 2.0),
      inter_frame_factor = delta_pitch_sq * opts.penalty_factor;

  // index local_cost, prev_forward_cost and this_forward_cost using raw pointer
  // indexing not operator (), since this is the very inner loop and a lot of
  // time is taken here.
  const BaseFloat *prev_forward_cost = prev_forward_cost_vec.Data();
  BaseFloat *this_forward_cost = this_forward_cost_vec->Data();

  if (index_info->empty())
    index_info->resize(num_states);

  // make it a reference for more concise indexing.
  std::vector<std::pair<int32, int32> > &bounds = *index_info;

  /* bounds[i].first will be a lower bound on the backpointer for state i,
     bounds[i].second will be an upper bound on it.  We progressively tighten
     these bounds till we know the backpointers exactly.
  */

  if (pitch_use_naive_search) {
    // This branch is only taken in unit-testing code.
    for (int32 i = 0; i < num_states; i++) {
      BaseFloat best_cost = std::numeric_limits<BaseFloat>::infinity();
      int32 best_j = -1;
      for (int32 j = 0; j < num_states; j++) {
        BaseFloat this_cost = (j - i) * (j - i) * inter_frame_factor
            + prev_forward_cost[j];
        if (this_cost < best_cost) {
          best_cost = this_cost;
          best_j = j;
        }
      }
      this_forward_cost[i] = best_cost;
      state_info_[i].backpointer = best_j;
    }
  } else {
    int32 last_backpointer = 0;
    for (int32 i = 0; i < num_states; i++) {
      int32 start_j = last_backpointer;
      BaseFloat best_cost = (start_j - i) * (start_j - i) * inter_frame_factor
          + prev_forward_cost[start_j];
      int32 best_j = start_j;

      for (int32 j = start_j + 1; j < num_states; j++) {
        BaseFloat this_cost = (j - i) * (j - i) * inter_frame_factor
            + prev_forward_cost[j];
        if (this_cost < best_cost) {
          best_cost = this_cost;
          best_j = j;
        } else {  // as soon as the costs stop improving, we stop searching.
          break;  // this is a loose lower bound we're getting.
        }
      }
      state_info_[i].backpointer = best_j;
      this_forward_cost[i] = best_cost;
      bounds[i].first = best_j;  // this is now a lower bound on the
                                 // backpointer.
      bounds[i].second = num_states - 1;  // we have no meaningful upper bound
                                          // yet.
      last_backpointer = best_j;
    }

    // We iterate, progressively refining the upper and lower bounds until they
    // meet and we know that the resulting backtraces are optimal.  Each
    // iteration takes time linear in num_states.  We won't normally iterate as
    // far as num_states; normally we only do two iterations; when printing out
    // the number of iterations, it's rarely more than that (once I saw seven
    // iterations).  Anyway, this part of the computation does not dominate.
    for (int32 iter = 0; iter < num_states; iter++) {
      bool changed = false;
      if (iter % 2 == 0) {  // go backwards through the states
        last_backpointer = num_states - 1;
        for (int32 i = num_states - 1; i >= 0; i--) {
          int32 lower_bound = bounds[i].first,
              upper_bound = std::min(last_backpointer, bounds[i].second);
          if (upper_bound == lower_bound) {
            last_backpointer = lower_bound;
            continue;
          }
          BaseFloat best_cost = this_forward_cost[i];
          int32 best_j = state_info_[i].backpointer, initial_best_j = best_j;

          if (best_j == upper_bound) {
            // if best_j already equals upper bound, don't bother tightening the
            // upper bound, we'll tighten the lower bound when the time comes.
            last_backpointer = best_j;
            continue;
          }
          // Below, we have j > lower_bound + 1 because we know we've already
          // evaluated lower_bound and lower_bound + 1 [via knowledge of
          // this algorithm.]
          for (int32 j = upper_bound; j > lower_bound + 1; j--) {
            BaseFloat this_cost = (j - i) * (j - i) * inter_frame_factor
                + prev_forward_cost[j];
            if (this_cost < best_cost) {
              best_cost = this_cost;
              best_j = j;
            } else {  // as soon as the costs stop improving, we stop searching,
              // unless the best j is still lower than j, in which case
              // we obviously need to keep moving.
              if (best_j > j)
                break;  // this is a loose lower bound we're getting.
            }
          }
          // our "best_j" is now an upper bound on the backpointer.
          bounds[i].second = best_j;
          if (best_j != initial_best_j) {
            this_forward_cost[i] = best_cost;
            state_info_[i].backpointer = best_j;
            changed = true;
          }
          last_backpointer = best_j;
        }
      } else {  // go forwards through the states.
        last_backpointer = 0;
        for (int32 i = 0; i < num_states; i++) {
          int32 lower_bound = std::max(last_backpointer, bounds[i].first),
              upper_bound = bounds[i].second;
          if (upper_bound == lower_bound) {
            last_backpointer = lower_bound;
            continue;
          }
          BaseFloat best_cost = this_forward_cost[i];
          int32 best_j = state_info_[i].backpointer, initial_best_j = best_j;

          if (best_j == lower_bound) {
            // if best_j already equals lower bound, we don't bother tightening
            // the lower bound, we'll tighten the upper bound when the time
            // comes.
            last_backpointer = best_j;
            continue;
          }
          // Below, we have j < upper_bound because we know we've already
          // evaluated that point.
          for (int32 j = lower_bound; j < upper_bound - 1; j++) {
            BaseFloat this_cost = (j - i) * (j - i) * inter_frame_factor
                + prev_forward_cost[j];
            if (this_cost < best_cost) {
              best_cost = this_cost;
              best_j = j;
            } else {  // as soon as the costs stop improving, we stop searching,
              // unless the best j is still higher than j, in which case
              // we obviously need to keep moving.
              if (best_j < j)
                break;  // this is a loose lower bound we're getting.
            }
          }
          // our "best_j" is now a lower bound on the backpointer.
          bounds[i].first = best_j;
          if (best_j != initial_best_j) {
            this_forward_cost[i] = best_cost;
            state_info_[i].backpointer = best_j;
            changed = true;
          }
          last_backpointer = best_j;
        }
      }
      if (!changed)
        break;
    }
  }
  // The next statement is needed due to RecomputeBacktraces: we have to
  // invalidate the previously computed best-state info.
  cur_best_state_ = -1;
  this_forward_cost_vec->AddVec(1.0, local_cost);
}

ComputeLatency()

int32 ComputeLatency

(

int32

max_latency

)

This function may be called on the last (most recent) PitchFrameInfo object; it computes how many frames of latency there is because the traceback has not yet settled on a single value for frames in the past.

It actually returns the minimum of max_latency and the actual latency, which is an optimization because we won't care about latency past a user-specified maximum latency.

Definition at line 514 of file pitch-functions.cc.

References KALDI_ASSERT, PitchFrameInfo::prev_info_, PitchFrameInfo::state_info_, and PitchFrameInfo::state_offset_.

                                                      {
  if (max_latency <= 0) return 0;

  int32 latency = 0;

  // This function would naturally be recursive, but we have coded this to avoid
  // recursion, which would otherwise eat up the stack.  Think of it as a static
  // member function, except we do use "this" right at the beginning.
  // This function is called only on the most recent PitchFrameInfo object.
  int32 num_states = state_info_.size();
  int32 min_living_state = 0, max_living_state = num_states - 1;
  PitchFrameInfo *this_info = this;  // it will change in the loop.


  for (; this_info != NULL && latency < max_latency;) {
    int32 offset = this_info->state_offset_;
    KALDI_ASSERT(min_living_state >= offset &&
                 max_living_state - offset < this_info->state_info_.size());
    min_living_state =
        this_info->state_info_[min_living_state - offset].backpointer;
    max_living_state =
        this_info->state_info_[max_living_state - offset].backpointer;
    if (min_living_state == max_living_state) {
      return latency;
    }
    this_info = this_info->prev_info_;
    if (this_info != NULL)  // avoid incrementing latency for frame -1,
      latency++;            // as it's not a real frame.
  }
  return latency;
}

SetBestState()

void SetBestState	(	int32	best_state,
		std::vector< std::pair< int32, BaseFloat > > &	lag_nccf
	)

This function may be called for the last (most recent) PitchFrameInfo object with the best state (obtained from the externally held forward-costs).

It traces back as far as needed to set the cur_best_state_, and as it's going it sets the lag-index and pov_nccf in pitch_pov_iter, which when it's called is an iterator to where to put the info for the final state; the iterator will be decremented inside this function.

Definition at line 486 of file pitch-functions.cc.

References PitchFrameInfo::cur_best_state_, KALDI_ASSERT, PitchFrameInfo::prev_info_, PitchFrameInfo::state_info_, and PitchFrameInfo::state_offset_.

                                                     {

  // This function would naturally be recursive, but we have coded this to avoid
  // recursion, which would otherwise eat up the stack.  Think of it as a static
  // member function, except we do use "this" right at the beginning.

  std::vector<std::pair<int32, BaseFloat> >::reverse_iterator iter = lag_nccf.rbegin();

  PitchFrameInfo *this_info = this;  // it will change in the loop.
  while (this_info != NULL) {
    PitchFrameInfo *prev_info = this_info->prev_info_;
    if (best_state == this_info->cur_best_state_)
      return;  // no change
    if (prev_info != NULL)  // don't write anything for frame -1.
      iter->first = best_state;
    size_t state_info_index = best_state - this_info->state_offset_;
    KALDI_ASSERT(state_info_index < this_info->state_info_.size());
    this_info->cur_best_state_ = best_state;
    best_state = this_info->state_info_[state_info_index].backpointer;
    if (prev_info != NULL)  // don't write anything for frame -1.
      iter->second = this_info->state_info_[state_info_index].pov_nccf;
    this_info = prev_info;
    if (this_info != NULL) ++iter;
  }
}

SetNccfPov()

void SetNccfPov

(

const VectorBase< BaseFloat > &

nccf_pov

)

Record the nccf_pov value.

Parameters

nccf_pov

The nccf as computed for the POV computation (without ballast).

Definition at line 299 of file pitch-functions.cc.

References VectorBase< Real >::Dim(), rnnlm::i, KALDI_ASSERT, and PitchFrameInfo::state_info_.

                                                                     {
  int32 num_states = nccf_pov.Dim();
  KALDI_ASSERT(num_states == state_info_.size());
  for (int32 i = 0; i < num_states; i++)
    state_info_[i].pov_nccf = nccf_pov(i);
}

UpdatePreviousBestState()

bool UpdatePreviousBestState

(

PitchFrameInfo *

prev_frame

)

This function updates.

Member Data Documentation

cur_best_state_

int32 cur_best_state_

private

The current best state in the backtrace from the end.

Definition at line 278 of file pitch-functions.cc.

Referenced by PitchFrameInfo::ComputeBacktraces(), and PitchFrameInfo::SetBestState().

prev_info_

PitchFrameInfo* prev_info_

private

The structure for the previous frame.

Definition at line 281 of file pitch-functions.cc.

Referenced by PitchFrameInfo::ComputeLatency(), and PitchFrameInfo::SetBestState().

state_info_

std::vector<StateInfo> state_info_

private

Definition at line 272 of file pitch-functions.cc.

Referenced by PitchFrameInfo::ComputeBacktraces(), PitchFrameInfo::ComputeLatency(), PitchFrameInfo::SetBestState(), and PitchFrameInfo::SetNccfPov().

state_offset_

int32 state_offset_

private

the state index of the first entry in "state_info"; this will initially be zero, but after cleanup might be nonzero.

Definition at line 275 of file pitch-functions.cc.

Referenced by PitchFrameInfo::ComputeLatency(), and PitchFrameInfo::SetBestState().

---

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

• feat/pitch-functions.cc