online-endpoint.h

Go to the documentation of this file.

// online2/online-endpoint.h

// Copyright 2013   Johns Hopkins University (author: Daniel Povey)

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.


#ifndef KALDI_ONLINE2_ONLINE_ENDPOINT_H_
#define KALDI_ONLINE2_ONLINE_ENDPOINT_H_

#include <string>
#include <vector>
#include <deque>

#include "matrix/matrix-lib.h"
#include "util/common-utils.h"
#include "base/kaldi-error.h"
#include "feat/feature-functions.h"
#include "feat/feature-mfcc.h"
#include "feat/feature-plp.h"
#include "itf/online-feature-itf.h"
#include "lat/kaldi-lattice.h"
#include "hmm/transition-model.h"
#include "decoder/lattice-faster-online-decoder.h"
#include "decoder/lattice-incremental-online-decoder.h"

namespace kaldi {


struct OnlineEndpointRule {
  bool must_contain_nonsilence;
  BaseFloat min_trailing_silence;
  BaseFloat max_relative_cost;
  BaseFloat min_utterance_length;
  // The values set in the initializer will probably never be used.
  OnlineEndpointRule(bool must_contain_nonsilence = true,
                     BaseFloat min_trailing_silence = 1.0,
                     BaseFloat max_relative_cost = std::numeric_limits<BaseFloat>::infinity(),
                     BaseFloat min_utterance_length = 0.0):
      must_contain_nonsilence(must_contain_nonsilence),
      min_trailing_silence(min_trailing_silence),
      max_relative_cost(max_relative_cost),
      min_utterance_length(min_utterance_length) { }

  void Register(OptionsItf *opts) {
    opts->Register("must-contain-nonsilence", &must_contain_nonsilence,
                   "If true, for this endpointing rule to apply there must"
                   "be nonsilence in the best-path traceback.");
    opts->Register("min-trailing-silence", &min_trailing_silence,
                   "This endpointing rule requires duration of trailing silence"
                   "(in seconds) to be >= this value.");
    opts->Register("max-relative-cost", &max_relative_cost,
                   "This endpointing rule requires relative-cost of final-states"
                   " to be <= this value (describes how good the probability "
                   "of final-states is).");
    opts->Register("min-utterance-length", &min_utterance_length,
                   "This endpointing rule requires utterance-length (in seconds) "
                   "to be >= this value.");
  };
  // for convenience add this RegisterWithPrefix function, because
  // we'll be registering this as a config with several different
  // prefixes.
  void RegisterWithPrefix(const std::string &prefix, OptionsItf *opts) {
    ParseOptions po_prefix(prefix, opts);
    this->Register(&po_prefix);
  }
};

struct OnlineEndpointConfig {
  std::string silence_phones; 


  OnlineEndpointRule rule1;
  OnlineEndpointRule rule2;
  OnlineEndpointRule rule3;
  OnlineEndpointRule rule4;
  OnlineEndpointRule rule5;

  OnlineEndpointConfig():
      rule1(false, 5.0, std::numeric_limits<BaseFloat>::infinity(), 0.0),
      rule2(true, 0.5, 2.0, 0.0),
      rule3(true, 1.0, 8.0, 0.0),
      rule4(true, 2.0, std::numeric_limits<BaseFloat>::infinity(), 0.0),
      rule5(false, 0.0, std::numeric_limits<BaseFloat>::infinity(), 20.0) { }

  void Register(OptionsItf *opts) {
    opts->Register("endpoint.silence-phones", &silence_phones, "List of phones "
                   "that are considered to be silence phones by the "
                   "endpointing code.");
    rule1.RegisterWithPrefix("endpoint.rule1", opts);
    rule2.RegisterWithPrefix("endpoint.rule2", opts);
    rule3.RegisterWithPrefix("endpoint.rule3", opts);
    rule4.RegisterWithPrefix("endpoint.rule4", opts);
    rule5.RegisterWithPrefix("endpoint.rule5", opts);
  }
};






bool EndpointDetected(const OnlineEndpointConfig &config,
                      int32 num_frames_decoded,
                      int32 trailing_silence_frames,
                      BaseFloat frame_shift_in_seconds,
                      BaseFloat final_relative_cost);


template <typename FST, typename DEC>
int32 TrailingSilenceLength(const TransitionModel &tmodel,
                            const std::string &silence_phones,
                            const DEC &decoder);


template <typename FST>
bool EndpointDetected(
    const OnlineEndpointConfig &config,
    const TransitionModel &tmodel,
    BaseFloat frame_shift_in_seconds,
    const LatticeFasterOnlineDecoderTpl<FST> &decoder);

template <typename FST>
bool EndpointDetected(
    const OnlineEndpointConfig &config,
    const TransitionModel &tmodel,
    BaseFloat frame_shift_in_seconds,
    const LatticeIncrementalOnlineDecoderTpl<FST> &decoder);





}  // namespace kaldi



#endif  // KALDI_ONLINE2_ONLINE_ENDPOINT_