Collaboration diagram for API_LowLvl::lib::cwr::wlat:

Data Structures
struct	SprWlatO

struct	SprWlatC

struct	SprWlatA

struct	SprWlatR

struct	SprWlatS

struct	SprWlatEIDD

union	_Union1_WLAT_MASTER_

struct	SprWlatEI

union	_Union2_WLAT_MASTER_

struct	SprWlatEvent

struct	SprWlatList

struct	SprWlatModInf

struct	SprWlatModule

struct	SprWlatPipe

struct	SprWlatHTE

union	_Union6_WLAT_MASTER_

struct	SprWlatHTDB
	hash data block More...

struct	SprWlatHT1

struct	SprWlatHTH

struct	SprWlatHT2

Typedefs
typedef const SprWlatEvent (	_FuncPtr3_WLAT_MASTER_ )(unsigned int port, const SprWlatEvent event, const struct spr_t_wlat_module module)

typedef int(*	_FuncPtr4_WLAT_MASTER_ )(struct spr_t_wlat_module module, const char descript, const SprCmdDesc *help)

typedef const SprWlatEvent (	_FuncPtr5_WLAT_MASTER_ )(unsigned int port, const SprWlatEvent event, const struct spr_t_wlat_module module)

Enumerations
enum	{ SPR_WLAT_ARC_EPS }

enum	{ SPR_WLAT_ARC, SPR_WLAT_ONODE, SPR_WLAT_CNODE, SPR_WLAT_REMARK, SPR_WLAT_STOP, SPR_WLAT_START, SPR_WLAT_END, SPR_WLAT_INIT, SPR_WLAT_DARC, SPR_WLAT_RARC, SPR_WLAT_MODE_MSK, SPR_WLAT_HAS_OPT1, SPR_WLAT_HAS_OPT2, SPR_WLAT_HAS_OPT3, SPR_WLAT_RESERVED_MSK, SPR_WLAT_USR_FLAG1, SPR_WLAT_USR_FLAG2, SPR_WLAT_USR_FLAG3, SPR_WLAT_USR_FLAG4 }

Functions
int	spr_wlat_bsearch_wrd_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlbs_wrd_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlbs_flavor_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_pp_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

void	spr_wlat_ei_free_triv (SprWlatEI *ei)

SprWlatHT1 *	spr_wlat_hash1_free (SprWlatHT1 *ht)

void	spr_wlat_hash1_reset (SprWlatHT1 *ht)

SprWlatHT1 *	spr_wlat_hash1_init (SprWlatHT1 *htx, unsigned int initial_size, unsigned int el_data_sz)

SprWlatHTE *	spr_wlat_hash1_find_el (const SprWlatHT1 *ht, int node_ndx)

int	spr_wlat_hash1_find_ndx (const SprWlatHT1 *ht, int node_ndx)

int	spr_wlat_hash1_del_el (SprWlatHT1 *ht, int node_ndx)

int	spr_wlat_hash1_add_ndx (SprWlatHT1 ht, int node_ndx, const void data)

void *	spr_wlat_hash1_add_el (SprWlatHT1 *ht, int node_ndx)

SprWlatHTE *	spr_wlat_hash1_ndx2el (SprWlatHT1 *ht, unsigned int ndx)

int	spr_wlat_hash1_next (SprWlatHT1 *ht, unsigned int ndx)

SprWlatHT2 *	spr_wlat_hash2_free (SprWlatHT2 *ht)

SprWlatHTH *	spr_wlat_hash2_reset (SprWlatHT2 ht, SprWlatHTH cat_free_list)

SprWlatHT2 *	spr_wlat_hash2_init (SprWlatHT2 *htx, unsigned int initial_size)

SprWlatHTH *	spr_wlat_hash2_find_el (const SprWlatHT2 *ht, int node_ndx)

SprWlatHTH *	spr_wlat_hash2_del_el (SprWlatHT2 *ht, int node_ndx)

SprWlatHTH *	spr_wlat_hash2_add_el (SprWlatHT2 ht, SprWlatHTH el)

const char *	spr_wlat_next_line (const char ***line_array)

const SprWlatEvent *	spr_wlat_propagate_event (unsigned int output_port, const SprWlatEvent event, const SprWlatModule wlat_module)

