Questions Class Reference

This class defines, for each EventKeyType, a set of initial questions that it tries and also a number of iterations for which to refine the questions to increase likelihood. More...

#include <build-tree-questions.h>

Collaboration diagram for Questions:

Public Member Functions
const QuestionsForKey &	GetQuestionsOf (EventKeyType key) const
void	SetQuestionsOf (EventKeyType key, const QuestionsForKey &options_of_key)
void	GetKeysWithQuestions (std::vector< EventKeyType > *keys_out) const
bool	HasQuestionsForKey (EventKeyType key) const
	~Questions ()
	Questions ()
	Initializer with arguments. More...
void	InitRand (const BuildTreeStatsType &stats, int32 num_quest, int32 num_iters_refine, AllKeysType all_keys_type)
	InitRand attempts to generate "reasonable" random questions. More...
void	Write (std::ostream &os, bool binary) const
void	Read (std::istream &is, bool binary)

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (Questions)

Private Attributes
std::vector< QuestionsForKey * >	key_options_
std::map< EventKeyType, size_t >	key_idx_

Detailed Description

This class defines, for each EventKeyType, a set of initial questions that it tries and also a number of iterations for which to refine the questions to increase likelihood.

It is perhaps a bit more than an options class, as it contains the actual questions.

Definition at line 77 of file build-tree-questions.h.

Constructor & Destructor Documentation

~Questions()

~Questions ( )

inline

Definition at line 108 of file build-tree-questions.h.

References kaldi::DeletePointers().

{ kaldi::DeletePointers(&key_options_); }

Questions()

Questions ( )

inline

Initializer with arguments.

After using this you would have to set up the config for each key you are going to use, or use InitRand().

Definition at line 113 of file build-tree-questions.h.

References kaldi::InitRand(), QuestionsForKey::Read(), and QuestionsForKey::Write().

{ }

Member Function Documentation

GetKeysWithQuestions()

void GetKeysWithQuestions ( std::vector< EventKeyType > *  keys_out ) const

inline

Definition at line 101 of file build-tree-questions.h.

References kaldi::CopyMapKeysToVector(), and KALDI_ASSERT.

Referenced by DecisionTreeSplitter::FindBestSplit(), and kaldi::TestBuildTree().

                                                                     {
    KALDI_ASSERT(keys_out != NULL);
    CopyMapKeysToVector(key_idx_, keys_out);
  }

GetQuestionsOf()

const QuestionsForKey& GetQuestionsOf ( EventKeyType  key ) const

inline

Definition at line 79 of file build-tree-questions.h.

References KALDI_ASSERT, and KALDI_ERR.

Referenced by kaldi::ComputeInitialSplit(), kaldi::FindBestSplitForKey(), kaldi::TestBuildTree(), kaldi::TestQuestionsInitRand(), and kaldi::TestSplitDecisionTree().

                                                                {
    std::map<EventKeyType, size_t>::const_iterator iter;
    if ( (iter = key_idx_.find(key)) == key_idx_.end()) {
      KALDI_ERR << "Questions: no options for key "<< key;
    }
    size_t idx = iter->second;
    KALDI_ASSERT(idx < key_options_.size());
    key_options_[idx]->Check();
    return *(key_options_[idx]);
  }

HasQuestionsForKey()

bool HasQuestionsForKey ( EventKeyType  key ) const

inline

Definition at line 105 of file build-tree-questions.h.

Referenced by DecisionTreeSplitter::FindBestSplit(), kaldi::TestBuildTree(), kaldi::TestQuestionsInitRand(), and kaldi::TestSplitDecisionTree().

                                                  {
    return (key_idx_.count(key) != 0);
  }

InitRand()

void InitRand	(	const BuildTreeStatsType &	stats,
		int32	num_quest,
		int32	num_iters_refine,
		AllKeysType	all_keys_type
	)

InitRand attempts to generate "reasonable" random questions.

Only of use for debugging. This initializer creates a config that is ready to use. e.g. num_iters_refine = 0 means just use stated questions (if >1, will use different questions at each split of the tree).

Definition at line 89 of file build-tree-questions.cc.

