ISIP Homepage

name: TrainNode : public String

synopsis:

gcc [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_search.a

#include <TrainNode.h>

~TrainNode();
TrainNode();
TrainNode(const TrainNode& copy_sym);

quick start:

#include <TrainNode.h>

TrainNode train_node;

float alpha = -0.3657;
float beta = -0.7865;

Trace new_trace;
train_node.setAlpha(alpha);
train_node.setBeta(beta);
train_node.setTrace(&new_trace);

description:

The TrainNode class specifies a location in a search space.

dependencies:

public constants:

define the class name:
```
static const String CLASS_NAME;
```
define i/o related constants:
```
static const String DEF_PARAM;
```
define default values and arguments:
```
static const long DEF_TIMESTAMP = -1;
```

protected data:

define the time instance (t)

long frame_d;

define the backward probability for the state at time (t)

double beta_d;

define the forward probability for the state at time (t)

double alpha_d;

define the score associated with the state at time (t)

double score_d;

define a flag that tells us if the train node is reachable

boolean is_valid_d;

boolean is_alpha_valid_d;

boolean is_beta_valid_d;

boolean is_accum_valid_d;

define the trace/instance reference pointer

void* reference_d;

define the statistical model pointer

StatisticalModel* stat_model_d;

define the memory manager:
```
static MemoryManager mgr_d;
```
define the debug level:
```
static Integral::DEBUG debug_level_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;

static boolean setDebug(Integral::DEBUG debug_level);

destructor/constructor(s):

~TrainNode();

TrainNode();

TrainNode(const TrainNode& arg);

assign methods:

boolean assign(const TrainNode& copy_node);

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

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

equality methods:

boolean eq(const TrainNode& compare_node) 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:

methods to get/set alpha

boolean setAlpha(float arg);

double getAlpha();

methods to get/set beta

boolean setBeta(float arg);

double getBeta();

methods to get/set frame

boolean setFrame(long arg);

long getFrame();

methods to get/set score

boolean setScore(double arg);

double getScore();

methods to get/set reference

boolean setReference(void* arg);

void* getReference();

methods to get/set statistical model

boolean setStatisticalModel(StatisticalModel* arg);

StatisticalModel* getStatisticalModel();

methods to get valid model
```
boolean getValidModel();
```

methods to get/set valid node

boolean setValidNode(boolean arg);

boolean getValidNode();

methods to accumulate/update statistics

boolean update(VectorFloat& param);

boolean accumulate(float utter_prob, Vector& data, float min_mpd, float min_occupancy);

methods to check if forward probability is valid

boolean setAlphaValid(boolean arg = true);

boolean isAlphaValid();

methods to check if backward probability is valid

boolean setBetaValid(boolean arg = true);

boolean isBetaValid();

methods to check if accumulator is valid

boolean setAccumulatorValid(boolean arg = true);

boolean isAccumulatorValid();

private methods:

none

notes:

The TrainNode class is primarily used during training, i.e., it is used to generate the trellis. The trellis is in turn used to compute the state occupancy probability of the states and reestimate the parameters of the model.