int	spr_wlat_root_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_read_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_write_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_filter_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_check_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

SprWlatPipe *	spr_wlat_pipe_free (SprWlatPipe *wlat_pipe)

SprWlatPipe *	spr_wlat_pipe_setup (const char **line_array)

void	spr_wlat_pipe_dump (SprStream fd, const SprWlatPipe wlat_pipe)

void	spr_wlat_pipe_help (SprStream *fd)
	Print the syntax of all possible commands and modules. More...

int	spr_wlat_pipe_process (const SprWlatPipe *wlat_pipe)

int	spr_wlat_install_root_reader (SprWlatPipe wlat_pipe, const char fname)

int	spr_wlat_stats_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_min_open_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_renum_min_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_time_sync_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_cor2wlat_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

int	spr_wlat_align_setup (SprWlatModule module, const char descript, const SprCmdDesc *help)

Variables
const SprWlatEIDD	spr_wlat_ei_dd_null

SprWlatEI *const	spr_wlat_ei_null

const SprWlatEIDD	spr_wlat_ei_dd_string

const SprWlatModInf *const	spr_mod_info_array []

Detailed Description

Typedef Documentation

typedef const SprWlatEvent*(* _FuncPtr3_WLAT_MASTER_)(unsigned int port, const SprWlatEvent *event, const struct spr_t_wlat_module *module)

typedef int(* _FuncPtr4_WLAT_MASTER_)(struct spr_t_wlat_module *module, const char **descript, const SprCmdDesc **help)

typedef const SprWlatEvent*(* _FuncPtr5_WLAT_MASTER_)(unsigned int port, const SprWlatEvent *event, const struct spr_t_wlat_module *module)

Enumeration Type Documentation

anonymous enum

Enumerator
SPR_WLAT_ARC_EPS

anonymous enum

Enumerator
SPR_WLAT_ARC
SPR_WLAT_ONODE
SPR_WLAT_CNODE
SPR_WLAT_REMARK
SPR_WLAT_STOP
SPR_WLAT_START
SPR_WLAT_END
SPR_WLAT_INIT
SPR_WLAT_DARC
SPR_WLAT_RARC
SPR_WLAT_MODE_MSK
SPR_WLAT_HAS_OPT1
SPR_WLAT_HAS_OPT2
SPR_WLAT_HAS_OPT3
SPR_WLAT_RESERVED_MSK
SPR_WLAT_USR_FLAG1
SPR_WLAT_USR_FLAG2
SPR_WLAT_USR_FLAG3
SPR_WLAT_USR_FLAG4

Function Documentation

int spr_wlat_bsearch_wrd_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [bsearch_wrd] module rescores lattices with a different language model. The search is a quasi-time-synchronous beam-search. The beam-search algorithm allows for fine-tuning of the pruning (and thus processing time) and for low-lattency output. Beam-search is however not-suited for top-N output (in other word, top_N output is not possible with this module). The output of this module are the nodes and arcs that make up the best path found and a comment line providing the score and some search statistics.

[bsearch]
`load lm <fname> [options]()`
options (options are seperated by a ';' character):
`FWD<I32:val>(1)`
Method used to calculate the forwarded probabilities: (0) no prob. forwarding, (1) the unigram probabilities, (2) a weighted sum of the N-gram probabilities over all seen events, (3) sqrt(fwd_1*fwd_2), (4) (fwd_1+fwd)/2.
`check_lvl=<I8:val>(0)`
Do some checking to see if there are errors in the LM, the level controls the output: (0) no checking, (1) give error count, (2) give detailed error info, (3) do not allow non zero back-off costs on empty LM-contexts, (4) report the first empty LM-context with a non zero back-off cost, (5) do not allow non-zero LM-contexts, (6) report the first non-zero LM-context.
`CLOSED(NULL)`
Do not allow a closed vocabulary LM to be used in an open vocabulary setup.
`CSR(NULL)`
Do not treat </s> as a blocking end-of-sentence symbol.
`ELMC0(NULL)`
Force the back-off cost of empty LM-contexts to zero.
`ext=<String:val>(NULL)`
A file containing word extension on the base lexicon.
`wdsf=<String:val>(NULL)`
A file containing word dependent LM scale factors.
Load + install an N-gram language model.
`load lm=<N-gram/FSG/comb/dump/XXX> <fname> [options]`
Load + install a language model of a certain type.
`load lexicon <ascii_lex>`
Load a lexicon, only the orthography is needed.
`scale [lmA](1.0) [lmC](0.0) [acmod](1.0)`
Specify a scale factor (lmA) and offset (lmC) on the LM and a scale factor acoustic scores (acmod).
`prune <threshold>(1024.0) [max_hyps](-1)`
Prune the search space with a threshold on the scores and a maximum numer of hypothesis.
`cache <lm_cache>(-1) [lmc_hash](-1)`
Sizes of the internal cache & hash tables.
`set <reset_sent_begin/check_sent_end/detail_lm> <on/off>(off)`
Configure some options.

