name: StatisticalModelAdaptation

synopsis:

g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_pr.a

#include <StatisticalModelAdaptation.h>

StatisticalModelAdaptation(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION, float split_threshold, float merge_threshold, float num_occ_threshold);
boolean eq(const StatisticalModelAdaptation& arg);
boolean setAlgorithm(ALGORITHM algorithm);

quick start:

StatisticalModelAdaptation smadp;
smadp.setAlgorithm(MLLR);
smadp.setImplementation(MEAN);
      
smadp.adapt(RegressionDecisionTree& rdt_a, Vector& stat_models_a);

description:

The StatisticalModelAdaptation class is used to solve the problem of sparse data by tying Statistical Models using the training data (Symbol Occupancies) and the Regression questions (expert knowledge). A good reference of the algorithm is:

J. Zhao, et al,,

"Tutorial for Decision Tree-Based State-Tying For Acoustic Modeling"

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"StatisticalModelAdaptation";

define the algorithm choices:

enum ALGORITHM { MLLR = 0, MAP, DEF_ALGORITHM = MLLR };

define the implementation choices:

enum IMPLEMENTATION { MEAN = 0, VARIANCE, DEF_IMPLEMENTATION = MEAN };

define the static NameMap objects:

static const NameMap ALGO_MAP(L"MLLR MAP");

static const NameMap IMPL_MAP(L"MEAN VARIANCE");

define i/o related constants:

static const String DEF_PARAM = L"";

static const String PARAM_ALGORITHM = L"algorithm";

static const String PARAM_IMPLEMENTATION = L"implementation";

static const String PARAM_IMPLEMENTATION = L"debug_level";

error codes:

error code indicating StatisticalModelAdaptation class general error:
```
static const long ERR = 00100750;
```
```
static const long ERR = 00100751;
```

protected data:

define the structures:

typedef BiGraphVertex<RegressionDecisionTreeNode> TreeNode;

algorithm name:

ALGORITHM algorithm_d;

implmentation name:

IMPLEMENTATION implementation_d;

define transformation matrix W (one row for each Gaussian dimension)

Vector w_transform_d;

debugging level

debug_level_d;

static memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean debug(const unichar* message) const;

boolean setDebug(Integral::DEBUG level);

destructor/constructor(s):

~StatisticalModelAdaptation();

StatisticalModelAdaptation(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION);

StatisticalModelAdaptation(const StatisticalModelAdaptation& arg);

assign methods:

boolean assign(const StatisticalModelAdaptation& arg);

operator= methods:

StatisticalModelAdaptation& operator= (const StatisticalModelAdaptation& arg);

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);

boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;

boolean readData(Sof& sof, const String& pname = DEF_PARAM, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

equality methods:

boolean eq(const StatisticalModelAdaptation& arg) const;

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);

class-specific public methods:

set methods:

boolean setAlgorithm(ALGORITHM algorithm);

boolean setImplementation(IMPLEMENTATION implementation);

boolean set(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION);

get methods:

ALGORITHM getAlgorithm() const;

IMPLEMENTATION getImplementation() const;

boolean get(ALGORITHM& algorithm, IMPLEMENTATION& implementation);

method to adapt the model:

boolean adapt(RegressionDecisionTree& rdt_a, Vector& stat_models_a);

other methods:
```
boolean setParser(SofParser* parser);
```

private methods:

find a terminal by given a regression decision tree and node index

BiGraphVertex* findTerminal(RTreeNode*& root_node_a, long index_a);

examples:

none

notes:

none