References kaldi::FindAllKeys(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_WARN, kaldi::kAllKeysUnion, RefineClustersOptions::num_iters, kaldi::PossibleValues(), kaldi::RandInt(), QuestionsForKey::refine_opts, and kaldi::SortAndUniq().

Referenced by kaldi::GenRandContextDependency(), kaldi::GenRandContextDependencyLarge(), kaldi::TestBuildTree(), kaldi::TestClusterEventMapRestricted(), kaldi::TestQuestionsInitRand(), kaldi::TestShareEventMapLeaves(), and kaldi::TestSplitDecisionTree().

                                                           {
  std::vector<EventKeyType> all_keys;
  FindAllKeys(stats, all_keys_type, &all_keys);  // get all keys.
  if (all_keys_type == kAllKeysUnion) {
    KALDI_WARN << "Questions::InitRand(), using union of all keys.  This may work depending on how you are building the tree but may crash (depends if you have already ensured that stats currently on the same leaf all share the same set of keys.)";
  }

  for (size_t i = 0;i < all_keys.size();i++) {
    EventKeyType key = all_keys[i];
    std::vector<EventValueType> all_values;
    bool b = PossibleValues(key, stats, &all_values);  // get possible values.
    if (all_keys_type != kAllKeysUnion) KALDI_ASSERT(b);
    KALDI_ASSERT(all_values.size() != 0);  // since key exists in stats, must have some value defined.
    QuestionsForKey q_for_key;
    q_for_key.refine_opts.num_iters = num_iters_refine;
    q_for_key.initial_questions.clear();  // Make sure empty.
    if (all_values.size() == 1) {  // can have no meaningful questions because only 1 possible value.   use empty set of questions.
      ;  // Do nothing.  No questions.
    } else {
      q_for_key.initial_questions.resize((size_t)num_quest);
      for (size_t i = 0;i < (size_t)num_quest;i++) {
        std::vector<EventValueType> &this_quest = q_for_key.initial_questions[i];
        for (size_t j = 0;j < all_values.size()/2;j++)
          this_quest.push_back(all_values[RandInt(0, all_values.size()-1)]);
        SortAndUniq(&this_quest);
        KALDI_ASSERT(!this_quest.empty());
      }
      SortAndUniq(&q_for_key.initial_questions);  // Ensure unique questions.
    }
    q_for_key.Check();
    SetQuestionsOf(key, q_for_key);
  }
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( Questions  )

private

Read()

void Read	(	std::istream &	is,
		bool	binary
	)

Definition at line 63 of file build-tree-questions.cc.

References kaldi::DeletePointers(), kaldi::ExpectToken(), KALDI_ERR, QuestionsForKey::Read(), kaldi::ReadBasicType(), and kaldi::ReadToken().

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

                                                {
  // First, clear anything present.
  DeletePointers(&key_options_);
  key_options_.clear();
  key_idx_.clear();

  ExpectToken(is, binary, "<Questions>");

  std::vector<EventKeyType> keys_with_options;

  while (1) {
    std::string token;
    ReadToken(is, binary, &token);
    if (token == "</Questions>") return;
    else {
      if (token != "<Key>")
        KALDI_ERR << "Questions::Read, expecting <Key>, got "<<token;
      EventKeyType key;
      ReadBasicType(is, binary, &key);
      QuestionsForKey opts;
      opts.Read(is, binary);
      SetQuestionsOf(key, opts);
    }
  }
}

SetQuestionsOf()

void SetQuestionsOf ( EventKeyType  key, const QuestionsForKey &  options_of_key  )

inline

Definition at line 89 of file build-tree-questions.h.

References QuestionsForKey::Check(), KALDI_ASSERT, and QuestionsForKey::QuestionsForKey().

Referenced by main().

                                                                               {
    options_of_key.Check();
    if (key_idx_.count(key) == 0) {
      key_idx_[key] = key_options_.size();
      key_options_.push_back(new QuestionsForKey());
      *(key_options_.back()) = options_of_key;
    } else {
      size_t idx = key_idx_[key];
      KALDI_ASSERT(idx < key_options_.size());
      *(key_options_[idx]) = options_of_key;
    }
  }

Write()

void Write	(	std::ostream &	os,
		bool	binary
	)		const

Definition at line 48 of file build-tree-questions.cc.

References rnnlm::i, QuestionsForKey::Write(), kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by kaldi::TestQuestionsInitRand().

                                                       {
  WriteToken(os, binary, "<Questions>");

  std::vector<EventKeyType> keys_with_options;
  this->GetKeysWithQuestions(&keys_with_options);
  for (size_t i = 0; i < keys_with_options.size(); i++) {
    EventKeyType key = keys_with_options[i];
    WriteToken(os, binary, "<Key>");
    WriteBasicType(os, binary, key);
    const QuestionsForKey &opts = GetQuestionsOf(key);
    opts.Write(os, binary);
  }
  WriteToken(os, binary, "</Questions>");
}

Member Data Documentation

key_idx_

std::map<EventKeyType, size_t> key_idx_

private

Definition at line 127 of file build-tree-questions.h.

key_options_

std::vector<QuestionsForKey*> key_options_

private

Definition at line 126 of file build-tree-questions.h.

---

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

• tree/build-tree-questions.h
• tree/build-tree-questions.cc