int spr_wlbs_wrd_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [bsearch_wrd] module rescores lattices with a different language model. The search is a quasi-time-synchronous beam-search. The beam-search algorithm allows for fine-tuning of the pruning (and thus processing time) and for low-lattency output. Beam-search is however not-suited for top-N output (in other word, top_N output is not possible with this module). The output of this module are the nodes and arcs that make up the best path found and a comment line providing the score and some search statistics.

int spr_wlbs_flavor_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [bsearch_flavor] module finds the best path through a phone lattices given a lexicon and a language model. The search is a quasi-time-synchronous beam-search. The beam-search algorithm allows for fine-tuning of the pruning (and thus processing time) and for low-lattency output. Beam-search is however not-suited for top-N output (in other word, top_N output is not possible with this module). The output of this module is a word lattice (currently only the best sentence is output).

int spr_wlat_pp_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [confidence] module computes confidence indicators, and optionally combines these indicator score into a single confidence level.

[confidence]
`% Compute confidence indicators, and optionally, combine them into a single confidence measure.`

`load phone_set <ci_fname> <cd_fname>`	`[requires c-strings]`
Load the phone definition of the acoustic model used to create the lattices, more specifically, the state alignments in the lattice.
`load ssp_script <ssp_script> ...`	`[requires c-strings]`
Load the signal processing script. The signal processing can either concatenate the features for the different acoustic models or can use named buffers.
`ssp obsdir=<obsdir> suffix=<suffix>`	`[requires c-strings]`
Set the directory name to add in front of all data file names and the file suffix to append to all data file names.
`load hmm <hmm> [mvg] [sel] [opt]`	`[requires c-strings]`
Load an HMM+GMM based acoustic model. For both the mvg and select file name a '' may be specified to indicate that the default file name should be used.*
`load hmm=<std/mdt/dft> <hmm> [mvg] [sel] [opt]`	`[requires c-strings]`
Load a acoustic model of a certain type.
`hmm input from <named_buffer>`	`[requires c-strings]`
Read the input for evaluating the previously loaded acoustic model from the given named buffer instead of from the main output stream of the preprocessing.
`hmm input norm=F<yes/1/no/0>log=F<yes/1/no/0>[base]`	`[requires c-strings]`
Only needed for acoustic models like the DFT where the type (linear or log_<base>) and/or the likelihoods normalization (yes or no) is not know (depends on the input features).
`load lexicon <ascii_lex>`	`[requires c-strings]`
Load the lexicon used to create the lattice (only the orthography is needed). Needed to compute LM-related scores.
`eos <word1> ...`	`[requires c-strings]`
Inform the LM computations that <word1> ... is/are end-of-sentence symbols – these need to be handled differently when evaluating the LM backwards.
`load lm <fname> [options]()`	`[requires c-strings]`
options (options are seperated by a ';' character):
`FWD<I32:val>(1)`
Method used to calculate the forwarded probabilities: (0) no prob. forwarding, (1) the unigram probabilities, (2) a weighted sum of the N-gram probabilities over all seen events, (3) sqrt(fwd_1*fwd_2), (4) (fwd_1+fwd)/2.
`check_lvl=<I8:val>(0)`
Do some checking to see if there are errors in the LM, the level controls the output: (0) no checking, (1) give error count, (2) give detailed error info, (3) do not allow non zero back-off costs on empty LM-contexts, (4) report the first empty LM-context with a non zero back-off cost, (5) do not allow non-zero LM-contexts, (6) report the first non-zero LM-context.
`CLOSED(NULL)`
Do not allow a closed vocabulary LM to be used in an open vocabulary setup.
`CSR(NULL)`
Do not treat </s> as a blocking end-of-sentence symbol.
`ELMC0(NULL)`
Force the back-off cost of empty LM-contexts to zero.
`ext=<String:val>(NULL)`
A file containing word extension on the base lexicon.
`wdsf=<String:val>(NULL)`
A file containing word dependent LM scale factors.
Load + install an N-gram language model.
`load lm=<N-gram/FSG/comb/dump/XXX> <fname> [options]`	`[requires c-strings]`
Load + install a language model of a certain type.
`define <LINEAR>`
Define that some condition is true.
`var <name> ...`
Define one or more auxilliary variables to use in the expressions below.
`const <var=expr> ...`
Set some auxilliary variable to some value.
`v res[<ndx> ]=<nfr/ascore/ascore_rp/postprob/support/duration/lm_fwd1/lm_fwd2/lm_fwd3/lm_bwd1/lm_bwd2/lm_bwd3> [(a=val,b=...)] ...`
Compute some feature <f> using the last load AM/LM; if needed for the feature <f>, extra named parameters <a>, <b>, ... can be specified as if <f>(<a>=val,<b>=...) were a function call.
`v score=<expr> ...`
Optionally, one can use the computed features to compute a final confidence score.

