compute-vad-from-frame-likes.cc File Reference

#include "base/kaldi-common.h"
#include "util/common-utils.h"
#include "matrix/kaldi-matrix.h"
#include "util/parse-options.h"
#include "util/stl-utils.h"

Include dependency graph for compute-vad-from-frame-likes.cc:

Go to the source code of this file.

Namespaces
	kaldi
	This code computes Goodness of Pronunciation (GOP) and extracts phone-level pronunciation feature for mispronunciations detection tasks, the reference:

Functions
void	PrepareMap (const std::string &map_rxfilename, int32 num_classes, unordered_map< int32, int32 > *map)
	PrepareMap creates a map that specifies the mapping between the input and output class labels. More...
void	PreparePriors (const std::string &priors_str, int32 num_classes, std::vector< BaseFloat > *priors)
	PreparePriors creates a table specifying the priors for each class. More...
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 98 of file compute-vad-from-frame-likes.cc.

References VectorBase< Real >::Dim(), ParseOptions::GetArg(), rnnlm::i, rnnlm::j, KALDI_ERR, KALDI_LOG, KALDI_WARN, ParseOptions::NumArgs(), kaldi::PrepareMap(), kaldi::PreparePriors(), ParseOptions::PrintUsage(), ParseOptions::Read(), ParseOptions::Register(), and TableWriter< Holder >::Write().

                                 {
  using namespace kaldi;
  typedef kaldi::int32 int32;
  try {
    const char *usage =
      "This program computes frame-level voice activity decisions from a\n"
      "set of input frame-level log-likelihoods.  Usually, these\n"
      "log-likelihoods are the output of fgmm-global-get-frame-likes.\n"
      "Frames are assigned labels according to the class for which the\n"
      "log-likelihood (optionally weighted by a prior) is maximal.  The\n"
      "class labels are determined by the order of inputs on the command\n"
      "line.  See options for more details.\n"
      "\n"
      "Usage: compute-vad-from-frame-likes [options] <likes-rspecifier-1>\n"
      "    ... <likes-rspecifier-n> <vad-wspecifier>\n"
      "e.g.: compute-vad-from-frame-likes --map=label_map.txt\n"
      "    scp:likes1.scp scp:likes2.scp ark:vad.ark\n"
      "See also: fgmm-global-get-frame-likes, compute-vad, merge-vads\n";

    ParseOptions po(usage);
    std::string map_rxfilename;
    std::string priors_str;

    po.Register("map", &map_rxfilename, "Table that defines the frame-level "
      "labels.  For each row, the first field is the zero-based index of the "
      "input likelihood archive and the second field is the associated "
      "integer label.");

    po.Register("priors", &priors_str, "Comma-separated list that specifies "
      "the priors for each class.  The order of the floats corresponds to "
      "the index of the input archives.  E.g., --priors=0.5,0.2,0.3");

    po.Read(argc, argv);
    if (po.NumArgs() < 3) {
      po.PrintUsage();
      exit(1);
    }

    unordered_map<int32, int32> map;
    std::vector<BaseFloat> priors;
    int32 num_classes = po.NumArgs() - 1;
    PrepareMap(map_rxfilename, num_classes, &map);
    PreparePriors(priors_str, num_classes, &priors);

    SequentialBaseFloatVectorReader first_reader(po.GetArg(1));
    std::vector<RandomAccessBaseFloatVectorReader *> readers;
    std::string vad_wspecifier = po.GetArg(po.NumArgs());
    BaseFloatVectorWriter vad_writer(vad_wspecifier);

    for (int32 i = 2; i < po.NumArgs(); i++) {
      RandomAccessBaseFloatVectorReader *reader
        = new RandomAccessBaseFloatVectorReader(po.GetArg(i));
      readers.push_back(reader);
    }

    int32 num_done = 0, num_err = 0;
    for (;!first_reader.Done(); first_reader.Next()) {
      std::string utt = first_reader.Key();
      Vector<BaseFloat> like(first_reader.Value());
      int32 like_dim = like.Dim();
      std::vector<Vector<BaseFloat> > likes;
      likes.push_back(like);
      if (like_dim == 0) {
        KALDI_WARN << "Empty vector for utterance " << utt;
        num_err++;
        continue;
      }
      for (int32 i = 0; i < num_classes - 1; i++) {
        if (!readers[i]->HasKey(utt)) {
          KALDI_WARN << "No vector for utterance " << utt;
          num_err++;
          continue;
        }
        Vector<BaseFloat> other_like(readers[i]->Value(utt));
        if (like_dim != other_like.Dim()) {
          KALDI_WARN << "Dimension mismatch in input vectors in " << utt
                    << ": " << like_dim << " vs. " << other_like.Dim();
          num_err++;
          continue;
        }
        likes.push_back(other_like);
      }

      Vector<BaseFloat> vad_result(like_dim);
      for (int32 i = 0; i < like.Dim(); i++) {
        int32 max_indx = 0;
        BaseFloat max_post = likes[0](i) + priors[0];
        for (int32 j = 0; j < num_classes; j++) {
          BaseFloat other_post = likes[j](i) + priors[j];
          if (other_post > max_post) {
            max_indx = j;
            max_post = other_post;
          }
        }
        unordered_map<int32, int32>::const_iterator iter = map.find(max_indx);
        if (iter == map.end()) {
          KALDI_ERR << "Missing label " << max_indx  << " in map";
        } else {
          vad_result(i) = iter->second;
        }
      }
      vad_writer.Write(utt, vad_result);
      num_done++;
    }

    for (int32 i = 0; i < num_classes - 1; i++)
      delete readers[i];

    KALDI_LOG << "Applied frame-level likelihood-based voice activity "
              << "detection; processed " << num_done
              << " utterances successfully; " << num_err
              << " had empty features.";
    return (num_done != 0 ? 0 : 1);
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}