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
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 ( )

inline

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

References kaldi::DeletePointers(), and Questions::key_options_.

{ kaldi::DeletePointers(&key_options_); }

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 111 of file build-tree-questions.h.

{ }

Member Function Documentation

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

inline

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

References kaldi::CopyMapKeysToVector(), KALDI_ASSERT, and Questions::key_idx_.

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

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

const QuestionsForKey& GetQuestionsOf ( EventKeyType  key ) const

inline

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

References KALDI_ASSERT, KALDI_ERR, Questions::key_idx_, and Questions::key_options_.

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

                                                                {
    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]);
  }

const bool HasQuestionsForKey ( EventKeyType  key ) const

inline

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

References Questions::key_idx_.

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

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

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, Questions::SetQuestionsOf(), 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 ( Questions  )

private

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

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

References kaldi::DeletePointers(), kaldi::ExpectToken(), KALDI_ERR, Questions::key_idx_, Questions::key_options_, QuestionsForKey::Read(), kaldi::ReadBasicType(), kaldi::ReadToken(), and Questions::SetQuestionsOf().

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);
    }
  }
}

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, Questions::key_idx_, and Questions::key_options_.

Referenced by Questions::InitRand(), main(), and Questions::Read().

                                                                               {
    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;
    }
  }

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

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

References Questions::GetKeysWithQuestions(), Questions::GetQuestionsOf(), 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

std::map<EventKeyType, size_t> key_idx_

private

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

Referenced by Questions::GetKeysWithQuestions(), Questions::GetQuestionsOf(), Questions::HasQuestionsForKey(), Questions::Read(), and Questions::SetQuestionsOf().

std::vector<QuestionsForKey*> key_options_

private

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

Referenced by Questions::GetQuestionsOf(), Questions::Read(), Questions::SetQuestionsOf(), and Questions::~Questions().

---

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

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