void spr_wlat_ei_free_triv ( SprWlatEI * ei )

Free function objects that are completely embedded, i.e. that have no extra memory allocated outside the main 'WlatEI' structure.

SprWlatHT1* spr_wlat_hash1_free ( SprWlatHT1 * ht )

void spr_wlat_hash1_reset ( SprWlatHT1 * ht )

SprWlatHT1* spr_wlat_hash1_init	(	SprWlatHT1 *	htx,
		unsigned int	initial_size,
		unsigned int	el_data_sz
	)

SprWlatHTE* spr_wlat_hash1_find_el	(	const SprWlatHT1 *	ht,
		int	node_ndx
	)

int spr_wlat_hash1_find_ndx	(	const SprWlatHT1 *	ht,
		int	node_ndx
	)

int spr_wlat_hash1_del_el	(	SprWlatHT1 *	ht,
		int	node_ndx
	)

int spr_wlat_hash1_add_ndx	(	SprWlatHT1 *	ht,
		int	node_ndx,
		const void *	data
	)

void* spr_wlat_hash1_add_el	(	SprWlatHT1 *	ht,
		int	node_ndx
	)

SprWlatHTE* spr_wlat_hash1_ndx2el	(	SprWlatHT1 *	ht,
		unsigned int	ndx
	)

int spr_wlat_hash1_next	(	SprWlatHT1 *	ht,
		unsigned int	ndx
	)

Scan all elements in the hash table.
Example:

unsigned int ndx;
for(ndx=~0u;(ndx=spr_wlat_hash1_next(ht,ndx))!=~0u; )
 {WlatHTE *he = spr_wlat_hash1_ndx2el(ht,ndx);
  // do the actual work
 }

SprWlatHT2* spr_wlat_hash2_free ( SprWlatHT2 * ht )

SprWlatHTH* spr_wlat_hash2_reset	(	SprWlatHT2 *	ht,
		SprWlatHTH *	cat_free_list
	)

SprWlatHT2* spr_wlat_hash2_init	(	SprWlatHT2 *	htx,
		unsigned int	initial_size
	)

SprWlatHTH* spr_wlat_hash2_find_el	(	const SprWlatHT2 *	ht,
		int	node_ndx
	)

SprWlatHTH* spr_wlat_hash2_del_el	(	SprWlatHT2 *	ht,
		int	node_ndx
	)

SprWlatHTH* spr_wlat_hash2_add_el	(	SprWlatHT2 *	ht,
		SprWlatHTH *	el
	)

const char* spr_wlat_next_line ( const char *** line_array )

const SprWlatEvent* spr_wlat_propagate_event	(	unsigned int	output_port,
		const SprWlatEvent *	event,
		const SprWlatModule *	wlat_module
	)

Broadcast event event to all modules atached to output port number output_port of module wlat_module.

Returns: event on success and NULL on error.

