Merge pull request #2 from yimmon/master

remove needless files

8 files changed, 0 insertions, 1771 deletions

diff --git a/kaldi_io/src/kaldi/tree/build-tree-questions.h b/kaldi_io/src/kaldi/tree/build-tree-questions.h
deleted file mode 100644
index a6bcfdd..0000000
--- a/kaldi_io/src/kaldi/tree/build-tree-questions.h
+++ /dev/null
@@ -1,133 +0,0 @@
-// tree/build-tree-questions.h
-
-// Copyright 2009-2011  Microsoft Corporation
-
-// 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_TREE_BUILD_TREE_QUESTIONS_H_
-#define KALDI_TREE_BUILD_TREE_QUESTIONS_H_
-
-#include "util/stl-utils.h"
-#include "tree/context-dep.h"
-
-namespace kaldi {
-
-
-/// \addtogroup tree_group
-/// @{
-/// Typedef for statistics to build trees.
-typedef std::vector<std::pair<EventType, Clusterable*> > BuildTreeStatsType;
-
-/// Typedef used when we get "all keys" from a set of stats-- used in specifying
-/// which kinds of questions to ask.
-typedef enum { kAllKeysInsistIdentical, kAllKeysIntersection, kAllKeysUnion } AllKeysType;
-
-/// @}
-
-/// \defgroup tree_group_questions Question sets for decision-tree clustering
-///  See \ref tree_internals (and specifically \ref treei_func_questions) for context.
-/// \ingroup tree_group
-/// @{
-
-/// QuestionsForKey is a class used to define the questions for a key,
-/// and also options that allow us to refine the question during tree-building
-/// (i.e. make a question specific to the location in the tree).
-/// The Questions class handles aggregating these options for a set
-/// of different keys.
-struct QuestionsForKey {  // Configuration class associated with a particular key
-  // (of type EventKeyType).  It also contains the questions themselves.
-  std::vector<std::vector<EventValueType> > initial_questions;
-  RefineClustersOptions refine_opts;  // if refine_opts.max_iter == 0,
-  // we just pick from the initial questions.
-  
-  QuestionsForKey(int32 num_iters = 5): refine_opts(num_iters, 2) {
-    // refine_cfg with 5 iters and top-n = 2 (this is no restriction because
-    // RefineClusters called with 2 clusters; would get set to that anyway as
-    // it's the only possible value for 2 clusters).  User has to add questions.
-    // This config won't work as-is, as it has no questions.
-  }
-
-  void Check() const {
-    for (size_t i = 0;i < initial_questions.size();i++) KALDI_ASSERT(IsSorted(initial_questions[i]));
-  }
-
-  void Write(std::ostream &os, bool binary) const;
-  void Read(std::istream &is, bool binary);
-
-  // copy and assign allowed.
-};
-
-/// 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.
-class Questions {  // careful, this is a class.
- public:
-  const QuestionsForKey &GetQuestionsOf(EventKeyType key) const {
-    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]);
-  }
-  void SetQuestionsOf(EventKeyType key, const QuestionsForKey &options_of_key) {
-    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 GetKeysWithQuestions(std::vector<EventKeyType> *keys_out) const {
-    KALDI_ASSERT(keys_out != NULL);
-    CopyMapKeysToVector(key_idx_, keys_out);
-  }
-  const bool HasQuestionsForKey(EventKeyType key) const { return (key_idx_.count(key) != 0); }
-  ~Questions() { kaldi::DeletePointers(&key_options_); }
-
-
-  /// 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().
-  Questions() { }
-
-
-  /// 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).
-  void InitRand(const BuildTreeStatsType &stats, int32 num_quest, int32 num_iters_refine, AllKeysType all_keys_type);
-
-  void Write(std::ostream &os, bool binary) const;
-  void Read(std::istream &is, bool binary);
- private:
-  std::vector<QuestionsForKey*> key_options_;
-  std::map<EventKeyType, size_t> key_idx_;
-  KALDI_DISALLOW_COPY_AND_ASSIGN(Questions);
-};
-
-/// @}
-
-}// end namespace kaldi
-
-#endif // KALDI_TREE_BUILD_TREE_QUESTIONS_H_
diff --git a/kaldi_io/src/kaldi/tree/build-tree-utils.h b/kaldi_io/src/kaldi/tree/build-tree-utils.h
deleted file mode 100644
index 464fc6b..0000000
--- a/kaldi_io/src/kaldi/tree/build-tree-utils.h
+++ /dev/null
@@ -1,324 +0,0 @@
-// tree/build-tree-utils.h
-
-// Copyright 2009-2011  Microsoft Corporation
-
-// 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_TREE_BUILD_TREE_UTILS_H_
-#define KALDI_TREE_BUILD_TREE_UTILS_H_
-
-#include "tree/build-tree-questions.h"
-
-// build-tree-questions.h needed for this typedef:
-// typedef std::vector<std::pair<EventType, Clusterable*> > BuildTreeStatsType;
-// and for other #includes.
-
-namespace kaldi {
-
-
-///   \defgroup tree_group_lower Low-level functions for manipulating statistics and event-maps
-///    See \ref tree_internals and specifically \ref treei_func for context.
-///   \ingroup tree_group
-///
-///   @{
-
-
-
-/// This frees the Clusterable* pointers in "stats", where non-NULL, and sets them to NULL.
-/// Does not delete the pointer "stats" itself.
-void DeleteBuildTreeStats(BuildTreeStatsType *stats);
-
-/// Writes BuildTreeStats object.  This works even if pointers are NULL.
-void WriteBuildTreeStats(std::ostream &os, bool binary,
-                         const BuildTreeStatsType &stats);
-
-/// Reads BuildTreeStats object.  The "example" argument must be of the same
-/// type as the stats on disk, and is needed for access to the correct "Read"
-/// function.  It was organized this way for easier extensibility (so adding new
-/// Clusterable derived classes isn't painful)
-void ReadBuildTreeStats(std::istream &is, bool binary,
-                        const Clusterable &example, BuildTreeStatsType *stats);
-
-/// Convenience function e.g. to work out possible values of the phones from just the stats.
-/// Returns true if key was always defined inside the stats.
-/// May be used with and == NULL to find out of key was always defined.
-bool PossibleValues(EventKeyType key, const BuildTreeStatsType &stats,
-                    std::vector<EventValueType> *ans);
-
-
-/// Splits stats according to the EventMap, indexing them at output by the
-/// leaf type.   A utility function.  NOTE-- pointers in stats_out point to
-/// the same memory location as those in stats.  No copying of Clusterable*
-/// objects happens.  Will add to stats in stats_out if non-empty at input.
-/// This function may increase the size of vector stats_out as necessary
-/// to accommodate stats, but will never decrease the size.
-void SplitStatsByMap(const BuildTreeStatsType &stats_in, const EventMap &e,
-                     std::vector<BuildTreeStatsType> *stats_out);
-
-/// SplitStatsByKey splits stats up according to the value of a particular key,
-/// which must be always defined and nonnegative.  Like MapStats.  Pointers to
-/// Clusterable* in stats_out are not newly allocated-- they are the same as the
-/// ones in stats_in.  Generally they will still be owned at stats_in (user can
-/// decide where to allocate ownership).
-void SplitStatsByKey(const BuildTreeStatsType &stats_in, EventKeyType key,
-                     std::vector<BuildTreeStatsType> *stats_out);
-
-
-/// Converts stats from a given context-window (N) and central-position (P) to a
-/// different N and P, by possibly reducing context.  This function does a job
-/// that's quite specific to the "normal" stats format we use.  See \ref
-/// tree_window for background.  This function may delete some keys and change
-/// others, depending on the N and P values.  It expects that at input, all keys
-/// will either be -1 or lie between 0 and oldN-1.  At output, keys will be
-/// either -1 or between 0 and newN-1.
-/// Returns false if we could not convert the stats (e.g. because newN is larger
-/// than oldN).
-bool ConvertStats(int32 oldN, int32 oldP, int32 newN, int32 newP,
-                  BuildTreeStatsType *stats);
-
-
-/// FilterStatsByKey filters the stats according the value of a specified key.
-/// If include_if_present == true, it only outputs the stats whose key is in
-/// "values"; otherwise it only outputs the stats whose key is not in "values".
-/// At input, "values" must be sorted and unique, and all stats in "stats_in"
-/// must have "key" defined.  At output, pointers to Clusterable* in stats_out
-/// are not newly allocated-- they are the same as the ones in stats_in.
-void FilterStatsByKey(const BuildTreeStatsType &stats_in,
-                      EventKeyType key,
-                      std::vector<EventValueType> &values,
-                      bool include_if_present,  // true-> retain only if in "values",
-                      // false-> retain only if not in "values".
-                      BuildTreeStatsType *stats_out);
-
-
-/// Sums stats, or returns NULL stats_in has no non-NULL stats.
-/// Stats are newly allocated, owned by caller.
-Clusterable *SumStats(const BuildTreeStatsType &stats_in);
-
-/// Sums the normalizer [typically, data-count] over the stats.
-BaseFloat SumNormalizer(const BuildTreeStatsType &stats_in);
-
-/// Sums the objective function over the stats.
-BaseFloat SumObjf(const BuildTreeStatsType &stats_in);
-
-
-/// Sum a vector of stats.  Leaves NULL as pointer if no stats available.
-/// The pointers in stats_out are owned by caller.  At output, there may be
-/// NULLs in the vector stats_out.
-void SumStatsVec(const std::vector<BuildTreeStatsType> &stats_in, std::vector<Clusterable*> *stats_out);
-
-/// Cluster the stats given the event map return the total objf given those clusters.
-BaseFloat ObjfGivenMap(const BuildTreeStatsType &stats_in, const EventMap &e);
-
-
-/// FindAllKeys puts in *keys the (sorted, unique) list of all key identities in the stats.
-/// If type == kAllKeysInsistIdentical, it will insist that this set of keys is the same for all the
-///   stats (else exception is thrown).
-/// if type == kAllKeysIntersection, it will return the smallest common set of keys present in
-///   the set of stats
-/// if type== kAllKeysUnion (currently probably not so useful since maps will return "undefined"
-///   if key is not present), it will return the union of all the keys present in the stats.
-void FindAllKeys(const BuildTreeStatsType &stats, AllKeysType keys_type,
-                 std::vector<EventKeyType> *keys);
-
-
-/// @}
-
-
-/**
- \defgroup tree_group_intermediate Intermediate-level functions used in building the tree
-    These functions are are used in top-level tree-building code (\ref tree_group_top); see
-     \ref tree_internals for documentation.
- \ingroup tree_group
- @{
-*/
-
-
-/// Returns a tree with just one node.  Used @ start of tree-building process.
-/// Not really used in current recipes.
-inline EventMap *TrivialTree(int32 *num_leaves) {
-  KALDI_ASSERT(*num_leaves == 0);  // in envisaged usage.
-  return new ConstantEventMap( (*num_leaves)++ );
-}
-
-/// DoTableSplit does a complete split on this key (e.g. might correspond to central phone
-/// (key = P-1), or HMM-state position (key == kPdfClass == -1).  Stats used to work out possible
-/// values of the event. "num_leaves" is used to allocate new leaves.   All stats must have
-/// this key defined, or this function will crash.
-EventMap *DoTableSplit(const EventMap &orig, EventKeyType key,
-                       const BuildTreeStatsType &stats, int32 *num_leaves);
-
-
-/// DoTableSplitMultiple does a complete split on all the keys, in order from keys[0],
-/// keys[1]
-/// and so on.  The stats are used to work out possible values corresponding to the key.
-/// "num_leaves" is used to allocate new leaves.   All stats must have
-/// the keys defined, or this function will crash.
-/// Returns a newly allocated event map.
-EventMap *DoTableSplitMultiple(const EventMap &orig,
-                               const std::vector<EventKeyType> &keys,
-                               const BuildTreeStatsType &stats,
-                               int32 *num_leaves);
-
-
-/// "ClusterEventMapGetMapping" clusters the leaves of the EventMap, with "thresh" a delta-likelihood
-/// threshold to control how many leaves we combine (might be the same as the delta-like
-/// threshold used in splitting.
-// The function returns the #leaves we combined.  The same leaf-ids of the leaves being clustered
-// will be used for the clustered leaves (but other than that there is no special rule which
-// leaf-ids should be used at output).
-// It outputs the mapping for leaves, in "mapping", which may be empty at the start
-// but may also contain mappings for other parts of the tree, which must contain
-// disjoint leaves from this part.  This is so that Cluster can
-// be called multiple times for sub-parts of the tree (with disjoint sets of leaves),
-// e.g. if we want to avoid sharing across phones.  Afterwards you can use Copy function
-// of EventMap to apply the mapping, i.e. call e_in.Copy(mapping) to get the new map.
-// Note that the application of Cluster creates gaps in the leaves.  You should then
-// call RenumberEventMap(e_in.Copy(mapping), num_leaves).
-// *If you only want to cluster a subset of the leaves (e.g. just non-silence, or just
-// a particular phone, do this by providing a set of "stats" that correspond to just
-// this subset of leaves*.  Leaves with no stats will not be clustered.
-// See build-tree.cc for an example of usage.
-int ClusterEventMapGetMapping(const EventMap &e_in, const BuildTreeStatsType &stats,
-                              BaseFloat thresh, std::vector<EventMap*> *mapping);
-
-/// This is as ClusterEventMapGetMapping but a more convenient interface
-/// that exposes less of the internals.  It uses a bottom-up clustering to
-/// combine the leaves, until the log-likelihood decrease from combinging two
-/// leaves exceeds the threshold.
-EventMap *ClusterEventMap(const EventMap &e_in, const BuildTreeStatsType &stats,
-                          BaseFloat thresh, int32 *num_removed);
-
-/// This is as ClusterEventMap, but first splits the stats on the keys specified
-/// in "keys" (e.g. typically keys = [ -1, P ]), and only clusters within the
-/// classes defined by that splitting.
-/// Note-- leaves will be non-consecutive at output, use RenumberEventMap.
-EventMap *ClusterEventMapRestrictedByKeys(const EventMap &e_in,
-                                          const BuildTreeStatsType &stats,
-                                          BaseFloat thresh,
-                                          const std::vector<EventKeyType> &keys,
-                                          int32 *num_removed);
-
-
-/// This version of ClusterEventMapRestricted restricts the clustering to only
-/// allow things that "e_restrict" maps to the same value to be clustered
-/// together.
-EventMap *ClusterEventMapRestrictedByMap(const EventMap &e_in,
-                                         const BuildTreeStatsType &stats,
-                                         BaseFloat thresh,
-                                         const EventMap &e_restrict,
-                                         int32 *num_removed);
-
-
-/// RenumberEventMap [intended to be used after calling ClusterEventMap] renumbers
-/// an EventMap so its leaves are consecutive.
-/// It puts the number of leaves in *num_leaves.  If later you need the mapping of
-/// the leaves, modify the function and add a new argument.
-EventMap *RenumberEventMap(const EventMap &e_in, int32 *num_leaves);
-
-/// This function remaps the event-map leaves using this mapping,
-/// indexed by the number at leaf.
-EventMap *MapEventMapLeaves(const EventMap &e_in,
-                            const std::vector<int32> &mapping);
-
-
-
-/// ShareEventMapLeaves performs a quite specific function that allows us to
-/// generate trees where, for a certain list of phones, and for all states in
-/// the phone, all the pdf's are shared.
-/// Each element of "values" contains a list of phones (may be just one phone),
-/// all states of which we want shared together).  Typically at input, "key" will
-/// equal P, the central-phone position, and "values" will contain just one
-/// list containing the silence phone.
-/// This function renumbers the event map leaves after doing the sharing, to
-/// make the event-map leaves contiguous.
-EventMap *ShareEventMapLeaves(const EventMap &e_in, EventKeyType key,
-                              std::vector<std::vector<EventValueType> > &values,
-                              int32 *num_leaves);
-
-
-
-/// Does a decision-tree split at the leaves of an EventMap.
-/// @param orig [in] The EventMap whose leaves we want to split. [may be either a trivial or a
-///           non-trivial one].
-/// @param stats [in] The statistics for splitting the tree; if you do not want a particular
-///          subset of leaves to be split, make sure the stats corresponding to those leaves
-///          are not present in "stats".
-/// @param qcfg [in] Configuration class that contains initial questions (e.g. sets of phones)
-///          for each key and says whether to refine these questions during tree building.
-/// @param thresh [in] A log-likelihood threshold (e.g. 300) that can be used to
-///           limit the number of leaves; you can use zero and set max_leaves instead.
-/// @param max_leaves [in] Will stop leaves being split after they reach this number.
-/// @param num_leaves [in,out] A pointer used to allocate leaves; always corresponds to the
-///             current number of leaves (is incremented when this is increased).
-/// @param objf_impr_out [out] If non-NULL, will be set to the objective improvement due to splitting
-///           (not normalized by the number of frames).
-/// @param smallest_split_change_out If non-NULL, will be set to the smallest objective-function
-///         improvement that we got from splitting any leaf; useful to provide a threshold
-///         for ClusterEventMap.
-/// @return The EventMap after splitting is returned; pointer is owned by caller.
-EventMap *SplitDecisionTree(const EventMap &orig,
-                            const BuildTreeStatsType &stats,
-                            Questions &qcfg,
-                            BaseFloat thresh,
-                            int32 max_leaves,  // max_leaves<=0 -> no maximum.
-                            int32 *num_leaves,
-                            BaseFloat *objf_impr_out,
-                            BaseFloat *smallest_split_change_out);
-
-/// CreateRandomQuestions will initialize a Questions randomly, in a reasonable
-/// way [for testing purposes, or when hand-designed questions are not available].
-/// e.g. num_quest = 5 might be a reasonable value if num_iters > 0, or num_quest = 20 otherwise.
-void CreateRandomQuestions(const BuildTreeStatsType &stats, int32 num_quest, Questions *cfg_out);
-
-
-/// FindBestSplitForKey is a function used in DoDecisionTreeSplit.
-/// It finds the best split for this key, given these stats.
-/// It will return 0 if the key was not always defined for the stats.
-BaseFloat FindBestSplitForKey(const BuildTreeStatsType &stats,
-                              const Questions &qcfg,
-                              EventKeyType key,
-                              std::vector<EventValueType> *yes_set);
-
-
-/// GetStubMap is used in tree-building functions to get the initial
-/// to-states map, before the decision-tree-building process.  It creates
-/// a simple map that splits on groups of phones.  For the set of phones in
-/// phone_sets[i] it creates either: if share_roots[i] == true, a single
-/// leaf node, or if share_roots[i] == false, separate root nodes for
-/// each HMM-position (it goes up to the highest position for any
-/// phone in the set, although it will warn if you share roots between
-/// phones with different numbers of states, which is a weird thing to
-/// do but should still work.  If any phone is present
-/// in "phone_sets" but "phone2num_pdf_classes" does not map it to a length,
-/// it is an error.  Note that the behaviour of the resulting map is
-/// undefined for phones not present in "phone_sets".
-/// At entry, this function should be called with (*num_leaves == 0).
-/// It will number the leaves starting from (*num_leaves).
-
-EventMap *GetStubMap(int32 P,
-                     const std::vector<std::vector<int32> > &phone_sets,
-                     const std::vector<int32> &phone2num_pdf_classes,
-                     const std::vector<bool> &share_roots,  // indexed by index into phone_sets.
-                     int32 *num_leaves);
-/// Note: GetStubMap with P = 0 can be used to get a standard monophone system.
-
-/// @}
-
-
-}// end namespace kaldi
-
-#endif
diff --git a/kaldi_io/src/kaldi/tree/build-tree.h b/kaldi_io/src/kaldi/tree/build-tree.h
deleted file mode 100644
index 37bb108..0000000
--- a/kaldi_io/src/kaldi/tree/build-tree.h
+++ /dev/null
@@ -1,250 +0,0 @@
-// tree/build-tree.h
-
-// Copyright 2009-2011  Microsoft Corporation
-
-// 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_TREE_BUILD_TREE_H_
-#define KALDI_TREE_BUILD_TREE_H_
-
-// The file build-tree.h contains outer-level routines used in tree-building
-// and related tasks, that are directly called by the command-line tools.
-
-#include "tree/build-tree-utils.h"
-#include "tree/context-dep.h"
-namespace kaldi {
-
-/// \defgroup tree_group_top Top-level tree-building functions
-/// See \ref tree_internals for context.
-/// \ingroup tree_group
-/// @{
-
-// Note, in tree_group_top we also include AccumulateTreeStats, in
-// ../hmm/tree-accu.h (it has some extra dependencies so we didn't
-// want to include it here).
-
-/**
- *  BuildTree is the normal way to build a set of decision trees.
- *  The sets "phone_sets" dictate how we set up the roots of the decision trees.
- *  each set of phones phone_sets[i] has shared decision-tree roots, and if
- *  the corresponding variable share_roots[i] is true, the root will be shared
- *  for the different HMM-positions in the phone.  All phones in "phone_sets"
- *  should be in the stats (use FixUnseenPhones to ensure this).
- *  if for any i, do_split[i] is false, we will not do any tree splitting for
- *  phones in that set.
- * @param qopts [in] Questions options class, contains questions for each key
- *                   (e.g. each phone position)
- * @param phone_sets [in] Each element of phone_sets is a set of phones whose
- *                 roots are shared together (prior to decision-tree splitting).
- * @param phone2num_pdf_classes [in] A map from phones to the number of
- *                 \ref pdf_class "pdf-classes"
- *                 in the phone (this info is derived from the HmmTopology object)
- * @param share_roots [in] A vector the same size as phone_sets; says for each
- *                phone set whether the root should be shared among all the
- *                pdf-classes or not.
- * @param do_split [in] A vector the same size as phone_sets; says for each
- *                phone set whether decision-tree splitting should be done
- *                 (generally true for non-silence phones).
- * @param stats [in] The statistics used in tree-building.
- * @param thresh [in] Threshold used in decision-tree splitting (e.g. 1000),
- *                   or you may use 0 in which case max_leaves becomes the
- *                    constraint.
- * @param max_leaves [in] Maximum number of leaves it will create; set this
- *                  to a large number if you want to just specify  "thresh".
- * @param cluster_thresh [in] Threshold for clustering leaves after decision-tree
- *                  splitting (only within each phone-set); leaves will be combined
- *                  if log-likelihood change is less than this.  A value about equal
- *                  to "thresh" is suitable
- *                  if thresh != 0; otherwise, zero will mean no clustering is done,
- *                  or a negative value (e.g. -1) sets it to the smallest likelihood
- *                  change seen during the splitting algorithm; this typically causes
- *                  about a 20% reduction in the number of leaves.
- 
- * @param P [in] The central position of the phone context window, e.g. 1 for a
- *                triphone system.
- * @return  Returns a pointer to an EventMap object that is the tree.
-
-*/
-
-EventMap *BuildTree(Questions &qopts,
-                    const std::vector<std::vector<int32> > &phone_sets,
-                    const std::vector<int32> &phone2num_pdf_classes,
-                    const std::vector<bool> &share_roots,
-                    const std::vector<bool> &do_split,
-                    const BuildTreeStatsType &stats,
-                    BaseFloat thresh,
-                    int32 max_leaves,
-                    BaseFloat cluster_thresh,  // typically == thresh.  If negative, use smallest split.
-                    int32 P);
-
-
-/**
- *
- *  BuildTreeTwoLevel builds a two-level tree, useful for example in building tied mixture
- *  systems with multiple codebooks.  It first builds a small tree by splitting to
- *  "max_leaves_first".  It then splits at the leaves of "max_leaves_first" (think of this
- *  as creating multiple little trees at the leaves of the first tree), until the total
- *  number of leaves reaches "max_leaves_second".  It then outputs the second tree, along
- *  with a mapping from the leaf-ids of the second tree to the leaf-ids of the first tree.
- *  Note that the interface is similar to BuildTree, and in fact it calls BuildTree
- *  internally.
- *
- *  The sets "phone_sets" dictate how we set up the roots of the decision trees.
- *  each set of phones phone_sets[i] has shared decision-tree roots, and if
- *  the corresponding variable share_roots[i] is true, the root will be shared
- *  for the different HMM-positions in the phone.  All phones in "phone_sets"
- *  should be in the stats (use FixUnseenPhones to ensure this).
- *  if for any i, do_split[i] is false, we will not do any tree splitting for
- *  phones in that set.
- *
- * @param qopts [in] Questions options class, contains questions for each key
- *                   (e.g. each phone position)
- * @param phone_sets [in] Each element of phone_sets is a set of phones whose
- *                 roots are shared together (prior to decision-tree splitting).
- * @param phone2num_pdf_classes [in] A map from phones to the number of
- *                 \ref pdf_class "pdf-classes"
- *                 in the phone (this info is derived from the HmmTopology object)
- * @param share_roots [in] A vector the same size as phone_sets; says for each
- *                phone set whether the root should be shared among all the
- *                pdf-classes or not.
- * @param do_split [in] A vector the same size as phone_sets; says for each
- *                phone set whether decision-tree splitting should be done
- *                 (generally true for non-silence phones).
- * @param stats [in] The statistics used in tree-building.
- * @param max_leaves_first [in] Maximum number of leaves it will create in first
- *                  level of decision tree. 
- * @param max_leaves_second [in] Maximum number of leaves it will create in second
- *                  level of decision tree.  Must be > max_leaves_first.
- * @param cluster_leaves [in] Boolean value; if true, we post-cluster the leaves produced
- *                  in the second level of decision-tree split; if false, we don't.
- *                  The threshold for post-clustering is the log-like change of the last
- *                  decision-tree split; this typically causes about a 20% reduction in
- *                  the number of leaves.
- * @param P [in]   The central position of the phone context window, e.g. 1 for a
- *                 triphone system.
- * @param leaf_map [out]  Will be set to be a mapping from the leaves of the
- *                 "big" tree to the leaves of the "little" tree, which you can
- *                 view as cluster centers.
- * @return  Returns a pointer to an EventMap object that is the (big) tree.
-
-*/
-
-EventMap *BuildTreeTwoLevel(Questions &qopts,
-                            const std::vector<std::vector<int32> > &phone_sets,
-                            const std::vector<int32> &phone2num_pdf_classes,
-                            const std::vector<bool> &share_roots,
-                            const std::vector<bool> &do_split,
-                            const BuildTreeStatsType &stats,
-                            int32 max_leaves_first,
-                            int32 max_leaves_second,
-                            bool cluster_leaves,
-                            int32 P,
-                            std::vector<int32> *leaf_map);
-
-
-/// GenRandStats generates random statistics of the form used by BuildTree.
-/// It tries to do so in such a way that they mimic "real" stats.  The event keys
-/// and their corresponding values are:
-/// - key == -1 == kPdfClass -> pdf-class, generally corresponds to
-///       zero-based position in HMM (0, 1, 2 .. hmm_lengths[phone]-1)
-/// - key == 0 -> phone-id of left-most context phone.
-/// - key == 1 -> phone-id of one-from-left-most context phone.
-/// - key == P-1 -> phone-id of central phone.
-/// - key == N-1 -> phone-id of right-most context phone.
-/// GenRandStats is useful only for testing but it serves to document the format of
-/// stats used by BuildTreeDefault.
-/// if is_ctx_dep[phone] is set to false, GenRandStats will not define the keys for
-/// other than the P-1'th phone.
-
-/// @param dim [in] dimension of features.
-/// @param num_stats [in] approximate number of separate phones-in-context wanted.
-/// @param N [in] context-size (typically 3)
-/// @param P [in] central-phone position in zero-based numbering (typically 1)
-/// @param phone_ids [in] integer ids of phones
-/// @param hmm_lengths [in] lengths of hmm for phone, indexed by phone.
-/// @param is_ctx_dep [in] boolean array indexed by phone, saying whether each phone
-///     is context dependent.
-/// @param ensure_all_phones_covered [in] Boolean argument: if true, GenRandStats
-///     ensures that every phone is seen at least once in the central position (P).
-/// @param stats_out [out] The statistics that this routine outputs.
-
-void GenRandStats(int32 dim, int32 num_stats, int32 N, int32 P,
-                  const std::vector<int32> &phone_ids,
-                  const std::vector<int32> &hmm_lengths,
-                  const std::vector<bool> &is_ctx_dep,
-                  bool ensure_all_phones_covered,
-                  BuildTreeStatsType *stats_out);
-
-
-/// included here because it's used in some tree-building
-/// calling code.  Reads an OpenFst symbl table,
-/// discards the symbols and outputs the integers
-void ReadSymbolTableAsIntegers(std::string filename,
-                               bool include_eps,
-                               std::vector<int32> *syms);
-
-
-
-/**
- *  Outputs sets of phones that are reasonable for questions
- *  to ask in the tree-building algorithm.  These are obtained by tree
- *  clustering of the phones; for each node in the tree, all the leaves
- *  accessible from that node form one of the sets of phones.
- *    @param stats [in] The statistics as used for normal tree-building.
- *    @param phone_sets_in [in] All the phones, pre-partitioned into sets.
- *       The output sets will be various unions of these sets.  These sets
- *       will normally correspond to "real phones", in cases where the phones
- *       have stress and position markings.
- *    @param all_pdf_classes_in [in] All the \ref pdf_class "pdf-classes"
- *      that we consider for clustering.  In the normal case this is the singleton
- *       set {1}, which means that we only consider the central hmm-position
- *       of the standard 3-state HMM, for clustering purposes.
- *    @param P [in] The central position in the phone context window; normally
- *       1 for triphone system.s
- *    @param questions_out [out] The questions (sets of phones) are output to here.
- **/
-void AutomaticallyObtainQuestions(BuildTreeStatsType &stats,
-                                  const std::vector<std::vector<int32> > &phone_sets_in,
-                                  const std::vector<int32> &all_pdf_classes_in,
-                                  int32 P,
-                                  std::vector<std::vector<int32> > *questions_out);
-
-/// This function clusters the phones (or some initially specified sets of phones)
-/// into sets of phones, using a k-means algorithm.  Useful, for example, in building
-/// simple models for purposes of adaptation.
-
-void KMeansClusterPhones(BuildTreeStatsType &stats,
-                         const std::vector<std::vector<int32> > &phone_sets_in,
-                         const std::vector<int32> &all_pdf_classes_in,
-                         int32 P,
-                         int32 num_classes,
-                         std::vector<std::vector<int32> > *sets_out);
-
-/// Reads the roots file (throws on error).  Format is lines like:
-///  "shared split 1 2 3 4",
-///  "not-shared not-split 5",
-/// and so on.  The numbers are indexes of phones.
-void ReadRootsFile(std::istream &is,
-                   std::vector<std::vector<int32> > *phone_sets,
-                   std::vector<bool> *is_shared_root,
-                   std::vector<bool> *is_split_root);
-
-
-/// @}
-
-}// end namespace kaldi
-
-#endif
diff --git a/kaldi_io/src/kaldi/tree/cluster-utils.h b/kaldi_io/src/kaldi/tree/cluster-utils.h
deleted file mode 100644
index 55583a2..0000000
--- a/kaldi_io/src/kaldi/tree/cluster-utils.h
+++ /dev/null
@@ -1,291 +0,0 @@
-// tree/cluster-utils.h
-
-// Copyright 2012   Arnab Ghoshal
-// Copyright 2009-2011  Microsoft Corporation;  Saarland University
-
-// 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_TREE_CLUSTER_UTILS_H_
-#define KALDI_TREE_CLUSTER_UTILS_H_
-
-#include <vector>
-#include "matrix/matrix-lib.h"
-#include "itf/clusterable-itf.h"
-
-namespace kaldi {
-
-/// \addtogroup clustering_group_simple
-/// @{
-
-/// Returns the total objective function after adding up all the
-/// statistics in the vector (pointers may be NULL).
-BaseFloat SumClusterableObjf(const std::vector<Clusterable*> &vec);
-
-/// Returns the total normalizer (usually count) of the cluster (pointers may be NULL).
-BaseFloat SumClusterableNormalizer(const std::vector<Clusterable*> &vec);
-
-/// Sums stats (ptrs may be NULL). Returns NULL if no non-NULL stats present.
-Clusterable *SumClusterable(const std::vector<Clusterable*> &vec);
-
-/** Fills in any (NULL) holes in "stats" vector, with empty stats, because
- *  certain algorithms require non-NULL stats.  If "stats" nonempty, requires it
- *  to contain at least one non-NULL pointer that we can call Copy() on.
- */
-void EnsureClusterableVectorNotNull(std::vector<Clusterable*> *stats);
-
-
-/** Given stats and a vector "assignments" of the same size (that maps to
- * cluster indices), sums the stats up into "clusters."  It will add to any
- * stats already present in "clusters" (although typically "clusters" will be
- * empty when called), and it will extend with NULL pointers for any unseen
- * indices. Call EnsureClusterableStatsNotNull afterwards if you want to ensure
- * all non-NULL clusters. Pointer in "clusters" are owned by caller. Pointers in
- * "stats" do not have to be non-NULL.
- */
-void AddToClusters(const std::vector<Clusterable*> &stats,
-                   const std::vector<int32> &assignments,
-                   std::vector<Clusterable*> *clusters);
-
-
-/// AddToClustersOptimized does the same as AddToClusters (it sums up the stats
-/// within each cluster, except it uses the sum of all the stats ("total") to
-/// optimize the computation for speed, if possible.  This will generally only be
-/// a significant speedup in the case where there are just two clusters, which
-/// can happen in algorithms that are doing binary splits; the idea is that we
-/// sum up all the stats in one cluster (the one with the fewest points in it),
-/// and then subtract from the total.
-void AddToClustersOptimized(const std::vector<Clusterable*> &stats,
-                            const std::vector<int32> &assignments,
-                            const Clusterable &total,
-                            std::vector<Clusterable*> *clusters);
-
-/// @} end "addtogroup clustering_group_simple"
-
-/// \addtogroup clustering_group_algo
-/// @{
-
-// Note, in the algorithms below, it is assumed that the input "points" (which
-// is std::vector<Clusterable*>) is all non-NULL.
-
-/** A bottom-up clustering algorithm. There are two parameters that control how
- *  many clusters we get: a "max_merge_thresh" which is a threshold for merging
- *  clusters, and a min_clust which puts a floor on the number of clusters we want. Set
- *  max_merge_thresh = large to use the min_clust only, or min_clust to 0 to use
- *  the max_merge_thresh only.
- *
- *  The algorithm is:
- *  \code
- *      while (num-clusters > min_clust && smallest_merge_cost <= max_merge_thresh)
- *          merge the closest two clusters.
- *  \endcode
- *
- *  @param points [in] Points to be clustered (may not contain NULL pointers)
- *  @param thresh [in] Threshold on cost change from merging clusters; clusters
- *               won't be merged if the cost is more than this
- *  @param min_clust [in] Minimum number of clusters desired; we'll stop merging
- *                  after reaching this number.
- *  @param clusters_out [out] If non-NULL, will be set to a vector of size equal
- *                 to the number of output clusters, containing the clustered
- *                 statistics.  Must be empty when called.
- *  @param assignments_out [out] If non-NULL, will be resized to the number of
- *                 points, and each element is the index of the cluster that point
- *                 was assigned to.
- *  @return Returns the total objf change relative to all clusters being separate, which is
- *    a negative.  Note that this is not the same as what the other clustering algorithms return.
- */
-BaseFloat ClusterBottomUp(const std::vector<Clusterable*> &points,
-                          BaseFloat thresh,
-                          int32 min_clust,
-                          std::vector<Clusterable*> *clusters_out,
-                          std::vector<int32> *assignments_out);
-
-/** This is a bottom-up clustering where the points are pre-clustered in a set
- *  of compartments, such that only points in the same compartment are clustered
- *  together. The compartment and pair of points with the smallest merge cost
- *  is selected and the points are clustered. The result stays in the same
- *  compartment. The code does not merge compartments, and hence assumes that
- *  the number of compartments is smaller than the 'min_clust' option.
- *  The clusters in "clusters_out" are newly allocated and owned by the caller.
- */
-BaseFloat ClusterBottomUpCompartmentalized(
-    const std::vector< std::vector<Clusterable*> > &points, BaseFloat thresh,
-    int32 min_clust, std::vector< std::vector<Clusterable*> > *clusters_out,
-    std::vector< std::vector<int32> > *assignments_out);
-
-
-struct RefineClustersOptions {
-  int32 num_iters;  // must be >= 0.  If zero, does nothing.
-  int32 top_n;  // must be >= 2.
-  RefineClustersOptions() : num_iters(100), top_n(5) {}
-  RefineClustersOptions(int32 num_iters_in, int32 top_n_in)
-      : num_iters(num_iters_in), top_n(top_n_in) {}
-  // include Write and Read functions because this object gets written/read as
-  // part of the QuestionsForKeyOptions class.
-  void Write(std::ostream &os, bool binary) const;
-  void Read(std::istream &is, bool binary);
-};
-
-/** RefineClusters is mainly used internally by other clustering algorithms.
- *
- *  It starts with a given assignment of points to clusters and
- *  keeps trying to improve it by moving points from cluster to cluster, up to
- *  a maximum number of iterations.
- *
- *  "clusters" and "assignments" are both input and output variables, and so
- *  both MUST be non-NULL.
- *
- *  "top_n" (>=2) is a pruning value: more is more exact, fewer is faster. The
- *  algorithm initially finds the "top_n" closest clusters to any given point,
- *  and from that point only consider move to those "top_n" clusters. Since
- *  RefineClusters is called multiple times from ClusterKMeans (for instance),
- *  this is not really a limitation.
- */
-BaseFloat RefineClusters(const std::vector<Clusterable*> &points,
-                         std::vector<Clusterable*> *clusters /*non-NULL*/,
-                         std::vector<int32> *assignments /*non-NULL*/,
-                         RefineClustersOptions cfg = RefineClustersOptions());
-
-struct ClusterKMeansOptions {
-  RefineClustersOptions refine_cfg;
-  int32 num_iters;
-  int32 num_tries;  // if >1, try whole procedure >once and pick best.
-  bool verbose;
-  ClusterKMeansOptions()
-      : refine_cfg(), num_iters(20), num_tries(2), verbose(true)  {}
-};
-
-/** ClusterKMeans is a K-means-like clustering algorithm. It starts with
- *  pseudo-random initialization of points to clusters and uses RefineClusters
- *  to iteratively improve the cluster assignments.  It does this for
- *  multiple iterations and picks the result with the best objective function.
- *
- *
- *  ClusterKMeans implicitly uses Rand(). It will not necessarily return
- *  the same value on different calls.  Use sRand() if you want consistent
- *  results.
- *  The algorithm used in ClusterKMeans is a "k-means-like" algorithm that tries
- *  to be as efficient as possible.  Firstly, since the algorithm it uses
- *  includes random initialization, it tries the whole thing cfg.num_tries times
- *  and picks the one with the best objective function.  Each try, it does as
- *  follows: it randomly initializes points to clusters, and then for
- *  cfg.num_iters iterations it calls RefineClusters().  The options to
- *  RefineClusters() are given by cfg.refine_cfg.  Calling RefineClusters once
- *  will always be at least as good as doing one iteration of reassigning points to
- *  clusters, but will generally be quite a bit better (without taking too
- *  much extra time).
- *
- *  @param points [in]  points to be clustered (must be all non-NULL).
- *  @param num_clust [in] number of clusters requested (it will always return exactly
- *                 this many, or will fail if num_clust > points.size()).
- *  @param clusters_out [out] may be NULL; if non-NULL, should be empty when called.
- *          Will be set to a vector of statistics corresponding to the output clusters.
- *  @param assignments_out [out] may be NULL; if non-NULL, will be set to a vector of
- *             same size as "points", which says for each point which cluster
- *              it is assigned to.
- *  @param cfg [in] configuration class specifying options to the algorithm.
- *  @return Returns the objective function improvement versus everything being
- *     in the same cluster.
- *
- */
-BaseFloat ClusterKMeans(const std::vector<Clusterable*> &points,
-                        int32 num_clust,  // exact number of clusters
-                        std::vector<Clusterable*> *clusters_out,  // may be NULL
-                        std::vector<int32> *assignments_out,  // may be NULL
-                        ClusterKMeansOptions cfg = ClusterKMeansOptions());
-
-struct TreeClusterOptions  {
-  ClusterKMeansOptions kmeans_cfg;
-  int32 branch_factor;
-  BaseFloat thresh;  // Objf change: if >0, may be used to control number of leaves.
-  TreeClusterOptions()
-      : kmeans_cfg(), branch_factor(2), thresh(0) {
-    kmeans_cfg.verbose = false;
-  }
-};
-
-/** TreeCluster is a top-down clustering algorithm, using a binary tree (not
- *  necessarily balanced). Returns objf improvement versus having all points
- *  in one cluster.  The algorithm is:
- *     - Initialize to 1 cluster (tree with 1 node).
- *     - Maintain, for each cluster, a "best-binary-split" (using ClusterKMeans
- *       to do so). Always split the highest scoring cluster, until we can do no
- *       more splits.
- *
- *  @param points [in] Data points to be clustered
- *  @param max_clust  [in] Maximum number of clusters (you will get exactly this number,
- *                if there are at least this many points, except if you set the
- *                cfg.thresh value nonzero, in which case that threshold may limit
- *                the number of clusters.
- *  @param clusters_out [out] If non-NULL, will be set to the a vector whose first
- *                (*num_leaves_out) elements are the leaf clusters, and whose
- *                subsequent elements are the nonleaf nodes in the tree, in
- *                topological order with the root node last.  Must be empty vector
- *                when this function is called.
- *  @param assignments_out [out] If non-NULL, will be set to a vector to a vector the
- *               same size as "points", where assignments[i] is the leaf node index i
- *               to which the i'th point gets clustered.
- *  @param clust_assignments_out [out] If non-NULL, will be set to a vector the same size
- *                as clusters_out  which says for each node (leaf or nonleaf), the
- *                index of its parent.  For the root node (which is last),
- *                assignments_out[i] == i.  For each i, assignments_out[i]>=i, i.e.
- *                any node's parent is higher numbered than itself.  If you don't need
- *                this information, consider using instead the ClusterTopDown function.
- *  @param num_leaves_out [out] If non-NULL, will be set to the number of leaf nodes
- *                in the tree.
- *  @param cfg [in] Configuration object that controls clustering behavior.  Most
- *                 important value is "thresh", which provides an alternative mechanism
- *                 [other than max_clust] to limit the number of leaves.
- */
-BaseFloat TreeCluster(const std::vector<Clusterable*> &points,
-                      int32 max_clust,  // max number of leaf-level clusters.
-                      std::vector<Clusterable*> *clusters_out,
-                      std::vector<int32> *assignments_out,
-                      std::vector<int32> *clust_assignments_out,
-                      int32 *num_leaves_out,
-                      TreeClusterOptions cfg = TreeClusterOptions());
-
-
-/**
- *  A clustering algorithm that internally uses TreeCluster,
- *  but does not give you the information about the structure of the tree.
- *  The "clusters_out" and "assignments_out" may be NULL if the outputs are not
- *  needed.
- *
- *  @param points [in]  points to be clustered (must be all non-NULL).
- *  @param max_clust [in] Maximum number of clusters (you will get exactly this number,
- *                if there are at least this many points, except if you set the
- *                cfg.thresh value nonzero, in which case that threshold may limit
- *                the number of clusters.
- *  @param clusters_out [out] may be NULL; if non-NULL, should be empty when called.
- *           Will be set to a vector of statistics corresponding to the output clusters.
- *  @param assignments_out [out] may be NULL; if non-NULL, will be set to a vector of
- *           same size as "points", which says for each point which cluster
- *            it is assigned to.
- *  @param cfg [in] Configuration object that controls clustering behavior.  Most
- *                important value is "thresh", which provides an alternative mechanism
- *                [other than max_clust] to limit the number of leaves.
-*/
-BaseFloat ClusterTopDown(const std::vector<Clusterable*> &points,
-                         int32 max_clust,  // max number of clusters.
-                         std::vector<Clusterable*> *clusters_out,
-                         std::vector<int32> *assignments_out,
-                         TreeClusterOptions cfg = TreeClusterOptions());
-
-/// @} end of "addtogroup clustering_group_algo"
-
-}  // end namespace kaldi.
-
-#endif  // KALDI_TREE_CLUSTER_UTILS_H_
diff --git a/kaldi_io/src/kaldi/tree/clusterable-classes.h b/kaldi_io/src/kaldi/tree/clusterable-classes.h
deleted file mode 100644
index 817d0c6..0000000
--- a/kaldi_io/src/kaldi/tree/clusterable-classes.h
+++ /dev/null
@@ -1,158 +0,0 @@
-// tree/clusterable-classes.h
-
-// Copyright 2009-2011  Microsoft Corporation;  Saarland University
-//                2014  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_TREE_CLUSTERABLE_CLASSES_H_
-#define KALDI_TREE_CLUSTERABLE_CLASSES_H_ 1
-
-#include <string>
-#include "itf/clusterable-itf.h"
-#include "matrix/matrix-lib.h"
-
-namespace kaldi {
-
-// Note: see sgmm/sgmm-clusterable.h for an SGMM-based clusterable
-// class.  We didn't include it here, to avoid adding an extra
-// dependency to this directory.
-
-/// \addtogroup clustering_group
-/// @{
-
-/// ScalarClusterable clusters scalars with x^2 loss.
-class ScalarClusterable: public Clusterable {
- public:
-  ScalarClusterable(): x_(0), x2_(0), count_(0) {}
-  explicit ScalarClusterable(BaseFloat x): x_(x), x2_(x*x), count_(1) {}
-  virtual std::string Type() const { return "scalar"; }
-  virtual BaseFloat Objf() const;
-  virtual void SetZero() { count_ = x_ = x2_ = 0.0; }
-  virtual void Add(const Clusterable &other_in);
-  virtual void Sub(const Clusterable &other_in);
-  virtual Clusterable* Copy() const;
-  virtual BaseFloat Normalizer() const {
-    return static_cast<BaseFloat>(count_);
-  }
-
-  // Function to write data to stream. Will organize input later [more complex]
-  virtual void Write(std::ostream &os, bool binary) const;
-  virtual Clusterable* ReadNew(std::istream &is, bool binary) const;
-
-  std::string Info();  // For debugging.
-  BaseFloat Mean() { return (count_ != 0 ? x_/count_ : 0.0); }
-  private:
-  BaseFloat x_;
-  BaseFloat x2_;
-  BaseFloat count_;
-
-  void Read(std::istream &is, bool binary);
-};
-
-
-/// GaussClusterable wraps Gaussian statistics in a form accessible
-/// to generic clustering algorithms.
-class GaussClusterable: public Clusterable {
- public:
-  GaussClusterable(): count_(0.0), var_floor_(0.0) {}
-  GaussClusterable(int32 dim, BaseFloat var_floor):
-      count_(0.0), stats_(2, dim), var_floor_(var_floor) {}
-
-  GaussClusterable(const Vector<BaseFloat> &x_stats,
-                   const Vector<BaseFloat> &x2_stats,
-                   BaseFloat var_floor, BaseFloat count);
-
-  virtual std::string Type() const {  return "gauss"; }
-  void AddStats(const VectorBase<BaseFloat> &vec, BaseFloat weight = 1.0);
-  virtual BaseFloat Objf() const;
-  virtual void SetZero();
-  virtual void Add(const Clusterable &other_in);
-  virtual void Sub(const Clusterable &other_in);
-  virtual BaseFloat Normalizer() const { return count_; }
-  virtual Clusterable *Copy() const;
-  virtual void Scale(BaseFloat f);
-  virtual void Write(std::ostream &os, bool binary) const;
-  virtual Clusterable *ReadNew(std::istream &is, bool binary) const;
-  virtual ~GaussClusterable() {}
-
-  BaseFloat count() const { return count_; }
-  // The next two functions are not const-correct, because of SubVector.
-  SubVector<double> x_stats() const { return stats_.Row(0); }
-  SubVector<double> x2_stats() const { return stats_.Row(1); }
- private:
-  double count_;
-  Matrix<double> stats_; // two rows: sum, then sum-squared.
-  double var_floor_;  // should be common for all objects created.
-
-  void Read(std::istream &is, bool binary);
-};
-
-/// @} end of "addtogroup clustering_group"
-
-inline void GaussClusterable::SetZero() {
-  count_ = 0;
-  stats_.SetZero();
-}
-
-inline GaussClusterable::GaussClusterable(const Vector<BaseFloat> &x_stats,
-                                          const Vector<BaseFloat> &x2_stats,
-                                          BaseFloat var_floor, BaseFloat count):
-    count_(count), stats_(2, x_stats.Dim()), var_floor_(var_floor) {
-  stats_.Row(0).CopyFromVec(x_stats);
-  stats_.Row(1).CopyFromVec(x2_stats);
-}
-
-
-/// VectorClusterable wraps vectors in a form accessible to generic clustering
-/// algorithms.  Each vector is associated with a weight; these could be 1.0.
-/// The objective function (to be maximized) is the negated sum of squared
-/// distances from the cluster center to each vector, times that vector's
-/// weight.
-class VectorClusterable: public Clusterable {
- public:
-  VectorClusterable(): weight_(0.0), sumsq_(0.0) {}
-
-  VectorClusterable(const Vector<BaseFloat> &vector,
-                    BaseFloat weight);
-
-  virtual std::string Type() const {  return "vector"; }
-  // Objf is negated weighted sum of squared distances.
-  virtual BaseFloat Objf() const;
-  virtual void SetZero() { weight_ = 0.0; sumsq_ = 0.0; stats_.Set(0.0); }
-  virtual void Add(const Clusterable &other_in);
-  virtual void Sub(const Clusterable &other_in);
-  virtual BaseFloat Normalizer() const { return weight_; }
-  virtual Clusterable *Copy() const;
-  virtual void Scale(BaseFloat f);
-  virtual void Write(std::ostream &os, bool binary) const;
-  virtual Clusterable *ReadNew(std::istream &is, bool binary) const;
-  virtual ~VectorClusterable() {}
-
- private:
-  double weight_;  // sum of weights of the source vectors.  Never negative.
-  Vector<double> stats_; // Equals the weighted sum of the source vectors.
-  double sumsq_;  // Equals the sum over all sources, of weight_ * vec.vec,
-                  // where vec = stats_ / weight_.  Used in computing
-                  // the objective function.
-  void Read(std::istream &is, bool binary);
-};
-
-
-
-}  // end namespace kaldi.
-
-#endif  // KALDI_TREE_CLUSTERABLE_CLASSES_H_
diff --git a/kaldi_io/src/kaldi/tree/context-dep.h b/kaldi_io/src/kaldi/tree/context-dep.h
deleted file mode 100644
index 307fcd4..0000000
--- a/kaldi_io/src/kaldi/tree/context-dep.h
+++ /dev/null
@@ -1,166 +0,0 @@
-// tree/context-dep.h
-
-// Copyright 2009-2011  Microsoft Corporation
-
-// 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_TREE_CONTEXT_DEP_H_
-#define KALDI_TREE_CONTEXT_DEP_H_
-
-#include "itf/context-dep-itf.h"
-#include "tree/event-map.h"
-#include "matrix/matrix-lib.h"
-#include "tree/cluster-utils.h"
-
-/*
-  This header provides the declarations for the class ContextDependency, which inherits
-  from the interface class "ContextDependencyInterface" in itf/context-dep-itf.h.
-  This is basically a wrapper around an EventMap.  The EventMap
-  (tree/event-map.h) declares most of the internals of the class, and the building routines are
-  in build-tree.h which uses build-tree-utils.h, which uses cluster-utils.h . */
-
-
-namespace kaldi {
-
-static const EventKeyType kPdfClass = -1;  // The "name" to which we assign the
-// pdf-class (generally corresponds ot position in the HMM, zero-based);
-// must not be used for any other event.  I.e. the value corresponding to
-// this key is the pdf-class (see hmm-topology.h for explanation of what this is).
-
-
-/* ContextDependency is quite a generic decision tree.
-
-   It does not actually do very much-- all the magic is in the EventMap object.
-   All this class does is to encode the phone context as a sequence of events, and
-   pass this to the EventMap object to turn into what it will interpret as a
-   vector of pdfs.
-
-   Different versions of the ContextDependency class that are written in the future may
-   have slightly different interfaces and pass more stuff in as events, to the
-   EventMap object.
-
-   In order to separate the process of training decision trees from the process
-   of actually using them, we do not put any training code into the ContextDependency class.
- */
-class ContextDependency: public ContextDependencyInterface {
- public:
-  virtual int32 ContextWidth() const { return N_; }
-  virtual int32 CentralPosition() const { return P_; }
-
-
-  /// returns success or failure; outputs pdf to pdf_id
-  virtual bool Compute(const std::vector<int32> &phoneseq,
-                       int32 pdf_class, int32 *pdf_id) const;
-
-  virtual int32 NumPdfs() const {
-    // this routine could be simplified to return to_pdf_->MaxResult()+1.  we're a
-    // bit more paranoid than that.
-    if (!to_pdf_) return 0;
-    EventAnswerType max_result = to_pdf_->MaxResult();
-    if (max_result < 0 ) return 0;
-    else return (int32) max_result+1;
-  }
-  virtual ContextDependencyInterface *Copy() const {
-    return new ContextDependency(N_, P_, to_pdf_->Copy());
-  }
-
-  /// Read context-dependency object from disk; throws on error
-  void Read (std::istream &is, bool binary);
-
-  // Constructor with no arguments; will normally be called
-  // prior to Read()
-  ContextDependency(): N_(0), P_(0), to_pdf_(NULL) { }
-
-  // Constructor takes ownership of pointers.
-  ContextDependency(int32 N, int32 P,
-                    EventMap *to_pdf):
-      N_(N), P_(P), to_pdf_(to_pdf) { }
-  void Write (std::ostream &os, bool binary) const;
-
-  ~ContextDependency() { if (to_pdf_ != NULL) delete to_pdf_; }
-
-  const EventMap &ToPdfMap() const { return *to_pdf_; }
-
-  /// GetPdfInfo returns a vector indexed by pdf-id, saying for each pdf which
-  /// pairs of (phone, pdf-class) it can correspond to.  (Usually just one).
-  /// c.f. hmm/hmm-topology.h for meaning of pdf-class.
-
-  void GetPdfInfo(const std::vector<int32> &phones,  // list of phones
-                  const std::vector<int32> &num_pdf_classes,  // indexed by phone,
-                  std::vector<std::vector<std::pair<int32, int32> > > *pdf_info)
-      const;
-
- private:
-  int32 N_;  //
-  int32 P_;
-  EventMap *to_pdf_;  // owned here.
-
-  KALDI_DISALLOW_COPY_AND_ASSIGN(ContextDependency);
-};
-
-/// GenRandContextDependency is mainly of use for debugging.  Phones must be sorted and uniq
-/// on input.
-/// @param phones [in] A vector of phone id's [must be sorted and uniq].
-/// @param ensure_all_covered [in] boolean argument; if true,  GenRandContextDependency
-///        generates a context-dependency object that "works" for all phones [no gaps].
-/// @param num_pdf_classes [out] outputs a vector indexed by phone, of the number
-///          of pdf classes (e.g. states) for that phone.
-/// @return Returns the a context dependency object.
-ContextDependency *GenRandContextDependency(const std::vector<int32> &phones,
-                                            bool ensure_all_covered,
-                                            std::vector<int32> *num_pdf_classes);
-
-/// GenRandContextDependencyLarge is like GenRandContextDependency but generates a larger tree
-/// with specified N and P for use in "one-time" larger-scale tests.
-ContextDependency *GenRandContextDependencyLarge(const std::vector<int32> &phones,
-                                                 int N, int P,
-                                                 bool ensure_all_covered,
-                                                 std::vector<int32> *num_pdf_classes);
-
-// MonophoneContextDependency() returns a new ContextDependency object that
-// corresponds to a monophone system.
-// The map phone2num_pdf_classes maps from the phone id to the number of
-// pdf-classes we have for that phone (e.g. 3, so the pdf-classes would be
-// 0, 1, 2).
-
-ContextDependency*
-MonophoneContextDependency(const std::vector<int32> phones,
-                           const std::vector<int32> phone2num_pdf_classes);
-
-// MonophoneContextDependencyShared is as MonophoneContextDependency but lets
-// you define classes of phones which share pdfs (e.g. different stress-markers of a single
-// phone.)  Each element of phone_classes is a set of phones that are in that class.
-ContextDependency*
-MonophoneContextDependencyShared(const std::vector<std::vector<int32> > phone_classes,
-                                 const std::vector<int32> phone2num_pdf_classes);
-
-
-// Important note:
-// Statistics for training decision trees will be of type:
-// std::vector<std::pair<EventType, Clusterable*> >
-// We don't make this a typedef as it doesn't add clarity.
-// they will be sorted and unique on the EventType member, which
-// itself is sorted and unique on the name (see event-map.h).
-
-// See build-tree.h for functions relating to actually building the decision trees.
-
-
-
-
-}  // namespace Kaldi
-
-
-#endif
diff --git a/kaldi_io/src/kaldi/tree/event-map.h b/kaldi_io/src/kaldi/tree/event-map.h
deleted file mode 100644
index 07fcc2b..0000000
--- a/kaldi_io/src/kaldi/tree/event-map.h
+++ /dev/null
@@ -1,365 +0,0 @@
-// tree/event-map.h
-
-// Copyright 2009-2011  Microsoft Corporation;  Haihua Xu
-
-// 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_TREE_EVENT_MAP_H_
-#define KALDI_TREE_EVENT_MAP_H_
-
-#include <vector>
-#include <map>
-#include <algorithm>
-#include "base/kaldi-common.h"
-#include "util/stl-utils.h"
-#include "util/const-integer-set.h"
-
-namespace kaldi {
-
-/// \defgroup event_map_group Event maps
-/// \ingroup tree_group
-/// See \ref tree_internals for overview, and specifically \ref treei_event_map.
-
-
-// Note RE negative values: some of this code will not work if things of type
-// EventValueType are negative.  In particular, TableEventMap can't be used if
-// things of EventValueType are negative, and additionally TableEventMap won't
-// be efficient if things of EventValueType take on extremely large values.  The
-// EventKeyType can be negative though.
-
-/// Things of type EventKeyType can take any value.  The code does not assume they are contiguous.
-/// So values like -1, 1000000 and the like are acceptable.
-typedef int32 EventKeyType;
-
-/// Given current code, things of type EventValueType should generally be nonnegative and in a
-/// reasonably small range (e.g. not one million), as we sometimes construct vectors of the size:
-/// [largest value we saw for this key].  This deficiency may be fixed in future [would require
-/// modifying TableEventMap]
-typedef int32 EventValueType;
-
-/// As far as the event-map code itself is concerned, things of type EventAnswerType may take
-/// any value except kNoAnswer (== -1).  However, some specific uses of EventMap (e.g. in
-/// build-tree-utils.h) assume these quantities are nonnegative.
-typedef int32 EventAnswerType;
-
-typedef std::vector<std::pair<EventKeyType, EventValueType> > EventType;
-// It is required to be sorted and have unique keys-- i.e. functions assume this when called
-// with this type.
-
-inline std::pair<EventKeyType, EventValueType> MakeEventPair (EventKeyType k, EventValueType v) {  
-  return std::pair<EventKeyType, EventValueType>(k, v);
-}
-
-void WriteEventType(std::ostream &os, bool binary, const EventType &vec);
-void ReadEventType(std::istream &is, bool binary, EventType *vec);
-
-std::string EventTypeToString(const EventType &evec);  // so we can print events out in error messages.
-
-struct EventMapVectorHash {  // Hashing object for EventMapVector.  Works for both pointers and references.
-  // Not used in event-map.{h, cc}
-  size_t operator () (const EventType &vec);
-  size_t operator () (const EventType *ptr) { return (*this)(*ptr); }
-};
-struct EventMapVectorEqual {  // Equality object for EventType pointers-- test equality of underlying vector.
-  // Not used in event-map.{h, cc}
-  size_t operator () (const EventType *p1, const EventType *p2) { return (*p1 == *p2); }
-};
-
-
-/// A class that is capable of representing a generic mapping from
-/// EventType (which is a vector of (key, value) pairs) to
-/// EventAnswerType which is just an integer.  See \ref tree_internals
-/// for overview.
-class EventMap {
- public:
-  static void Check(const EventType &event);  // will crash if not sorted and unique on key.
-  static bool Lookup(const EventType &event, EventKeyType key, EventValueType *ans);
-
-  // Maps events to the answer type. input must be sorted.
-  virtual bool Map(const EventType &event, EventAnswerType *ans) const = 0;
-
-  // MultiMap maps a partially specified set of events to the set of answers it might
-  // map to.  It appends these to "ans".  "ans" is
-  // **not guaranteed unique at output** if the
-  // tree contains duplicate answers at leaves -- you should sort & uniq afterwards.
-  // e.g.: SortAndUniq(ans).
-  virtual void MultiMap(const EventType &event, std::vector<EventAnswerType> *ans) const = 0;
-
-  // GetChildren() returns the EventMaps that are immediate children of this
-  // EventMap (if they exist), by putting them in *out.  Useful for
-  // determining the structure of the event map.
-  virtual void GetChildren(std::vector<EventMap*> *out) const = 0;
-
-  // This Copy() does a deep copy of the event map.
-  // If new_leaves is nonempty when it reaches a leaf with value l s.t. new_leaves[l] != NULL,
-  // it replaces it with a copy of that EventMap.  This makes it possible to extend and modify
-  // It's the way we do splits of trees, and clustering of trees.  Think about this carefully, because
-  // the EventMap structure does not support modification of an existing tree.  Do not be tempted
-  // to do this differently, because other kinds of mechanisms would get very messy and unextensible.
-  // Copy() is the only mechanism to modify a tree.  It's similar to a kind of function composition.
-  // Copy() does not take ownership of the pointers in new_leaves (it uses the Copy() function of those
-  // EventMaps).
-  virtual EventMap *Copy(const std::vector<EventMap*> &new_leaves) const = 0;
-  
-  EventMap *Copy() const { std::vector<EventMap*> new_leaves; return Copy(new_leaves); }
-
-  // The function MapValues() is intended to be used to map phone-sets between
-  // different integer representations.  For all the keys in the set
-  // "keys_to_map", it will map the corresponding values using the map
-  // "value_map".  Note: these values are the values in the key->value pairs of
-  // the EventMap, which really correspond to phones in the usual case; they are
-  // not the "answers" of the EventMap which correspond to clustered states.  In
-  // case multiple values are mapped to the same value, it will try to deal with
-  // it gracefully where it can, but will crash if, for example, this would
-  // cause problems with the TableEventMap.  It will also crash if any values
-  // used for keys in "keys_to_map" are not mapped by "value_map".  This
-  // function is not currently used.
-  virtual EventMap *MapValues(
-      const unordered_set<EventKeyType> &keys_to_map,
-      const unordered_map<EventValueType,EventValueType> &value_map) const = 0;
-
-  // The function Prune() is like Copy(), except it removes parts of the tree
-  // that return only -1 (it will return NULL if this EventMap returns only -1).
-  // This is a mechanism to remove parts of the tree-- you would first use the
-  // Copy() function with a vector of EventMap*, and for the parts you don't
-  // want, you'd put a ConstantEventMap with -1; you'd then call
-  // Prune() on the result.  This function is not currently used.
-  virtual EventMap *Prune() const = 0;
-  
-  virtual EventAnswerType MaxResult() const {  // child classes may override this for efficiency; here is basic version.
-    // returns -1 if nothing found.
-    std::vector<EventAnswerType> tmp; EventType empty_event;
-    MultiMap(empty_event, &tmp);
-    if (tmp.empty()) {
-      KALDI_WARN << "EventMap::MaxResult(), empty result";
-      return std::numeric_limits<EventAnswerType>::min();
-    }
-    else { return * std::max_element(tmp.begin(), tmp.end()); }
-  }
-
-  /// Write to stream.
-  virtual void Write(std::ostream &os, bool binary) = 0;
-
-  virtual ~EventMap() {}
-
-  /// a Write function that takes care of NULL pointers.
-  static void Write(std::ostream &os, bool binary, EventMap *emap);
-  /// a Read function that reads an arbitrary EventMap; also
-  /// works for NULL pointers.
-  static EventMap *Read(std::istream &is, bool binary);
-};
-
-
-class ConstantEventMap: public EventMap {
- public:
-  virtual bool Map(const EventType &event, EventAnswerType *ans) const {
-    *ans = answer_;
-    return true;
-  }
-
-  virtual void MultiMap(const EventType &,
-                        std::vector<EventAnswerType> *ans) const {
-     ans->push_back(answer_);
-  }
-
-  virtual void GetChildren(std::vector<EventMap*> *out) const { out->clear(); }
-
-  virtual EventMap *Copy(const std::vector<EventMap*> &new_leaves) const {
-    if (answer_ < 0 || answer_ >= (EventAnswerType)new_leaves.size() ||
-        new_leaves[answer_] == NULL)
-      return new ConstantEventMap(answer_);
-    else return new_leaves[answer_]->Copy();
-  }
-
-  virtual EventMap *MapValues(
-      const unordered_set<EventKeyType> &keys_to_map,
-      const unordered_map<EventValueType,EventValueType> &value_map) const {
-    return new ConstantEventMap(answer_);
-  }
-
-  virtual EventMap *Prune() const {
-    return (answer_ == -1 ? NULL : new ConstantEventMap(answer_));
-  }
-  
-  explicit ConstantEventMap(EventAnswerType answer): answer_(answer) { }
-  
-  virtual void Write(std::ostream &os, bool binary);
-  static ConstantEventMap *Read(std::istream &is, bool binary);
- private:
-  EventAnswerType answer_;
-  KALDI_DISALLOW_COPY_AND_ASSIGN(ConstantEventMap);
-};
-
-class TableEventMap: public EventMap {
- public:
-
-  virtual bool Map(const EventType &event, EventAnswerType *ans) const {
-    EventValueType tmp;   *ans = -1;  // means no answer
-    if (Lookup(event, key_, &tmp) && tmp >= 0
-       && tmp < (EventValueType)table_.size() && table_[tmp] != NULL) {
-      return table_[tmp]->Map(event, ans);
-    }
-    return false;
-  }
-
-  virtual void GetChildren(std::vector<EventMap*> *out) const {
-    out->clear();
-    for (size_t i = 0; i<table_.size(); i++)
-      if (table_[i] != NULL) out->push_back(table_[i]);
-  }
-
-  virtual void MultiMap(const EventType &event, std::vector<EventAnswerType> *ans) const {
-    EventValueType tmp;
-    if (Lookup(event, key_, &tmp)) {
-      if (tmp >= 0 && tmp < (EventValueType)table_.size() && table_[tmp] != NULL)
-        return table_[tmp]->MultiMap(event, ans);
-      // else no answers.
-    } else {  // all answers are possible if no such key.
-      for (size_t i = 0;i < table_.size();i++)
-        if (table_[i] != NULL) table_[i]->MultiMap(event, ans);  // append.
-    }
-  }
-
-  virtual EventMap *Prune() const;
-  
-  virtual EventMap *MapValues(
-      const unordered_set<EventKeyType> &keys_to_map,
-      const unordered_map<EventValueType,EventValueType> &value_map) const;
-  
-  /// Takes ownership of pointers.
-  explicit TableEventMap(EventKeyType key, const std::vector<EventMap*> &table): key_(key), table_(table) {}
-  /// Takes ownership of pointers.
-  explicit TableEventMap(EventKeyType key, const std::map<EventValueType, EventMap*> &map_in);
-  /// This initializer creates a ConstantEventMap for each value in the map.
-  explicit TableEventMap(EventKeyType key, const std::map<EventValueType, EventAnswerType> &map_in);
-
-  virtual void Write(std::ostream &os, bool binary);
-  static TableEventMap *Read(std::istream &is, bool binary);
-
-  virtual EventMap *Copy(const std::vector<EventMap*> &new_leaves) const {
-    std::vector<EventMap*> new_table_(table_.size(), NULL);
-    for (size_t i = 0;i<table_.size();i++) if (table_[i]) new_table_[i]=table_[i]->Copy(new_leaves);
-    return new TableEventMap(key_, new_table_);
-  }
-  virtual ~TableEventMap() {
-    DeletePointers(&table_);
-  }
- private:
-  EventKeyType key_;
-  std::vector<EventMap*> table_;
-  KALDI_DISALLOW_COPY_AND_ASSIGN(TableEventMap);
-};
-
-
-
-
-class SplitEventMap: public EventMap {  // A decision tree [non-leaf] node.
- public:
-
-  virtual bool Map(const EventType &event, EventAnswerType *ans) const {
-    EventValueType value;
-    if (Lookup(event, key_, &value)) {
-      // if (std::binary_search(yes_set_.begin(), yes_set_.end(), value)) {
-      if (yes_set_.count(value)) {
-        return yes_->Map(event, ans);
-      }
-      return no_->Map(event, ans);
-    }
-    return false;
-  }
-
-  virtual void MultiMap(const EventType &event, std::vector<EventAnswerType> *ans) const {
-    EventValueType tmp;
-    if (Lookup(event, key_, &tmp)) {
-      if (std::binary_search(yes_set_.begin(), yes_set_.end(), tmp))
-        yes_->MultiMap(event, ans);
-      else
-        no_->MultiMap(event, ans);
-    } else {  // both yes and no contribute.
-      yes_->MultiMap(event, ans);
-      no_->MultiMap(event, ans);
-    }
-  }
-
-  virtual void GetChildren(std::vector<EventMap*> *out) const {
-    out->clear();
-    out->push_back(yes_);
-    out->push_back(no_);
-  }
-
-  virtual EventMap *Copy(const std::vector<EventMap*> &new_leaves) const {
-    return new SplitEventMap(key_, yes_set_, yes_->Copy(new_leaves), no_->Copy(new_leaves));
-  }
-
-  virtual void Write(std::ostream &os, bool binary);
-  static SplitEventMap *Read(std::istream &is, bool binary);
-
-  virtual EventMap *Prune() const;
-  
-  virtual EventMap *MapValues(
-      const unordered_set<EventKeyType> &keys_to_map,
-      const unordered_map<EventValueType,EventValueType> &value_map) const;
-  
-  virtual ~SplitEventMap() { Destroy(); }
-
-  /// This constructor takes ownership of the "yes" and "no" arguments.
-  SplitEventMap(EventKeyType key, const std::vector<EventValueType> &yes_set,
-                EventMap *yes, EventMap *no): key_(key), yes_set_(yes_set), yes_(yes), no_(no) {
-    KALDI_PARANOID_ASSERT(IsSorted(yes_set));
-    KALDI_ASSERT(yes_ != NULL && no_ != NULL);
-  }
-
-
- private:
-  /// This constructor used in the Copy() function.
-  SplitEventMap(EventKeyType key, const ConstIntegerSet<EventValueType> &yes_set,
-                EventMap *yes, EventMap *no): key_(key), yes_set_(yes_set), yes_(yes), no_(no) {
-    KALDI_ASSERT(yes_ != NULL && no_ != NULL);
-  }
-  void Destroy() {
-    delete yes_; delete no_;
-  }
-  EventKeyType key_;
-  //  std::vector<EventValueType> yes_set_;
-  ConstIntegerSet<EventValueType> yes_set_;  // more efficient Map function.
-  EventMap *yes_;  // owned here.
-  EventMap *no_;  // owned here.
-  SplitEventMap &operator = (const SplitEventMap &other);  // Disallow.
-};
-
-/**
-   This function gets the tree structure of the EventMap "map" in a convenient form.
-   If "map" corresponds to a tree structure (not necessarily binary) with leaves
-   uniquely numbered from 0 to num_leaves-1, then the function will return true,
-   output "num_leaves", and set "parent" to a vector of size equal to the number of
-   nodes in the tree (nonleaf and leaf), where each index corresponds to a node
-   and the leaf indices correspond to the values returned by the EventMap from
-   that leaf; for an index i, parent[i] equals the parent of that node in the tree
-   structure, where parent[i] > i, except for the last (root) node where parent[i] == i.
-   If the EventMap does not have this structure (e.g. if multiple different leaf nodes share
-   the same number), then it will return false.
-*/
-
-bool GetTreeStructure(const EventMap &map,
-                      int32 *num_leaves,
-                      std::vector<int32> *parents);
-
-
-/// @} end "addtogroup event_map_group"
-
-}
-
-#endif
diff --git a/kaldi_io/src/kaldi/tree/tree-renderer.h b/kaldi_io/src/kaldi/tree/tree-renderer.h
deleted file mode 100644
index 5e0b0d8..0000000
--- a/kaldi_io/src/kaldi/tree/tree-renderer.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// tree/tree-renderer.h
-
-// Copyright 2012 Vassil Panayotov
-
-// 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_TREE_TREE_RENDERER_H_
-#define KALDI_TREE_TREE_RENDERER_H_
-
-#include "base/kaldi-common.h"
-#include "tree/event-map.h"
-#include "util/common-utils.h"
-#include "hmm/transition-model.h"
-#include "fst/fstlib.h"
-
-namespace kaldi {
-
-// Parses a decision tree file and outputs its description in GraphViz format
-class TreeRenderer {
- public:
-  const static int32 kEdgeWidth; // normal width of the edges and state contours
-  const static int32 kEdgeWidthQuery; // edge and state width when in query
-  const static std::string kEdgeColor; // normal color for states and edges
-  const static std::string kEdgeColorQuery; // edge and state color when in query
-
-  TreeRenderer(std::istream &is, bool binary, std::ostream &os,
-               fst::SymbolTable &phone_syms, bool use_tooltips)
-      : phone_syms_(phone_syms), is_(is), out_(os), binary_(binary),
-        N_(-1), use_tooltips_(use_tooltips), next_id_(0) {}
-
-  // Renders the tree and if the "query" parameter is not NULL
-  // a distinctly colored trace corresponding to the event.
-  void Render(const EventType *query);
-
- private:
-  // Looks-up the next token from the stream and invokes
-  // the appropriate render method to visualize it
-  void RenderSubTree(const EventType *query, int32 id);
-
-  // Renders a leaf node (constant event map)
-  void RenderConstant(const EventType *query, int32 id);
-
-  // Renders a split event map node and the edges to the nodes
-  // representing YES and NO sets
-  void RenderSplit(const EventType *query, int32 id);
-
-  // Renders a table event map node and the edges to its (non-null) children
-  void RenderTable(const EventType *query, int32 id);
-
-  // Makes a comma-separated string from the elements of a set of identifiers
-  // If the identifiers represent phones, their symbolic representations are used
-  std::string MakeEdgeLabel(const EventKeyType &key,
-                            const ConstIntegerSet<EventValueType> &intset);
-
-  // Writes the GraphViz representation of a non-leaf node to the out stream
-  // A question about a phone from the context window or about pdf-class
-  // is used as a label.
-  void RenderNonLeaf(int32 id, const EventKeyType &key, bool in_query);
-
-  fst::SymbolTable &phone_syms_; // phone symbols to be used as edge labels
-  std::istream &is_; // the stream from which the tree is read
-  std::ostream &out_; // the GraphViz representation is written to this stream
-  bool binary_; // is the input stream binary?
-  int32 N_, P_; // context-width and central position
-  bool use_tooltips_;  // use tooltips(useful in e.g. SVG) instead of labels
-  int32 next_id_; // the first unused GraphViz node ID
-};
-
-} // namespace kaldi
-
-#endif //  KALDI_TREE_TREE_RENDERER_H_