int spr_wlat_root_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [ROOT] module is just a place holder for the real input method, e.g. a [read] module or some program that generates word lattice events.

[root]
`nr_outputs <nr_outputs>(1)`
Number of output ports the root process is expected to have.

int spr_wlat_read_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [read] module read a word lattice in binary or ascii format and converts it to events which are sent into the processing pipe.

[read]
`fname <fname> ...`
Read the word lattices from the given file.
`sync <START/STOP>(START)`
Synchronize the reading process with the START/STOP markers in the input stream.
`match <EXACT/NONE>(NONE)`
Do an exact or no match between the file names specified in the input lattice and the file names specified in the read file.

int spr_wlat_write_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [write] module saves word lattices in binary or ascii format to a file.

[write]
`fname <fname>`
Write the word lattices to the given file.
`format <BIN/ASCII>(ASCII)`
Write the word lattices in binary or ascii format.
`pass_through`
Defines the write module to be a tee module instead of a sink module, i.e. the module now also passes the word lattice events to the next module.

int spr_wlat_filter_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [filter] module removes components from the lattice.

[filter]
`remove remarks`
Remove all comments from the lattice structure.
`remove lattice`
Remove the complete lattice structure, retaining only the comments and the file markers.
`remove extra info`
Clear the extra information fields.

int spr_wlat_check_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [check] module removes components from the lattice.

[check]
`check <ARC_IO_ORDER/DIRECTED_ARCS/SINK_MARKED/SINK_TIME/ROOT_FIRST/DEAD_END/SPONT_START> ...`
Check if the lattice adheres to certain rules: ARC_IO_ORDER first arcs in, then arcs out DIRECTED_ARCS arcs point forward in time SINK_MARKED nodes with a negative number are sink nodes SINK_TIME all sink nodes are at the same frame ROOT_FIRST the very first node is the root node DEAD_END paths only end in sink nodes SPONT_START paths only start in the root node
`has<NORMAL_NODES/SINK_NODES/NORMAL_ARCS/DUMMY_ARCS/COMMENTS/EXTRA_INFO> ...`
Check if the lattice contains certain items.
`hasn't<NORMAL_NODES/SINK_NODES/NORMAL_ARCS/DUMMY_ARCS/COMMENTS/EXTRA_INFO> ...`
Check if the lattice is missing certain items (NORMAL_NODES, SINK_NODES, NORMAL_ARCS, DUMMY_ARCS, COMMENTS, EXTRA_INFO).

SprWlatPipe* spr_wlat_pipe_free ( SprWlatPipe * wlat_pipe )

Free all data allocated for the word lattice processing pipe line.

SprWlatPipe* spr_wlat_pipe_setup ( const char ** line_array )

Setup a word lattice processing pipe line. The line array line_array must contain the complete description of the pipe line, the script name (stored internally in line_array) is only used when printing messages. From this call on, the line array is owned by the word lattice processing system, and will be released automatically at the end.

void spr_wlat_pipe_dump	(	SprStream *	fd,
		const SprWlatPipe *	wlat_pipe
	)

Print info concerning the input and output of each module in the word lattice processing pipe line (for debugging puposes only).

void spr_wlat_pipe_help ( SprStream * fd )

Print the syntax of all possible commands and modules.

int spr_wlat_pipe_process ( const SprWlatPipe * wlat_pipe )

Read from the ROOT module until EOF and propagate to all attached modules.

int spr_wlat_install_root_reader	(	SprWlatPipe *	wlat_pipe,
		const char *	fname
	)

Attach a simple reader as root (input) module to the word lattice processing pipe.

int spr_wlat_stats_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [renum_min] module renumber the nodes to minimal numbers

[renum_min]
`% This module does not take options`

int spr_wlat_min_open_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [min_open] module minimizes the window during which nodes are open, i.e. it moves the open node operation right before the first arc going to the node, and moves the close node operation right after the last arc leaving that node.

[min_open]
`msg_lvl <lvl>(0)`
Report spontaneous starts and broken off paths at the given msg level.
`imperfect`
Do not optimize the end nodes in the lattice. This results in a somewhat lower latency.

int spr_wlat_renum_min_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [renum_min] module renumber the nodes to minimal numbers

[renum_min]
`% This module does not take options`

int spr_wlat_time_sync_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [time_sync] module minimizes the window during which nodes are open, i.e. it moves the open node operation right before the first arc going to the node, and moves the close node operation right after the last arc leaving that node.

[time_sync]
`msg_lvl <lvl>(0)`
Report orphaned nodes at the given msg level.
`frame_hash_sz <log2_N>(9)`
Make the frame hash table of a certain size (should equals to a few seconds of speech, avoiding long arcs with double mappings as much as possible).

int spr_wlat_cor2wlat_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [cor2wlat] module converts the orthographic transcriptions given in a corpus file to a (trival linear) word lattice or to a phoneme lattice. Conversion to a phoneme lattice is done when the 'phones' option is specified.

[cor2wlat]
`corpus <corpus_file>`
The corpus file to read from.
`phones <ci-phones> <cd-phones>`
Specify the phones to use when converting the word sequence to a phoneme network (if this option is not specified, a word lattice is created instead of a phone lattice).
`lexicon <dictionary> [unwind]`
The dictionary specifying the known word entries. When make phone networks, some 'unwind' options can be specified as well. See read_lex_desc() for more info on the unwind options.
`msg <lvl>(0)`
Report unknowns at the given message level. A level of (-1) will abort when unknowns are encountered.
`sync <START/END/ROOT>(START)`
In sync START/END mode, the input stream triggers the output of the generated word lattices: the lattice is output either at the start or at the end of the corresponding input lattice. In ROOT mode, no input lattices is allowed and all corpus entries are outputed immediatly.
`match <SLOPPY/EXACT/NONE>(SLOPPY)`
Do a sloppy (substring) or exact or no match between the file names specified in the input lattice and the file names specified in the corpus file.

int spr_wlat_align_setup	(	SprWlatModule *	module,
		const char **	descript,
		const SprCmdDesc **	help
	)

The [align] module aligns a word lattice with a reference lattice. The reference is for example the lexicon network produced given the othographic transcription, a lexicon and assimilation rules. The alignment which produces the lowest cost is searched for. The default options configure the cost to be equal to then Word Error Rate (Ins+Sub+del). In case two options end up with the same cost, the one with the lowest sub-cost is preferred. With the default values for the costs and sub-costs (WER), this means that if some substitutions can be swapped for a combination of insertions and deletions while still giving the same WER, the solution with the lowest number of substitutions is preferred.

The reference should be input at port 1, the lattice to align at port 0.

[align]
`ins cost <cost>(1) [sub-cost](1)`
Specify the cost and sub-cost for an insertion.
`del cost <cost>(1) [sub-cost](0)`
Specify the cost and sub-cost for a deletion.
`sub cost <cost>(1) [sub-cost](10000)`
Specify the cost and sub-cost for a substitution.
`cost matrix <lexicon> <matrix>`
Specify a cost matrix (and the lexicon), i.e. word/phoneme dependent sub, ins & del costs. Note: the sub-costs cannot be made word/phoneme dependent.
`acmod factor <factor>(-0.0)`
Take into account the acoustic scores after multiplying with the given scale factor. Note: most recognition algorithms maximize a log(likelihood), this algorithm minimizes a cost, hence the negative scaling factor.
`ref factor <factor>(-1.0)`
Use the costs (log(probs)) in the reference network as costs after multiplying with the given scale factor. Note: most recognition algorithms maximize a log(likelihood), this algorithm minimizes a cost, hence the negative scaling factor.
`% Note: The cost (matrix) are floating point values, the sub-costs are integers.`
UL

Variable Documentation

const SprWlatEIDD spr_wlat_ei_dd_null

SprWlatEI* const spr_wlat_ei_null

const SprWlatEIDD spr_wlat_ei_dd_string

const SprWlatModInf* const spr_mod_info_array[]

Typedefs
typedef const SprWlatEvent (	_FuncPtr3_WLAT_MASTER_ )(unsigned int port, const SprWlatEvent event, const struct spr_t_wlat_module module)

typedef int(*	_FuncPtr4_WLAT_MASTER_ )(struct spr_t_wlat_module module, const char descript, const SprCmdDesc *help)

typedef const SprWlatEvent (	_FuncPtr5_WLAT_MASTER_ )(unsigned int port, const SprWlatEvent event, const struct spr_t_wlat_module module)

Data Structures

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation