fst Namespace Reference

For an extended explanation of the framework of which grammar-fsts are a part, please see Support for grammars and graphs with on-the-fly parts. (i.e. More...

Namespaces
	internal
	pre_determinize_helpers

Classes
class	ArcIterator< GrammarFst >
	This is the overridden template for class ArcIterator for GrammarFst. More...
class	ArcIterator< TrivialFactorWeightFst< A, F > >
class	ArcticWeightTpl
class	BackoffDeterministicOnDemandFst
	This class wraps an Fst, representing a language model, using the interface for "BackoffDeterministicOnDemandFst". More...
class	CacheDeterministicOnDemandFst
class	CompactLatticeMinimizer
class	CompactLatticePusher
class	CompactLatticeWeightCommonDivisorTpl
class	CompactLatticeWeightTpl
class	ComposeDeterministicOnDemandFst
class	DeterministicOnDemandFst
	class DeterministicOnDemandFst is an "FST-like" base-class. More...
struct	DeterminizeLatticeOptions
struct	DeterminizeLatticePhonePrunedOptions
struct	DeterminizeLatticePrunedOptions
class	DeterminizerStar
class	DfsOrderVisitor
class	GrammarFst
	GrammarFst is an FST that is 'stitched together' from multiple FSTs, that can recursively incorporate each other. More...
struct	GrammarFstArc
class	GrammarFstPreparer
struct	IdentityFunction
class	InverseContextFst
class	InverseLeftBiphoneContextFst
class	LatticeDeterminizer
class	LatticeDeterminizerPruned
class	LatticeStringRepository
class	LatticeToStdMapper
	Class LatticeToStdMapper maps a LatticeArc to a normal arc (StdArc) by adding the elements of the LatticeArc weight. More...
class	LatticeWeightTpl
class	LmExampleDeterministicOnDemandFst
	This class is for didactic purposes, it does not really do anything. More...
class	MapInputSymbolsMapper
class	NaturalLess< CompactLatticeWeightTpl< LatticeWeightTpl< double >, int32 > >
class	NaturalLess< CompactLatticeWeightTpl< LatticeWeightTpl< float >, int32 > >
class	NaturalLess< CompactLatticeWeightTpl< LatticeWeightTpl< FloatType >, IntType > >
class	NaturalLess< LatticeWeightTpl< double > >
class	NaturalLess< LatticeWeightTpl< float > >
class	NaturalLess< LatticeWeightTpl< FloatType > >
class	PruneSpecialClass
	This class is used to implement the function PruneSpecial. More...
class	PushSpecialClass
struct	RandFstOptions
class	RemoveEpsLocalClass
class	RemoveSomeInputSymbolsMapper
struct	ReweightPlusDefault
struct	ReweightPlusLogArc
class	ScaleDeterministicOnDemandFst
	Class ScaleDeterministicOnDemandFst takes another DeterministicOnDemandFst and scales the weights (like applying a language-model scale). More...
class	StateIterator< TrivialFactorWeightFst< A, F > >
class	StdToLatticeMapper
	Class StdToLatticeMapper maps a normal arc (StdArc) to a LatticeArc by putting the StdArc weight as the first element of the LatticeWeight. More...
class	StringRepository
struct	TableComposeCache
	TableComposeCache lets us do multiple compositions while caching the same matcher. More...
struct	TableComposeOptions
class	TableMatcher
class	TableMatcherImpl
struct	TableMatcherOptions
	TableMatcher is a matcher specialized for the case where the output side of the left FST always has either all-epsilons coming out of a state, or a majority of the symbol table. More...
struct	TestFunctor
class	TrivialFactorWeightFst
	TrivialFactorWeightFst takes as template parameter a FactorIterator as defined above. More...
struct	TrivialFactorWeightOptions
class	UnweightedNgramFst
	The class UnweightedNgramFst is a DeterministicOnDemandFst whose states encode an n-gram history. More...
class	VectorFstTplHolder

Typedefs
typedef fst::StdArc	StdArc
typedef fst::StdArc::Label	Label
typedef fst::StdArc::StateId	StateId
typedef fst::StdVectorFst	StdVectorFst
typedef fst::StdArc::Weight	Weight
typedef unsigned char	StatePropertiesType
typedef VectorFstTplHolder< StdArc >	VectorFstHolder
typedef float	BaseFloat
typedef LatticeWeightTpl< BaseFloat >	LatticeWeight
typedef CompactLatticeWeightTpl< LatticeWeight, int32 >	CompactLatticeWeight
typedef CompactLatticeWeightCommonDivisorTpl< LatticeWeight, int32 >	CompactLatticeWeightCommonDivisor
typedef ArcticWeightTpl< float >	ArcticWeight

Enumerations
enum	{ kStateHasEpsilonArcsEntering = 0x1, kStateHasNonEpsilonArcsEntering = 0x2, kStateHasEpsilonArcsLeaving = 0x4, kStateHasNonEpsilonArcsLeaving = 0x8 }
enum	StatePropertiesEnum {   kStateFinal = 0x1, kStateInitial = 0x2, kStateArcsIn = 0x4, kStateMultipleArcsIn = 0x8,   kStateArcsOut = 0x10, kStateMultipleArcsOut = 0x20, kStateOlabelsOut = 0x40, kStateIlabelsOut = 0x80 }
enum	NonterminalValues {   kNontermBos = 0, kNontermBegin = 1, kNontermEnd = 2, kNontermReenter = 3,   kNontermUserDefined = 4, kNontermMediumNumber = 1000, kNontermBigNumber = 10000000 }
	An anonymous enum to define some values for symbols used in our grammar-fst framework. More...

Functions
template<class Arc >
static VectorFst< Arc > *	GenAcceptorFromSequence (const vector< typename Arc::Label > &symbols, float cost)
template<class Arc >
static float	CheckPhones (const VectorFst< Arc > &linear_fst, const vector< typename Arc::Label > &phone_ids, const vector< typename Arc::Label > &disambig_ids, const vector< typename Arc::Label > &phone_seq, const vector< vector< typename Arc::Label > > &ilabel_info, int N, int P)
template<class Arc >
static VectorFst< Arc > *	GenRandPhoneSeq (vector< typename Arc::Label > &phone_syms, vector< typename Arc::Label > &disambig_syms, typename Arc::Label subsequential_symbol, int num_subseq_syms, float seq_prob, vector< typename Arc::Label > *phoneseq_out)
static void	TestContextFst (bool verbose, bool use_matcher)
void	ComposeContext (const vector< int32 > &disambig_syms_in, int32 context_width, int32 central_position, VectorFst< StdArc > *ifst, VectorFst< StdArc > *ofst, vector< vector< int32 > > *ilabels_out, bool project_ifst)
	Used in the command-line tool fstcomposecontext. More...
void	AddSubsequentialLoop (StdArc::Label subseq_symbol, MutableFst< StdArc > *fst)
	Modifies an FST so that it transuces the same paths, but the input side of the paths can all have the subsequential symbol '$' appended to them any number of times (we could easily specify the number of times, but accepting any number of repetitions is just more convenient). More...
void	WriteILabelInfo (std::ostream &os, bool binary, const vector< vector< int32 > > &info)
	Utility function for writing ilabel-info vectors to disk. More...
void	ReadILabelInfo (std::istream &is, bool binary, vector< vector< int32 > > *info)
	Utility function for reading ilabel-info vectors from disk. More...
SymbolTable *	CreateILabelInfoSymbolTable (const vector< vector< int32 > > &info, const SymbolTable &phones_symtab, std::string separator, std::string initial_disambig)
	The following function is mainly of use for printing and debugging. More...
void	WriteILabelInfo (std::ostream &os, bool binary, const std::vector< std::vector< int32 > > &ilabel_info)
	Utility function for writing ilabel-info vectors to disk. More...
void	ReadILabelInfo (std::istream &is, bool binary, std::vector< std::vector< int32 > > *ilabel_info)
	Utility function for reading ilabel-info vectors from disk. More...
SymbolTable *	CreateILabelInfoSymbolTable (const std::vector< std::vector< int32 > > &ilabel_info, const SymbolTable &phones_symtab, std::string separator, std::string disambig_prefix)
	The following function is mainly of use for printing and debugging. More...
void	ComposeContext (const std::vector< int32 > &disambig_syms, int32 context_width, int32 central_position, VectorFst< StdArc > *ifst, VectorFst< StdArc > *ofst, std::vector< std::vector< int32 > > *ilabels_out, bool project_ifst=false)
	Used in the command-line tool fstcomposecontext. More...
template<class Arc >
void	ComposeDeterministicOnDemand (const Fst< Arc > &fst1, DeterministicOnDemandFst< Arc > *fst2, MutableFst< Arc > *fst_composed)
template<class Arc >
void	ComposeDeterministicOnDemandInverse (const Fst< Arc > &fst1, DeterministicOnDemandFst< Arc > *fst2, MutableFst< Arc > *fst_composed)
	This function does '*fst_composed = Compose(Inverse(*fst2), fst1)' Note that the arguments are reversed; this is unfortunate but it's because the fst2 argument needs to be non-const and non-const arguments must follow const ones. More...
bool	FileExists (std::string strFilename)
StdVectorFst *	CreateBackoffFst ()
StdVectorFst *	CreateResultFst ()
void	DeleteTestFst (StdVectorFst *fst)
Weight	WalkSinglePath (StdVectorFst *ifst, DeterministicOnDemandFst< StdArc > *dfst)
void	TestBackoffAndCache ()
void	TestCompose ()
template<class Weight , class IntType >
bool	DeterminizeLattice (const Fst< ArcTpl< Weight > > &ifst, MutableFst< ArcTpl< Weight > > *ofst, DeterminizeLatticeOptions opts=DeterminizeLatticeOptions(), bool *debug_ptr=NULL)
	This function implements the normal version of DeterminizeLattice, in which the output strings are represented using sequences of arcs, where all but the first one has an epsilon on the input side. More...
template<class Weight , class IntType >
bool	DeterminizeLattice (const Fst< ArcTpl< Weight > > &ifst, MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *ofst, DeterminizeLatticeOptions opts, bool *debug_ptr)
void	TestLatticeStringRepository ()
template<class Arc >
void	TestDeterminizeLattice ()
template<class Arc >
void	TestDeterminizeLattice2 ()
template<class F >
bool	DeterminizeStar (F &ifst, MutableFst< typename F::Arc > *ofst, float delta=kDelta, bool *debug_ptr=NULL, int max_states=-1, bool allow_partial=false)
	This function implements the normal version of DeterminizeStar, in which the output strings are represented using sequences of arcs, where all but the first one has an epsilon on the input side. More...
template<class F >
bool	DeterminizeStar (F &ifst, MutableFst< GallicArc< typename F::Arc > > *ofst, float delta, bool *debug_ptr, int max_states, bool allow_partial)
template<class Arc >
void	TestDeterminizeGeneral ()
template<class Arc >
void	TestDeterminize ()
template<class Arc >
void	TestDeterminize2 ()
template<class Arc >
void	TestPush ()
template<class Arc >
void	TestMinimize ()
template<class Arc , class inttype >
void	TestStringRepository ()
template<class Arc >
void	ComputeStateInfo (const VectorFst< Arc > &fst, std::vector< char > *epsilon_info)
	This function will set epsilon_info to have size equal to the NumStates() of the FST, containing a logical-or of the enum values kStateHasEpsilonArcsEntering, kStateHasNonEpsilonArcsEntering, kStateHasEpsilonArcsLeaving, and kStateHasNonEpsilonArcsLeaving. More...
template<class Arc >
void	EnsureEpsilonProperty (VectorFst< Arc > *fst)
	This function modifies the fst (while maintaining equivalence) in such a way that, after the modification, all states of the FST which have epsilon-arcs entering them, have no non-epsilon arcs entering them, and all states which have epsilon-arcs leaving them, have no non-epsilon arcs leaving them. More...
void	TestEnsureEpsilonProperty ()
template<class Arc >
void	GetStateProperties (const Fst< Arc > &fst, typename Arc::StateId max_state, std::vector< StatePropertiesType > *props)
	This function works out various properties of the states in the FST, using the bit properties defined in StatePropertiesEnum. More...
template<class Arc , class I >
void	Factor (const Fst< Arc > &fst, MutableFst< Arc > *ofst, std::vector< std::vector< I > > *symbols)
	Factor identifies linear chains of states with an olabel (if any) only on the first arc of the chain, and possibly a sequence of ilabels; it outputs an FST with different symbols on the input that represent sequences of the original input symbols; it outputs the mapping from the new symbol to sequences of original symbols, as "symbols" [zero is reserved for epsilon]. More...
template<class Arc >
void	Factor (const Fst< Arc > &fst, MutableFst< Arc > *ofst1, MutableFst< Arc > *ofst2)
	This is a more conventional interface of Factor that outputs the result as two FSTs. More...
template<class Arc , class I >
void	ExpandInputSequences (const std::vector< std::vector< I > > &sequences, MutableFst< Arc > *fst)
	ExpandInputSequences expands out the input symbols into sequences of input symbols. More...
template<class Arc , class I >
void	CreateFactorFst (const std::vector< std::vector< I > > &sequences, MutableFst< Arc > *fst)
	The function CreateFactorFst will create an FST that expands out the "factors" that are the indices of the "sequences" array, into linear sequences of symbols. More...
template<class Arc , class I >
void	CreateMapFst (const std::vector< I > &symbol_map, MutableFst< Arc > *fst)
	CreateMapFst will create an FST representing this symbol_map. More...
template<class Arc >
static void	TestFactor ()
template<class Arc >
Arc::Label	HighestNumberedOutputSymbol (const Fst< Arc > &fst)
	Returns the highest numbered output symbol id of the FST (or zero for an empty FST. More...
template<class Arc >
Arc::Label	HighestNumberedInputSymbol (const Fst< Arc > &fst)
	Returns the highest numbered input symbol id of the FST (or zero for an empty FST. More...
template<class Arc >
Arc::StateId	NumArcs (const ExpandedFst< Arc > &fst)
	Returns the total number of arcs in an FST. More...
template<class Arc , class I >
void	GetOutputSymbols (const Fst< Arc > &fst, bool include_eps, std::vector< I > *symbols)
	GetOutputSymbols gets the list of symbols on the output of fst (including epsilon, if include_eps == true) More...
template<class Arc , class I >
void	GetInputSymbols (const Fst< Arc > &fst, bool include_eps, std::vector< I > *symbols)
	GetInputSymbols gets the list of symbols on the input of fst (including epsilon, if include_eps == true), as a sorted, unique list. More...
template<class Arc , class I >
void	RemoveSomeInputSymbols (const std::vector< I > &to_remove, MutableFst< Arc > *fst)
	RemoveSomeInputSymbols removes any symbol that appears in "to_remove", from the input side of the FST, replacing them with epsilon. More...
template<class Arc , class I >
void	MapInputSymbols (const std::vector< I > &symbol_mapping, MutableFst< Arc > *fst)
template<class Arc , class I >
bool	GetLinearSymbolSequence (const Fst< Arc > &fst, std::vector< I > *isymbols_out, std::vector< I > *osymbols_out, typename Arc::Weight *tot_weight_out)
	GetLinearSymbolSequence gets the symbol sequence from a linear FST. More...
template<class Arc >
void	ConvertNbestToVector (const Fst< Arc > &fst, std::vector< VectorFst< Arc > > *fsts_out)
	This function converts an FST with a special structure, which is output by the OpenFst functions ShortestPath and RandGen, and converts them into a std::vector of separate FSTs. More...
template<class Arc >
void	NbestAsFsts (const Fst< Arc > &fst, size_t n, std::vector< VectorFst< Arc > > *fsts_out)
	Takes the n-shortest-paths (using ShortestPath), but outputs the result as a vector of up to n fsts. More...
template<class Arc , class I >
void	MakeLinearAcceptorWithAlternatives (const std::vector< std::vector< I > > &labels, MutableFst< Arc > *ofst)
	Creates an unweighted acceptor with a linear structure, with alternatives at each position. More...
template<class Arc , class I >
void	MakeLinearAcceptor (const std::vector< I > &labels, MutableFst< Arc > *ofst)
	Creates unweighted linear acceptor from symbol sequence. More...
template<class I >
void	GetSymbols (const SymbolTable &symtab, bool include_eps, std::vector< I > *syms_out)
template<class Arc >
void	SafeDeterminizeWrapper (MutableFst< Arc > *ifst, MutableFst< Arc > *ofst, float delta=kDelta)
	Does PreDeterminize and DeterminizeStar and then removes the disambiguation symbols. More...
template<class Arc >
void	SafeDeterminizeMinimizeWrapper (MutableFst< Arc > *ifst, VectorFst< Arc > *ofst, float delta=kDelta)
	SafeDeterminizeMinimizeWapper is as SafeDeterminizeWrapper except that it also minimizes (encoded minimization, which is safe). More...
void	DeterminizeStarInLog (VectorFst< StdArc > *fst, float delta, bool *debug_ptr, int max_states)
void	DeterminizeInLog (VectorFst< StdArc > *fst)
void	SafeDeterminizeMinimizeWrapperInLog (VectorFst< StdArc > *ifst, VectorFst< StdArc > *ofst, float delta=kDelta)
	SafeDeterminizeMinimizeWapperInLog is as SafeDeterminizeMinimizeWrapper except it first casts tothe log semiring. More...
void	SafeDeterminizeWrapperInLog (VectorFst< StdArc > *ifst, VectorFst< StdArc > *ofst, float delta)
template<class Arc >
void	RemoveWeights (MutableFst< Arc > *ifst)
template<class Arc >
bool	PrecedingInputSymbolsAreSame (bool start_is_epsilon, const Fst< Arc > &fst)
	Returns true if and only if the FST is such that the input symbols on arcs entering any given state all have the same value. More...
template<class Arc , class F >
bool	PrecedingInputSymbolsAreSameClass (bool start_is_epsilon, const Fst< Arc > &fst, const F &f)
	This is as PrecedingInputSymbolsAreSame, but with a functor f that maps labels to classes. More...
template<class Arc >
bool	FollowingInputSymbolsAreSame (bool end_is_epsilon, const Fst< Arc > &fst)
	Returns true if and only if the FST is such that the input symbols on arcs exiting any given state all have the same value. More...
template<class Arc , class F >
bool	FollowingInputSymbolsAreSameClass (bool end_is_epsilon, const Fst< Arc > &fst, const F &f)
template<class Arc >
void	MakePrecedingInputSymbolsSame (bool start_is_epsilon, MutableFst< Arc > *fst)
	MakePrecedingInputSymbolsSame ensures that all arcs entering any given fst state have the same input symbol. More...
template<class Arc , class F >
void	MakePrecedingInputSymbolsSameClass (bool start_is_epsilon, MutableFst< Arc > *fst, const F &f)
	As MakePrecedingInputSymbolsSame, but takes a functor object that maps labels to classes. More...
template<class Arc >
void	MakeFollowingInputSymbolsSame (bool end_is_epsilon, MutableFst< Arc > *fst)
	MakeFollowingInputSymbolsSame ensures that all arcs exiting any given fst state have the same input symbol. More...
template<class Arc , class F >
void	MakeFollowingInputSymbolsSameClass (bool end_is_epsilon, MutableFst< Arc > *fst, const F &f)
	As MakeFollowingInputSymbolsSame, but takes a functor object that maps labels to classes. More...
template<class Arc >
VectorFst< Arc > *	MakeLoopFst (const std::vector< const ExpandedFst< Arc > * > &fsts)
	MakeLoopFst creates an FST that has a state that is both initial and final (weight == Weight::One()), and for each non-NULL pointer fsts[i], it has an arc out whose output-symbol is i and which goes to a sub-graph whose input language is equivalent to fsts[i], where the final-state becomes a transition to the loop-state. More...
template<class Arc >
void	ClearSymbols (bool clear_input, bool clear_output, MutableFst< Arc > *fst)
	ClearSymbols sets all the symbols on the input and/or output side of the FST to zero, as specified. More...
template<class Arc >
void	ApplyProbabilityScale (float scale, MutableFst< Arc > *fst)
	ApplyProbabilityScale is applicable to FSTs in the log or tropical semiring. More...
template<class Arc >
ssize_t	FindSelfLoopWithILabel (const Fst< Arc > &fst, typename Arc::StateId s)
template<class Arc >
bool	EqualAlign (const Fst< Arc > &ifst, typename Arc::StateId length, int rand_seed, MutableFst< Arc > *ofst, int num_retries=10)
	EqualAlign is similar to RandGen, but it generates a sequence with exactly "length" input symbols. More...
template<class Arc >
void	RemoveUselessArcs (MutableFst< Arc > *fst)
template<class Arc >
void	PhiCompose (const Fst< Arc > &fst1, const Fst< Arc > &fst2, typename Arc::Label phi_label, MutableFst< Arc > *ofst)
template<class Arc >
void	PropagateFinalInternal (typename Arc::Label phi_label, typename Arc::StateId s, MutableFst< Arc > *fst)
template<class Arc >
void	PropagateFinal (typename Arc::Label phi_label, MutableFst< Arc > *fst)
template<class Arc >
void	RhoCompose (const Fst< Arc > &fst1, const Fst< Arc > &fst2, typename Arc::Label rho_label, MutableFst< Arc > *ofst)
template<>
bool	IsStochasticFst (const Fst< LogArc > &fst, float delta, LogArc::Weight *min_sum, LogArc::Weight *max_sum)
template<class Arc >
bool	IsStochasticFst (const Fst< Arc > &fst, float delta=kDelta, typename Arc::Weight *min_sum=NULL, typename Arc::Weight *max_sum=NULL)
	This function returns true if, in the semiring of the FST, the sum (within the semiring) of all the arcs out of each state in the FST is one, to within delta. More...
bool	IsStochasticFstInLog (const Fst< StdArc > &fst, float delta, StdArc::Weight *min_sum, StdArc::Weight *max_sum)
template<class Arc , class I >
void	TestMakeLinearAcceptor ()
template<class Arc >
void	TestDeterminizeStarInLog ()
template<class Arc >
void	TestSafeDeterminizeWrapper ()
void	TestPushInLog ()
template<class Arc >
void	TestAcceptorMinimize ()
template<class Arc >
void	TestMakeSymbolsSame ()
template<class Arc >
void	TestMakeSymbolsSameClass ()
template<class Arc >
VectorFst< Arc > *	MakeLoopFstCompare (const vector< const ExpandedFst< Arc > *> &fsts)
template<class Arc >
void	TestMakeLoopFst ()
template<class Arc >
void	TestEqualAlign ()
template<class Arc >
void	Print (const Fst< Arc > &fst, std::string message)
template<class Arc >
void	TestRemoveUselessArcs ()
template<ReweightType rtype>
void	PushInLog (VectorFst< StdArc > *fst, uint32 ptype, float delta=kDelta)
template<class Arc >
void	MinimizeEncoded (VectorFst< Arc > *fst, float delta=kDelta)
void	ComposeContextLeftBiphone (int32 nonterm_phones_offset, const vector< int32 > &disambig_syms_in, const VectorFst< StdArc > &ifst, VectorFst< StdArc > *ofst, std::vector< std::vector< int32 > > *ilabels)
	This is a variant of the function ComposeContext() which is to be used with our "grammar FST" framework (see The ContextFst object, i.e. More...
int32	GetEncodingMultiple (int32 nonterm_phones_offset)
void	ComposeContextLeftBiphone (int32 nonterm_phones_offset, const std::vector< int32 > &disambig_syms, const VectorFst< StdArc > &ifst, VectorFst< StdArc > *ofst, std::vector< std::vector< int32 > > *ilabels)
	This is a variant of the function ComposeContext() which is to be used with our "grammar FST" framework (see The ContextFst object, i.e. More...
template<class Arc >
void	WriteFstKaldi (std::ostream &os, bool binary, const VectorFst< Arc > &t)
template<class W >
bool	StrToWeight (const std::string &s, bool allow_zero, W *w)
template<class Arc >
void	ReadFstKaldi (std::istream &is, bool binary, VectorFst< Arc > *fst)
VectorFst< StdArc > *	ReadFstKaldi (std::string rxfilename)
Fst< StdArc > *	ReadFstKaldiGeneric (std::string rxfilename, bool throw_on_err)
VectorFst< StdArc > *	CastOrConvertToVectorFst (Fst< StdArc > *fst)
void	ReadFstKaldi (std::string rxfilename, fst::StdVectorFst *ofst)
void	WriteFstKaldi (const VectorFst< StdArc > &fst, std::string wxfilename)
fst::VectorFst< fst::StdArc > *	ReadAndPrepareLmFst (std::string rxfilename)
void	ReadFstKaldi (std::string rxfilename, VectorFst< StdArc > *ofst)
template<class Weight , class Int >
void	ConvertLattice (const ExpandedFst< ArcTpl< Weight > > &ifst, MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > *ofst, bool invert=true)
	Convert lattice from a normal FST to a CompactLattice FST. More...
template<class Weight , class Int >
void	ConvertLattice (const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > &ifst, MutableFst< ArcTpl< Weight > > *ofst, bool invert=true)
	Convert lattice CompactLattice format to Lattice. More...
template<class WeightIn , class WeightOut >
void	ConvertLattice (const ExpandedFst< ArcTpl< WeightIn > > &ifst, MutableFst< ArcTpl< WeightOut > > *ofst)
	Convert between CompactLattices and Lattices of different floating point types... More...
template<class Weight , class ScaleFloat >
void	ScaleLattice (const std::vector< std::vector< ScaleFloat > > &scale, MutableFst< ArcTpl< Weight > > *fst)
	Scales the pairs of weights in LatticeWeight or CompactLatticeWeight by viewing the pair (a, b) as a 2-vector and pre-multiplying by the 2x2 matrix in "scale". More...
template<class Weight , class Int >
void	RemoveAlignmentsFromCompactLattice (MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > *fst)
	Removes state-level alignments (the strings that are part of the weights). More...
template<class Weight , class Int >
bool	CompactLatticeHasAlignment (const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > &fst)
	Returns true if lattice has alignments, i.e. More...
template<class Real >
void	ConvertFstToLattice (const ExpandedFst< ArcTpl< TropicalWeight > > &ifst, MutableFst< ArcTpl< LatticeWeightTpl< Real > > > *ofst)
	Converts TropicalWeight to LatticeWeight (puts all the weight on the first float in the lattice's pair). More...
template<class Weight , class Int >
void	TestConvert (bool invert)
template<class Weight , class Int >
void	TestShortestPath ()
template<class Int >
void	TestConvert2 ()
template<class Weight , class Int >
void	TestConvertPair (bool invert)
template<class Weight , class Int >
void	TestScalePair (bool invert)
template<class Int >
void	ConvertLattice (const ExpandedFst< ArcTpl< LatticeWeightTpl< float > > > &ifst, MutableFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< double >, Int > > > *ofst)
template<class Int >
void	ConvertLattice (const ExpandedFst< ArcTpl< LatticeWeightTpl< double > > > &ifst, MutableFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< float >, Int > > > *ofst)
template<class Int >
void	ConvertLattice (const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< double >, Int > > > &ifst, MutableFst< ArcTpl< LatticeWeightTpl< float > > > *ofst)
	Converts CompactLattice with double to Lattice with float. More...
template<class Int >
void	ConvertLattice (const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< float >, Int > > > &ifst, MutableFst< ArcTpl< LatticeWeightTpl< double > > > *ofst)
	Converts CompactLattice with float to Lattice with double. More...
std::vector< std::vector< double > >	DefaultLatticeScale ()
	Returns a default 2x2 matrix scaling factor for LatticeWeight. More...
std::vector< std::vector< double > >	AcousticLatticeScale (double acwt)
std::vector< std::vector< double > >	GraphLatticeScale (double lmwt)
std::vector< std::vector< double > >	LatticeScale (double lmwt, double acwt)
template<class Weight , class Int >
void	PruneCompactLattice (Weight beam, MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > *fst)
LatticeWeight	RandomLatticeWeight ()
CompactLatticeWeight	RandomCompactLatticeWeight ()
void	LatticeWeightTest ()
void	CompactLatticeWeightTest ()
template<class FloatType >
std::ostream &	operator<< (std::ostream &strm, const LatticeWeightTpl< FloatType > &w)
template<class FloatType >
std::istream &	operator>> (std::istream &strm, LatticeWeightTpl< FloatType > &w)
template<class FloatType , class ScaleFloatType >
LatticeWeightTpl< FloatType >	ScaleTupleWeight (const LatticeWeightTpl< FloatType > &w, const std::vector< std::vector< ScaleFloatType > > &scale)
template<class FloatType , class ScaleFloatType >
PairWeight< TropicalWeightTpl< FloatType >, TropicalWeightTpl< FloatType > >	ScaleTupleWeight (const PairWeight< TropicalWeightTpl< FloatType >, TropicalWeightTpl< FloatType > > &w, const std::vector< std::vector< ScaleFloatType > > &scale)
template<class FloatType >
bool	operator== (const LatticeWeightTpl< FloatType > &wa, const LatticeWeightTpl< FloatType > &wb)
template<class FloatType >
bool	operator!= (const LatticeWeightTpl< FloatType > &wa, const LatticeWeightTpl< FloatType > &wb)
template<class FloatType >
int	Compare (const LatticeWeightTpl< FloatType > &w1, const LatticeWeightTpl< FloatType > &w2)
	Compare returns -1 if w1 < w2, +1 if w1 > w2, and 0 if w1 == w2. More...
template<class FloatType >
LatticeWeightTpl< FloatType >	Plus (const LatticeWeightTpl< FloatType > &w1, const LatticeWeightTpl< FloatType > &w2)
template<class FloatType >
LatticeWeightTpl< FloatType >	Times (const LatticeWeightTpl< FloatType > &w1, const LatticeWeightTpl< FloatType > &w2)
template<class FloatType >
LatticeWeightTpl< FloatType >	Divide (const LatticeWeightTpl< FloatType > &w1, const LatticeWeightTpl< FloatType > &w2, DivideType typ=DIVIDE_ANY)
template<class FloatType >
bool	ApproxEqual (const LatticeWeightTpl< FloatType > &w1, const LatticeWeightTpl< FloatType > &w2, float delta=kDelta)
template<class WeightType , class IntType >
bool	operator== (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2)
template<class WeightType , class IntType >
bool	operator!= (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2)
template<class WeightType , class IntType >
bool	ApproxEqual (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2, float delta=kDelta)
template<class WeightType , class IntType >
int	Compare (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2)
int	Compare (const TropicalWeight &w1, const TropicalWeight &w2)
template<class WeightType , class IntType >
CompactLatticeWeightTpl< WeightType, IntType >	Plus (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2)
template<class WeightType , class IntType >
CompactLatticeWeightTpl< WeightType, IntType >	Times (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2)
template<class WeightType , class IntType >
CompactLatticeWeightTpl< WeightType, IntType >	Divide (const CompactLatticeWeightTpl< WeightType, IntType > &w1, const CompactLatticeWeightTpl< WeightType, IntType > &w2, DivideType div=DIVIDE_ANY)
template<class WeightType , class IntType >
std::ostream &	operator<< (std::ostream &strm, const CompactLatticeWeightTpl< WeightType, IntType > &w)
template<class WeightType , class IntType >
std::istream &	operator>> (std::istream &strm, CompactLatticeWeightTpl< WeightType, IntType > &w)
template<class Weight , class IntType , class ScaleFloatType >
CompactLatticeWeightTpl< Weight, IntType >	ScaleTupleWeight (const CompactLatticeWeightTpl< Weight, IntType > &w, const std::vector< std::vector< ScaleFloatType > > &scale)
	Scales the pair (a, b) of floating-point weights inside a CompactLatticeWeight by premultiplying it (viewed as a vector) by a 2x2 matrix "scale". More...
template<class Float1 , class Float2 >
void	ConvertLatticeWeight (const LatticeWeightTpl< Float1 > &w_in, LatticeWeightTpl< Float2 > *w_out)
	Define some ConvertLatticeWeight functions that are used in various lattice conversions... More...
template<class Float1 , class Float2 , class Int >
void	ConvertLatticeWeight (const CompactLatticeWeightTpl< LatticeWeightTpl< Float1 >, Int > &w_in, CompactLatticeWeightTpl< LatticeWeightTpl< Float2 >, Int > *w_out)
template<class Float1 , class Float2 >
void	ConvertLatticeWeight (const LatticeWeightTpl< Float1 > &w_in, TropicalWeightTpl< Float2 > *w_out)
template<class Float >
double	ConvertToCost (const LatticeWeightTpl< Float > &w)
template<class Float , class Int >
double	ConvertToCost (const CompactLatticeWeightTpl< LatticeWeightTpl< Float >, Int > &w)
template<class Float >
double	ConvertToCost (const TropicalWeightTpl< Float > &w)
template<class Arc , class Int >
void	PreDeterminize (MutableFst< Arc > *fst, typename Arc::Label first_new_sym, std::vector< Int > *symsOut)
template<class Label >
void	CreateNewSymbols (SymbolTable *input_sym_table, int nSym, std::string prefix, std::vector< Label > *symsOut)
template<class Arc >
void	AddSelfLoops (MutableFst< Arc > *fst, std::vector< typename Arc::Label > &isyms, std::vector< typename Arc::Label > &osyms)
	AddSelfLoops is a function you will probably want to use alongside PreDeterminize, to add self-loops to any FSTs that you compose on the left hand side of the one modified by PreDeterminize. More...
template<class Arc >
int64	DeleteISymbols (MutableFst< Arc > *fst, std::vector< typename Arc::Label > isyms)
template<class Arc >
Arc::StateId	CreateSuperFinal (MutableFst< Arc > *fst)
template<class Arc >
void	TestPreDeterminize ()
template<class Arc >
void	TestAddSelfLoops ()
template<class Arc >
void	PruneSpecial (const Fst< Arc > &ifst, VectorFst< Arc > *ofst, typename Arc::Weight beam, size_t max_states=0)
	The function PruneSpecial is like the standard OpenFst function "prune", except it does not expand the entire "ifst"- this is useful for cases where ifst is an on-demand FST such as a ComposeFst and we don't want to visit it all. More...
static void	TestPruneSpecial ()
static void	TestPushSpecial ()
void	PushSpecial (VectorFst< StdArc > *fst, float delta)
template<class Arc >
VectorFst< Arc > *	RandFst (RandFstOptions opts=RandFstOptions())
	Returns a random FST. More...
template<class Arc >
VectorFst< Arc > *	RandPairFst (RandFstOptions opts=RandFstOptions())
	Returns a random FST. More...
template<class Arc >
void	RemoveEpsLocal (MutableFst< Arc > *fst)
	RemoveEpsLocal remove some (but not necessarily all) epsilons in an FST, using an algorithm that is guaranteed to never increase the number of arcs in the FST (and will also never increase the number of states). More...
void	RemoveEpsLocalSpecial (MutableFst< StdArc > *fst)
	As RemoveEpsLocal but takes care to preserve stochasticity when cast to LogArc. More...
template<class Arc >
static void	TestRemoveEpsLocal ()
static void	TestRemoveEpsLocalSpecial ()
template<class Arc >
void	TestTableMatcher (bool connect, bool left)
template<class Arc >
void	TestTableMatcherCacheLeft (bool connect)
template<class Arc >
void	TestTableMatcherCacheRight (bool connect)
template<class Arc >
void	TableCompose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const TableComposeOptions &opts=TableComposeOptions())
template<class Arc >
void	TableCompose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, TableComposeCache< Fst< Arc > > *cache)
template<class Arc >
void	TestFactor ()
static ConstFst< StdArc > *	ReadConstFstFromStream (std::istream &is)
static void	InputDeterminizeSingleState (StdArc::StateId s, VectorFst< StdArc > *fst)
	This utility function input-determinizes a specified state s of the FST 'fst'. More...
void	PrepareForGrammarFst (int32 nonterm_phones_offset, VectorFst< StdArc > *fst)
	This function prepares 'ifst' for use in GrammarFst: it ensures that it has the expected properties, changing it slightly as needed. More...
void	CopyToVectorFst (GrammarFst *grammar_fst, VectorFst< StdArc > *vector_fst)
	This function copies a GrammarFst to a VectorFst (intended mostly for testing and comparison purposes). More...
template<class T >
ArcticWeightTpl< T >	Plus (const ArcticWeightTpl< T > &w1, const ArcticWeightTpl< T > &w2)
ArcticWeightTpl< float >	Plus (const ArcticWeightTpl< float > &w1, const ArcticWeightTpl< float > &w2)
ArcticWeightTpl< double >	Plus (const ArcticWeightTpl< double > &w1, const ArcticWeightTpl< double > &w2)
template<class T >
ArcticWeightTpl< T >	Times (const ArcticWeightTpl< T > &w1, const ArcticWeightTpl< T > &w2)
ArcticWeightTpl< float >	Times (const ArcticWeightTpl< float > &w1, const ArcticWeightTpl< float > &w2)
ArcticWeightTpl< double >	Times (const ArcticWeightTpl< double > &w1, const ArcticWeightTpl< double > &w2)
template<class T >
ArcticWeightTpl< T >	Divide (const ArcticWeightTpl< T > &w1, const ArcticWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
ArcticWeightTpl< float >	Divide (const ArcticWeightTpl< float > &w1, const ArcticWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
ArcticWeightTpl< double >	Divide (const ArcticWeightTpl< double > &w1, const ArcticWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
template<class Arc >
void	TestDeterminizeLatticePruned ()
template<class Arc >
void	TestDeterminizeLatticePruned2 ()
template<class Weight , class IntType >
bool	DeterminizeLatticePruned (const ExpandedFst< ArcTpl< Weight > > &ifst, double beam, MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *ofst, DeterminizeLatticePrunedOptions opts)
template<class Weight >
bool	DeterminizeLatticePruned (const ExpandedFst< ArcTpl< Weight > > &ifst, double prune, MutableFst< ArcTpl< Weight > > *ofst, DeterminizeLatticePrunedOptions opts=DeterminizeLatticePrunedOptions())
	This function implements the normal version of DeterminizeLattice, in which the output strings are represented using sequences of arcs, where all but the first one has an epsilon on the input side. More...
template<class Weight >
ArcTpl< Weight >::Label	DeterminizeLatticeInsertPhones (const kaldi::TransitionModel &trans_model, MutableFst< ArcTpl< Weight > > *fst)
	This function takes in lattices and inserts phones at phone boundaries. More...
template<class Weight >
void	DeterminizeLatticeDeletePhones (typename ArcTpl< Weight >::Label first_phone_label, MutableFst< ArcTpl< Weight > > *fst)
	This function takes in lattices and deletes "phones" from them. More...
template void	DeterminizeLatticeDeletePhones (ArcTpl< kaldi::LatticeWeight >::Label first_phone_label, MutableFst< ArcTpl< kaldi::LatticeWeight > > *fst)
template<class Weight , class IntType >
bool	DeterminizeLatticePhonePrunedFirstPass (const kaldi::TransitionModel &trans_model, double beam, MutableFst< ArcTpl< Weight > > *fst, const DeterminizeLatticePrunedOptions &opts)
	This function does a first pass determinization with phone symbols inserted at phone boundary. More...
template<class Weight , class IntType >
bool	DeterminizeLatticePhonePruned (const kaldi::TransitionModel &trans_model, MutableFst< ArcTpl< Weight > > *ifst, double prune, MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *ofst, DeterminizeLatticePhonePrunedOptions opts=DeterminizeLatticePhonePrunedOptions())
	"Destructive" version of DeterminizeLatticePhonePruned() where the input lattice might be changed. More...
template<class Weight , class IntType >
bool	DeterminizeLatticePhonePruned (const kaldi::TransitionModel &trans_model, const ExpandedFst< ArcTpl< Weight > > &ifst, double prune, MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *ofst, DeterminizeLatticePhonePrunedOptions opts=DeterminizeLatticePhonePrunedOptions())
	This function is a wrapper of DeterminizeLatticePhonePrunedFirstPass() and DeterminizeLatticePruned(). More...
bool	DeterminizeLatticePhonePrunedWrapper (const kaldi::TransitionModel &trans_model, MutableFst< kaldi::LatticeArc > *ifst, double prune, MutableFst< kaldi::CompactLatticeArc > *ofst, DeterminizeLatticePhonePrunedOptions opts=DeterminizeLatticePhonePrunedOptions())
	This function is a wrapper of DeterminizeLatticePhonePruned() that works for Lattice type FSTs. More...
template bool	DeterminizeLatticePruned< kaldi::LatticeWeight > (const ExpandedFst< kaldi::LatticeArc > &ifst, double prune, MutableFst< kaldi::CompactLatticeArc > *ofst, DeterminizeLatticePrunedOptions opts)
template bool	DeterminizeLatticePruned< kaldi::LatticeWeight > (const ExpandedFst< kaldi::LatticeArc > &ifst, double prune, MutableFst< kaldi::LatticeArc > *ofst, DeterminizeLatticePrunedOptions opts)
template bool	DeterminizeLatticePhonePruned< kaldi::LatticeWeight, kaldi::int32 > (const kaldi::TransitionModel &trans_model, const ExpandedFst< kaldi::LatticeArc > &ifst, double prune, MutableFst< kaldi::CompactLatticeArc > *ofst, DeterminizeLatticePhonePrunedOptions opts)
template bool	DeterminizeLatticePhonePruned< kaldi::LatticeWeight, kaldi::int32 > (const kaldi::TransitionModel &trans_model, MutableFst< kaldi::LatticeArc > *ifst, double prune, MutableFst< kaldi::CompactLatticeArc > *ofst, DeterminizeLatticePhonePrunedOptions opts)
template<class Weight , class IntType >
bool	MinimizeCompactLattice (MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *clat, float delta=fst::kDelta)
	This function minimizes the compact lattice. More...
template bool	MinimizeCompactLattice< kaldi::LatticeWeight, kaldi::int32 > (MutableFst< kaldi::CompactLatticeArc > *clat, float delta)
template<class Weight , class IntType >
bool	PushCompactLatticeStrings (MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *clat)
	This function pushes the transition-ids as far towards the start as they will go. More...
template<class Weight , class IntType >
bool	PushCompactLatticeWeights (MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *clat)
	This function pushes the weights in the CompactLattice so that all states except possibly the start state, have Weight components (of type LatticeWeight) that "sum to one" in the LatticeWeight (i.e. More...
template bool	PushCompactLatticeStrings< kaldi::LatticeWeight, kaldi::int32 > (MutableFst< kaldi::CompactLatticeArc > *clat)
template bool	PushCompactLatticeWeights< kaldi::LatticeWeight, kaldi::int32 > (MutableFst< kaldi::CompactLatticeArc > *clat)
static void	InputDeterminizeSingleState (StdArc::StateId s, VectorFst< StdArc > *fst)
template<class Arc , class I >
void	RemoveArcsWithSomeInputSymbols (const std::vector< I > &symbols_in, VectorFst< Arc > *fst)
template<class Arc , class I >
void	PenalizeArcsWithSomeInputSymbols (const std::vector< I > &symbols_in, float penalty, VectorFst< Arc > *fst)
ConstFst< StdArc > *	ReadAsConstFst (std::string rxfilename)
bool	PrintProxyFstPath (const VectorFst< StdArc > &proxy, vector< vector< StdArc::Label > > *path, vector< StdArc::Weight > *weight, StdArc::StateId cur_state, vector< StdArc::Label > cur_path, StdArc::Weight cur_weight)

Detailed Description

For an extended explanation of the framework of which grammar-fsts are a part, please see Support for grammars and graphs with on-the-fly parts. (i.e.

../doc/grammar.dox).

This header implements a special FST type which we use in that framework; it is a lightweight wrapper which stitches together several FSTs and makes them look, to the decoder code, like a single FST. It is a bit like OpenFst's Replace() function, but with support for left-biphone context.

Typedef Documentation

ArcticWeight

typedef ArcticWeightTpl<float> ArcticWeight

Definition at line 84 of file arctic-weight.h.

BaseFloat

typedef float BaseFloat

Definition at line 28 of file lattice-weight-test.cc.

CompactLatticeWeight

typedef CompactLatticeWeightTpl<LatticeWeight, int32> CompactLatticeWeight

Definition at line 32 of file lattice-weight-test.cc.

CompactLatticeWeightCommonDivisor

typedef CompactLatticeWeightCommonDivisorTpl<LatticeWeight, int32> CompactLatticeWeightCommonDivisor

Definition at line 35 of file lattice-weight-test.cc.

Label

typedef fst::StdArc::Label Label

Definition at line 57 of file deterministic-fst-test.cc.

LatticeWeight

typedef LatticeWeightTpl<BaseFloat> LatticeWeight

Definition at line 30 of file lattice-weight-test.cc.

StateId

typedef fst::StdArc::StateId StateId

Definition at line 58 of file deterministic-fst-test.cc.

StatePropertiesType

typedef unsigned char StatePropertiesType

Definition at line 122 of file factor.h.

StdArc

typedef fst::StdArc StdArc

Definition at line 56 of file deterministic-fst-test.cc.

StdVectorFst

typedef fst::StdVectorFst StdVectorFst

Definition at line 59 of file deterministic-fst-test.cc.

VectorFstHolder

typedef VectorFstTplHolder<StdArc> VectorFstHolder

Definition at line 151 of file kaldi-fst-io.h.

Weight

typedef fst::StdArc::Weight Weight

Definition at line 60 of file deterministic-fst-test.cc.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kStateHasEpsilonArcsEntering
kStateHasNonEpsilonArcsEntering
kStateHasEpsilonArcsLeaving
kStateHasNonEpsilonArcsLeaving

Definition at line 27 of file epsilon-property.h.

     {
  kStateHasEpsilonArcsEntering = 0x1,
  kStateHasNonEpsilonArcsEntering = 0x2,
  kStateHasEpsilonArcsLeaving = 0x4,
  kStateHasNonEpsilonArcsLeaving = 0x8
}; // use 'char' for this enum.

NonterminalValues

enum NonterminalValues

An anonymous enum to define some values for symbols used in our grammar-fst framework.

Please understand this with reference to the documentation in Support for grammars and graphs with on-the-fly parts. (../doc/grammar.dox). This enum defines the values of nonterminal-related symbols in phones.txt. They are not the actual values– they will be shifted by adding the value nonterm_phones_offset which is passed in by the command-line flag –nonterm-phones-offset.

Enumerator
kNontermBos
kNontermBegin
kNontermEnd
kNontermReenter
kNontermUserDefined
kNontermMediumNumber
kNontermBigNumber

Definition at line 68 of file grammar-context-fst.h.

                       {
  kNontermBos = 0,  // #nonterm_bos
  kNontermBegin = 1,  // #nonterm_begin
  kNontermEnd = 2,  // #nonterm_end
  kNontermReenter = 3,  // #nonterm_reenter
  kNontermUserDefined = 4,   // the lowest-numbered user-defined nonterminal, e.g. #nonterm:foo
  // kNontermMediumNumber and kNontermBigNumber come into the encoding of
  // nonterminal-related symbols in HCLG.fst.  The only hard constraint on them
  // is that kNontermBigNumber must be bigger than the biggest transition-id in
  // your system, and kNontermMediumNumber must be >0.  These values were chosen
  // for ease of human inspection of numbers encoded with them.
  kNontermMediumNumber = 1000,
  kNontermBigNumber = 10000000
};

StatePropertiesEnum

enum StatePropertiesEnum

Enumerator
kStateFinal
kStateInitial
kStateArcsIn
kStateMultipleArcsIn
kStateArcsOut
kStateMultipleArcsOut
kStateOlabelsOut
kStateIlabelsOut

Definition at line 112 of file factor.h.

{ kStateFinal = 0x1,
  kStateInitial = 0x2,
  kStateArcsIn = 0x4,
  kStateMultipleArcsIn = 0x8,
  kStateArcsOut = 0x10,
  kStateMultipleArcsOut = 0x20,
  kStateOlabelsOut = 0x40,
  kStateIlabelsOut = 0x80 };

Function Documentation

AcousticLatticeScale()

std::vector<std::vector<double> > fst::AcousticLatticeScale ( double  acwt )

inline

Definition at line 138 of file lattice-utils.h.

Referenced by DiscriminativeSupervisionSplitter::CreateRangeLattice(), kaldi::DecodeUtterance(), kaldi::DecodeUtteranceLatticeFaster(), kaldi::DecodeUtteranceLatticeIncremental(), kaldi::DecodeUtteranceLatticeSimple(), main(), DeterminizeLatticeTask::operator()(), DecodeUtteranceLatticeFasterClass::operator()(), DiscriminativeSupervisionSplitter::PrepareLattice(), and NnetBatchDecoder::ProcessOutputUtterance().

                                                                       {
  std::vector<std::vector<double> > ans(2);
  ans[0].resize(2, 0.0);
  ans[1].resize(2, 0.0);
  ans[0][0] = 1.0;
  ans[1][1] = acwt;
  return ans;
}

AddSelfLoops()

void AddSelfLoops	(	MutableFst< Arc > *	fst,
		std::vector< typename Arc::Label > &	isyms,
		std::vector< typename Arc::Label > &	osyms
	)

AddSelfLoops is a function you will probably want to use alongside PreDeterminize, to add self-loops to any FSTs that you compose on the left hand side of the one modified by PreDeterminize.

This function inserts loops with "special symbols" [e.g. #0, #1] into an FST. This is done at each final state and each state with non-epsilon output symbols on at least one arc out of it. This is to ensure that these symbols, when inserted into the input side of an FST we will compose with on the right, can "pass through" this FST.

At input, isyms and osyms must be vectors of the same size n, corresponding to symbols that currently do not exist in 'fst'. For each state in n that has non-epsilon symbols on the output side of arcs leaving it, or which is a final state, this function inserts n self-loops with unit weight and one of the n pairs of symbols on its input and output.

Definition at line 599 of file pre-determinize-inl.h.

References rnnlm::i, and rnnlm::n.

Referenced by TestAddSelfLoops().

                                                                           {
  assert(fst != NULL);
  assert(isyms.size() == osyms.size());
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  size_t n = isyms.size();
  if (n == 0) return;  // Nothing to do.

  // {
  // the following declarations and statements are for quick detection of these
  // symbols, which is purely for debugging/checking purposes.
  Label  isyms_min = *std::min_element(isyms.begin(), isyms.end()),
         isyms_max = *std::max_element(isyms.begin(), isyms.end()),
         osyms_min = *std::min_element(osyms.begin(), osyms.end()),
         osyms_max = *std::max_element(osyms.begin(), osyms.end());
  std::set<Label> isyms_set, osyms_set;
  for (size_t i = 0; i < isyms.size(); i++) {
    assert(isyms[i] > 0 && osyms[i] > 0);  // should not have epsilon or invalid symbols.
    isyms_set.insert(isyms[i]);
    osyms_set.insert(osyms[i]);
  }
  assert(isyms_set.size() == n && osyms_set.size() == n);
  // } end block.

  for (StateIterator<MutableFst<Arc> > siter(*fst); ! siter.Done(); siter.Next()) {
    StateId state = siter.Value();
    bool this_state_needs_self_loops = (fst->Final(state) != Weight::Zero());
    for (ArcIterator<MutableFst<Arc> > aiter(*fst, state); ! aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      // If one of the following asserts fails, it means that the input FST already had the symbols
      // we are inserting.  This is contrary to the preconditions of this algorithm.
      assert(!(arc.ilabel>=isyms_min && arc.ilabel<=isyms_max && isyms_set.count(arc.ilabel) != 0));
      assert(!(arc.olabel>=osyms_min && arc.olabel<=osyms_max && osyms_set.count(arc.olabel) != 0));
      if (arc.olabel != 0) // Has non-epsilon output label -> need self loops.
        this_state_needs_self_loops = true;
    }
    if (this_state_needs_self_loops) {
      for (size_t i = 0;i < n;i++) {
        Arc arc;
        arc.ilabel = isyms[i];
        arc.olabel = osyms[i];
        arc.weight = Weight::One();
        arc.nextstate = state;
        fst->AddArc(state, arc);
      }
    }
  }
}

AddSubsequentialLoop()

void AddSubsequentialLoop	(	StdArc::Label	subseq_symbol,
		MutableFst< StdArc > *	fst
	)

Modifies an FST so that it transuces the same paths, but the input side of the paths can all have the subsequential symbol '$' appended to them any number of times (we could easily specify the number of times, but accepting any number of repetitions is just more convenient).

The actual way we do this is for each final state, we add a transition with weight equal to the final-weight of that state, with input-symbol '$' and output-symbols <eps>, and ending in a new super-final state that has unit final-probability and a unit-weight self-loop with '$' on its input and <eps> on its output. The reason we don't just add a loop to each final-state has to do with preserving stochasticity (see Preserving stochasticity and testing it). We keep the final-probability in all the original final-states rather than setting them to zero, so the resulting FST can accept zero '$' symbols at the end (in case we had no right context).

Definition at line 297 of file context-fst.cc.

References rnnlm::i.

Referenced by ComposeContext(), main(), and TrainingGraphCompiler::TrainingGraphCompiler().

                                                   {
  typedef StdArc Arc;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  vector<StateId> final_states;
  for (StateIterator<MutableFst<Arc> > siter(*fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    if (fst->Final(s) != Weight::Zero())  final_states.push_back(s);
  }

  StateId superfinal = fst->AddState();
  Arc arc(subseq_symbol, 0, Weight::One(), superfinal);
  fst->AddArc(superfinal, arc);  // loop at superfinal.
  fst->SetFinal(superfinal, Weight::One());

  for (size_t i = 0; i < final_states.size(); i++) {
    StateId s = final_states[i];
    fst->AddArc(s, Arc(subseq_symbol, 0, fst->Final(s), superfinal));
    // No, don't remove the final-weights of the original states..
    // this is so we can add the subsequential loop in cases where
    // there is no context, and it won't hurt.
    // fst->SetFinal(s, Weight::Zero());
    arc.nextstate = final_states[i];
  }
}

ApplyProbabilityScale()

void ApplyProbabilityScale	(	float	scale,
		MutableFst< Arc > *	fst
	)

ApplyProbabilityScale is applicable to FSTs in the log or tropical semiring.

It multiplies the arc and final weights by "scale" [this is not the Mul operation of the semiring, it's actual multiplication, which is equivalent to taking a power in the semiring].

Definition at line 771 of file fstext-utils-inl.h.

Referenced by kaldi::GetHmmAsFsa(), main(), and MinimizeEncoded().

                                                              {
  typedef typename Arc::Weight Weight;
  typedef typename Arc::StateId StateId;
  for (StateIterator<MutableFst<Arc> > siter(*fst);
       !siter.Done();
       siter.Next()) {
    StateId s = siter.Value();
    for (MutableArcIterator<MutableFst<Arc> > aiter(fst, s);
        !aiter.Done();
        aiter.Next()) {
      Arc arc = aiter.Value();
      arc.weight = Weight(arc.weight.Value() * scale);
      aiter.SetValue(arc);
    }
    if (fst->Final(s) != Weight::Zero())
      fst->SetFinal(s, Weight(fst->Final(s).Value() * scale));
  }
}

ApproxEqual() [1/2]

bool fst::ApproxEqual ( const LatticeWeightTpl< FloatType > &  w1, const LatticeWeightTpl< FloatType > &  w2, float  delta = kDelta  )

inline

Definition at line 389 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by DeterminizerStar< F >::EpsilonClosure::AddOneElement(), ApproxEqual(), CompactLatticeWeightTest(), CompactLatticeMinimizer< Weight, IntType >::Equivalent(), IsStochasticFst(), LatticeWeightTest(), DeterminizerStar< F >::SubsetEqual::operator()(), LatticeDeterminizerPruned< Weight, IntType >::SubsetEqual::operator()(), LatticeDeterminizer< Weight, IntType >::SubsetEqual::operator()(), TestBackoffAndCache(), TestCompose(), TestRemoveEpsLocalSpecial(), TestRemoveUselessArcs(), and TestShortestPath().

                                              {
  if (w1.Value1() == w2.Value1() && w1.Value2() == w2.Value2()) return true;  // handles Zero().
  return (fabs((w1.Value1() + w1.Value2()) - (w2.Value1() + w2.Value2())) <= delta);
}

ApproxEqual() [2/2]

bool fst::ApproxEqual ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2, float  delta = kDelta  )

inline

Definition at line 570 of file lattice-weight.h.

References ApproxEqual(), CompactLatticeWeightTpl< WeightType, IntType >::String(), and CompactLatticeWeightTpl< WeightType, IntType >::Weight().

                                              {
  return (ApproxEqual(w1.Weight(), w2.Weight(), delta) && w1.String() == w2.String());
}

CastOrConvertToVectorFst()

VectorFst< StdArc > * CastOrConvertToVectorFst

(

Fst< StdArc > *

fst

)

Definition at line 94 of file kaldi-fst-io.cc.

References KALDI_ASSERT.

Referenced by main().

                                                              {
  // This version currently supports ConstFst<StdArc> or VectorFst<StdArc>
  std::string real_type = fst->Type();
  KALDI_ASSERT(real_type == "vector" || real_type == "const");
  if (real_type == "vector") {
    return dynamic_cast<VectorFst<StdArc> *>(fst);
  } else {
    // As the 'fst' can't cast to VectorFst, we create a new
    // VectorFst<StdArc> initialized by 'fst', and delete 'fst'.
    VectorFst<StdArc> *new_fst = new VectorFst<StdArc>(*fst);
    delete fst;
    return new_fst;
  }
}

CheckPhones()

static float fst::CheckPhones ( const VectorFst< Arc > &  linear_fst, const vector< typename Arc::Label > &  phone_ids, const vector< typename Arc::Label > &  disambig_ids, const vector< typename Arc::Label > &  phone_seq, const vector< vector< typename Arc::Label > > &  ilabel_info, int  N, int  P  )

static

Definition at line 71 of file context-fst-test.cc.

References GetLinearSymbolSequence(), rnnlm::i, kaldi::IsSorted(), and rnnlm::j.

                                        {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  assert(kaldi::IsSorted(phone_ids));  // so we can do binary_search.


  vector<int32> input_syms;
  vector<int32> output_syms;
  Weight tot_cost;
  bool ans = GetLinearSymbolSequence(linear_fst,  &input_syms,
                                     &output_syms, &tot_cost);
  assert(ans);  // should be linear.

  vector<int32> phone_seq_check;
  for (size_t i = 0; i < output_syms.size(); i++)
    if (std::binary_search(phone_ids.begin(), phone_ids.end(), output_syms[i]))
      phone_seq_check.push_back(output_syms[i]);

  assert(phone_seq_check  == phone_seq);

  vector<vector<int32> > input_syms_long;
  for (size_t i = 0; i < input_syms.size(); i++) {
    Label isym = input_syms[i];
    if (ilabel_info[isym].size() == 0) continue;  // epsilon.
    if ( (ilabel_info[isym].size() == 1 &&
         ilabel_info[isym][0] <= 0) ) continue;  // disambig.
    input_syms_long.push_back(ilabel_info[isym]);
  }

  for (size_t i = 0; i < input_syms_long.size(); i++) {
    vector<int32> phone_context_window(N);  // phone at pos i will be at pos P in this window.
    int pos = ((int)i) - P;  // pos of first phone in window [ may be out of range] .
    for (int j = 0; j < N; j++, pos++) {
      if (static_cast<size_t>(pos) < phone_seq.size()) phone_context_window[j] = phone_seq[pos];
      else phone_context_window[j] = 0;  // 0 is a special symbol that context-dep-itf expects to see
      // when no phone is present due to out-of-window.  context-fst knows about this too.
    }
    assert(input_syms_long[i] == phone_context_window);
  }
  return tot_cost.Value();
}

ClearSymbols()

void ClearSymbols	(	bool	clear_input,
		bool	clear_output,
		MutableFst< Arc > *	fst
	)

ClearSymbols sets all the symbols on the input and/or output side of the FST to zero, as specified.

It does not alter the symbol tables.

Definition at line 742 of file fstext-utils-inl.h.

Referenced by MakeLoopFstCompare().

                                        {
  for (StateIterator<MutableFst<Arc> > siter(*fst);
       !siter.Done();
       siter.Next()) {
    typename Arc::StateId s = siter.Value();
    for (MutableArcIterator<MutableFst<Arc> > aiter(fst, s);
         !aiter.Done();
         aiter.Next()) {
      Arc arc = aiter.Value();
      bool change = false;
      if (clear_input && arc.ilabel != 0) {
        arc.ilabel = 0;
        change = true;
      }
      if (clear_output && arc.olabel != 0) {
        arc.olabel = 0;
        change = true;
      }
      if (change) {
        aiter.SetValue(arc);
      }
    }
  }
}

CompactLatticeHasAlignment()

bool CompactLatticeHasAlignment

(

const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > &

fst

)

Returns true if lattice has alignments, i.e.

it has any nonempty strings inside its weights.

Definition at line 244 of file lattice-utils-inl.h.

Referenced by LatticeScale().

                                                                            {
  typedef CompactLatticeWeightTpl<Weight, Int> W;
  typedef ArcTpl<W> Arc;
  typedef ExpandedFst<Arc> Fst;
  typedef typename Arc::StateId StateId;
  StateId num_states = fst.NumStates();
  for (StateId s = 0; s < num_states; s++) {
    for (ArcIterator<Fst> aiter(fst, s);
         !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (!arc.weight.String().empty()) return true;
    }
    W final_weight = fst.Final(s);
    if (!final_weight.String().empty()) return true;
  }
  return false;
}

CompactLatticeWeightTest()

void fst::CompactLatticeWeightTest

(

)

Definition at line 126 of file lattice-weight-test.cc.

References ApproxEqual(), Compare(), Divide(), rnnlm::i, KALDI_ASSERT, CompactLatticeWeightTpl< WeightType, IntType >::Member(), CompactLatticeWeightTpl< WeightType, IntType >::One(), Plus(), CompactLatticeWeightTpl< WeightType, IntType >::Quantize(), RandomCompactLatticeWeight(), CompactLatticeWeightTpl< WeightType, IntType >::Read(), Times(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by main().

                                {
  for(int32 i = 0; i < 100; i++) {
    CompactLatticeWeight l1 = RandomCompactLatticeWeight(), l2 = RandomCompactLatticeWeight();
    CompactLatticeWeight l3 = Plus(l1, l2);
    CompactLatticeWeight l4 = Times(l1, l2);

    KALDI_ASSERT(Plus(l3, l3) == l3);
    KALDI_ASSERT(Plus(l1, l2) == Plus(l2, l1)); // commutativity of plus
    KALDI_ASSERT(Plus(l3, CompactLatticeWeight::Zero()) == l3); // x + 0 = x
    KALDI_ASSERT(Times(l3, CompactLatticeWeight::One()) == l3); // x * 1 = x
    KALDI_ASSERT(Times(l3, CompactLatticeWeight::Zero()) == CompactLatticeWeight::Zero()); // x * 0 = 0
    NaturalLess<CompactLatticeWeight> nl;
    bool a = nl(l1, l2);
    bool b = (Plus(l1, l2) == l1 && l1 != l2);
    KALDI_ASSERT(a == b);

    KALDI_ASSERT(Compare(l1, Plus(l1, l2)) != 1); // so do not have l1 > l1 + l2
    CompactLatticeWeight l5 = RandomCompactLatticeWeight(), l6 = RandomCompactLatticeWeight();
    KALDI_ASSERT(Times(Plus(l1, l2), Plus(l5, l6)) ==
                 Plus(Times(l1, l5), Plus(Times(l1, l6),
                 Plus(Times(l2, l5), Times(l2, l6))))); // * distributes over +
    KALDI_ASSERT(l1.Member() && l2.Member() && l3.Member() && l4.Member()
                 && l5.Member() && l6.Member());
    if (l2 != CompactLatticeWeight::Zero())  {
      KALDI_ASSERT(ApproxEqual(Divide(Times(l1, l2), l2, DIVIDE_RIGHT), l1)); // (a*b) / b = a if b != 0
      KALDI_ASSERT(ApproxEqual(Divide(Times(l2, l1), l2, DIVIDE_LEFT), l1)); // (a*b) / b = a if b != 0
    }
    KALDI_ASSERT(ApproxEqual(l1, l1.Quantize()));

    std::ostringstream s1;
    s1 << l1;
    std::istringstream s2(s1.str());
    s2 >> l2;
    KALDI_ASSERT(ApproxEqual(l1, l2));
    std::cout << s1.str() << '\n';

    {
      std::ostringstream s1b;
      l1.Write(s1b);
      std::istringstream s2b(s1b.str());
      l3.Read(s2b);
      KALDI_ASSERT(l1 == l3);
    }

    CompactLatticeWeightCommonDivisor divisor;
    std::cout << "l5 = " << l5 << '\n';
    std::cout << "l6 = " << l6 << '\n';
    l1 = divisor(l5, l6);
    std::cout << "div = " << l1 << '\n';
    if (l1 != CompactLatticeWeight::Zero()) {
      l2 = Divide(l5, l1, DIVIDE_LEFT);
      l3 = Divide(l6, l1, DIVIDE_LEFT);
      std::cout << "l2 = " << l2 << '\n';
      std::cout << "l3 = " << l3 << '\n';
      l4 = divisor(l2, l3); // make sure l2 is now one.
      std::cout << "l4 = " << l4 << '\n';
      KALDI_ASSERT(ApproxEqual(l4, CompactLatticeWeight::One()));
    } else {
      KALDI_ASSERT(l5 == CompactLatticeWeight::Zero()
                   && l6 == CompactLatticeWeight::Zero());
    }
  }
}

Compare() [1/3]

int fst::Compare ( const LatticeWeightTpl< FloatType > &  w1, const LatticeWeightTpl< FloatType > &  w2  )

inline

Compare returns -1 if w1 < w2, +1 if w1 > w2, and 0 if w1 == w2.

Definition at line 294 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by CompactLatticeWeightTest(), Compare(), LatticeDeterminizerPruned< Weight, IntType >::Compare(), LatticeDeterminizer< Weight, IntType >::Compare(), PruneSpecialClass< Arc >::Done(), LatticeDeterminizerPruned< Weight, IntType >::EpsilonClosure(), LatticeDeterminizer< Weight, IntType >::EpsilonClosure(), LatticeWeightTest(), LatticeDeterminizer< Weight, IntType >::MakeSubsetUnique(), NaturalLess< LatticeWeightTpl< FloatType > >::operator()(), NaturalLess< LatticeWeightTpl< float > >::operator()(), NaturalLess< LatticeWeightTpl< double > >::operator()(), NaturalLess< CompactLatticeWeightTpl< LatticeWeightTpl< FloatType >, IntType > >::operator()(), NaturalLess< CompactLatticeWeightTpl< LatticeWeightTpl< float >, int32 > >::operator()(), NaturalLess< CompactLatticeWeightTpl< LatticeWeightTpl< double >, int32 > >::operator()(), PruneSpecialClass< Arc >::Task::operator<(), Plus(), LatticeDeterminizer< Weight, IntType >::ProcessFinal(), and PruneSpecialClass< Arc >::ProcessState().

                                                           {
  FloatType f1 = w1.Value1() + w1.Value2(),
      f2 = w2.Value1() + w2.Value2();
  if (f1 < f2) { return 1; } // having smaller cost means you're larger
  // in the semiring [higher probability]
  else if (f1 > f2) { return -1; }
  // mathematically we should be comparing (w1.value1_-w1.value2_ < w2.value1_-w2.value2_)
  // in the next line, but add w1.value1_+w1.value2_ = w2.value1_+w2.value2_ to both sides and
  // divide by two, and we get the simpler equivalent form w1.value1_ < w2.value1_.
  else if (w1.Value1() < w2.Value1()) { return 1; }
  else if (w1.Value1() > w2.Value1()) { return -1; }
  else { return 0; }
}

Compare() [2/3]

int fst::Compare ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2  )

inline

Definition at line 591 of file lattice-weight.h.

References Compare(), rnnlm::i, CompactLatticeWeightTpl< WeightType, IntType >::String(), and CompactLatticeWeightTpl< WeightType, IntType >::Weight().

                                                                           {
  int c1 = Compare(w1.Weight(), w2.Weight());
  if (c1 != 0) return c1;
  int l1 = w1.String().size(), l2 = w2.String().size();
  // Use opposite order on the string lengths, so that if the costs are the same,
  // the shorter string wins.
  if (l1 > l2) return -1;
  else if (l1 < l2) return 1;
  for(int i = 0; i < l1; i++) {
    if (w1.String()[i] < w2.String()[i]) return -1;
    else if (w1.String()[i] > w2.String()[i]) return 1;
  }
  return 0;
}

Compare() [3/3]

int fst::Compare ( const TropicalWeight &  w1, const TropicalWeight &  w2  )

inline

Definition at line 653 of file lattice-weight.h.

                                             {
  float f1 = w1.Value(), f2 = w2.Value();
  if (f1 == f2) return 0;
  else if (f1 > f2) return -1;
  else return 1;
}

ComposeContext() [1/2]

void fst::ComposeContext	(	const std::vector< int32 > &	disambig_syms,
		int32	context_width,
		int32	central_position,
		VectorFst< StdArc > *	ifst,
		VectorFst< StdArc > *	ofst,
		std::vector< std::vector< int32 > > *	ilabels_out,
		bool	project_ifst = false
	)

Used in the command-line tool fstcomposecontext.

It creates a context FST and composes it on the left with "ifst" to make "ofst". It outputs the label information to ilabels_out. "ifst" is mutable because we need to add the subsequential loop.

Parameters

[in]	disambig_syms	List of disambiguation symbols, e.g. the integer ids of #0, #1, #2 ... in the phones.txt.
[in]	context_width	Size of context window, e.g. 3 for triphone.
[in]	central_position	Central position in phonetic context window (zero-based index), e.g. 1 for triphone.
[in,out]	ifst	The FST we are composing with C (e.g. LG.fst), mustable because we need to add the subsequential loop to it.
[out]	ofst	Composed output FST (would be CLG.fst).
[out]	ilabels_out	Vector, indexed by ilabel of CLG.fst, providing information about the meaning of that ilabel; see "http://kaldi-asr.org/doc/tree_externals.html#tree_ilabel".
[in]	project_ifst	This is intended only to be set to true in the program 'fstmakecontextfst'... if true, it will project on the input after adding the subsequential loop to 'ifst', which allows us to reconstruct the context fst C.fst.

Definition at line 246 of file context-fst.cc.

References AddSubsequentialLoop(), ComposeDeterministicOnDemandInverse(), GetInputSymbols(), rnnlm::i, KALDI_ASSERT, and InverseContextFst::SwapIlabelInfo().

Referenced by main().

                                       {
  KALDI_ASSERT(ifst != NULL && ofst != NULL);
  KALDI_ASSERT(context_width > 0);
  KALDI_ASSERT(central_position >= 0);
  KALDI_ASSERT(central_position < context_width);

  vector<int32> disambig_syms(disambig_syms_in);
  std::sort(disambig_syms.begin(), disambig_syms.end());

  vector<int32> all_syms;
  GetInputSymbols(*ifst, false/*no eps*/, &all_syms);
  std::sort(all_syms.begin(), all_syms.end());
  vector<int32> phones;
  for (size_t i = 0; i < all_syms.size(); i++)
    if (!std::binary_search(disambig_syms.begin(),
                            disambig_syms.end(), all_syms[i]))
      phones.push_back(all_syms[i]);

  // Get subsequential symbol that does not clash with
  // any disambiguation symbol or symbol in the FST.
  int32 subseq_sym = 1;
  if (!all_syms.empty())
    subseq_sym = std::max(subseq_sym, all_syms.back() + 1);
  if (!disambig_syms.empty())
    subseq_sym = std::max(subseq_sym, disambig_syms.back() + 1);

  // if central_position == context_width-1, it's left-context, and no
  // subsequential symbol is needed.
  if (central_position != context_width-1) {
    AddSubsequentialLoop(subseq_sym, ifst);
    if (project_ifst) {
      fst::Project(ifst, fst::PROJECT_INPUT);
    }
  }

  InverseContextFst inv_c(subseq_sym, phones, disambig_syms,
                          context_width, central_position);

  // The following statement is equivalent to the following
  // (if FSTs had the '*' operator for composition):
  //   (*ofst) = inv(inv_c) * (*ifst)
  ComposeDeterministicOnDemandInverse(*ifst, &inv_c, ofst);

  inv_c.SwapIlabelInfo(ilabels_out);
}

ComposeContext() [2/2]

void fst::ComposeContext	(	const std::vector< int32 > &	disambig_syms,
		int32	context_width,
		int32	central_position,
		VectorFst< StdArc > *	ifst,
		VectorFst< StdArc > *	ofst,
		std::vector< std::vector< int32 > > *	ilabels_out,
		bool	project_ifst = false
	)

Used in the command-line tool fstcomposecontext.

It creates a context FST and composes it on the left with "ifst" to make "ofst". It outputs the label information to ilabels_out. "ifst" is mutable because we need to add the subsequential loop.

Parameters

[in]	disambig_syms	List of disambiguation symbols, e.g. the integer ids of #0, #1, #2 ... in the phones.txt.
[in]	context_width	Size of context window, e.g. 3 for triphone.
[in]	central_position	Central position in phonetic context window (zero-based index), e.g. 1 for triphone.
[in,out]	ifst	The FST we are composing with C (e.g. LG.fst), mustable because we need to add the subsequential loop to it.
[out]	ofst	Composed output FST (would be CLG.fst).
[out]	ilabels_out	Vector, indexed by ilabel of CLG.fst, providing information about the meaning of that ilabel; see "http://kaldi-asr.org/doc/tree_externals.html#tree_ilabel".
[in]	project_ifst	This is intended only to be set to true in the program 'fstmakecontextfst'... if true, it will project on the input after adding the subsequential loop to 'ifst', which allows us to reconstruct the context fst C.fst.

Definition at line 246 of file context-fst.cc.

References AddSubsequentialLoop(), ComposeDeterministicOnDemandInverse(), GetInputSymbols(), rnnlm::i, KALDI_ASSERT, and InverseContextFst::SwapIlabelInfo().

Referenced by main().

                                       {
  KALDI_ASSERT(ifst != NULL && ofst != NULL);
  KALDI_ASSERT(context_width > 0);
  KALDI_ASSERT(central_position >= 0);
  KALDI_ASSERT(central_position < context_width);

  vector<int32> disambig_syms(disambig_syms_in);
  std::sort(disambig_syms.begin(), disambig_syms.end());

  vector<int32> all_syms;
  GetInputSymbols(*ifst, false/*no eps*/, &all_syms);
  std::sort(all_syms.begin(), all_syms.end());
  vector<int32> phones;
  for (size_t i = 0; i < all_syms.size(); i++)
    if (!std::binary_search(disambig_syms.begin(),
                            disambig_syms.end(), all_syms[i]))
      phones.push_back(all_syms[i]);

  // Get subsequential symbol that does not clash with
  // any disambiguation symbol or symbol in the FST.
  int32 subseq_sym = 1;
  if (!all_syms.empty())
    subseq_sym = std::max(subseq_sym, all_syms.back() + 1);
  if (!disambig_syms.empty())
    subseq_sym = std::max(subseq_sym, disambig_syms.back() + 1);

  // if central_position == context_width-1, it's left-context, and no
  // subsequential symbol is needed.
  if (central_position != context_width-1) {
    AddSubsequentialLoop(subseq_sym, ifst);
    if (project_ifst) {
      fst::Project(ifst, fst::PROJECT_INPUT);
    }
  }

  InverseContextFst inv_c(subseq_sym, phones, disambig_syms,
                          context_width, central_position);

  // The following statement is equivalent to the following
  // (if FSTs had the '*' operator for composition):
  //   (*ofst) = inv(inv_c) * (*ifst)
  ComposeDeterministicOnDemandInverse(*ifst, &inv_c, ofst);

  inv_c.SwapIlabelInfo(ilabels_out);
}

ComposeContextLeftBiphone() [1/2]

void fst::ComposeContextLeftBiphone	(	int32	nonterm_phones_offset,
		const std::vector< int32 > &	disambig_syms,
		const VectorFst< StdArc > &	ifst,
		VectorFst< StdArc > *	ofst,
		std::vector< std::vector< int32 > > *	ilabels
	)

This is a variant of the function ComposeContext() which is to be used with our "grammar FST" framework (see The ContextFst object, i.e.

../doc/grammar.dox, for more details). This does not take the 'context_width' and 'central_position' arguments because they are assumed to be 2 and 1 respectively (meaning, left-biphone phonetic context).

This function creates a context FST and composes it on the left with "ifst" to make "ofst".

Parameters

[in]	nonterm_phones_offset	The integer id of the symbol #nonterm_bos in the phones.txt file. You can just set this to a large value (like 1 million) if you are not actually using nonterminals (e.g. for testing purposes).
[in]	disambig_syms	List of disambiguation symbols, e.g. the integer ids of #0, #1, #2 ... in the phones.txt.
[in,out]	ifst	The FST we are composing with C (e.g. LG.fst).
[out]	ofst	Composed output FST (would be CLG.fst).
[out]	ilabels	Vector, indexed by ilabel of CLG.fst, providing information about the meaning of that ilabel; see The ilabel_info object (http://kaldi-asr.org/doc/tree_externals.html#tree_ilabel) and also Special symbols in CLG.fst (http://kaldi-asr.org/doc/grammar#grammar_special_clg).

Definition at line 196 of file grammar-context-fst.cc.

References ComposeDeterministicOnDemandInverse(), GetInputSymbols(), rnnlm::i, and InverseLeftBiphoneContextFst::SwapIlabelInfo().

Referenced by GetEncodingMultiple(), and main().

                                           {

  vector<int32> disambig_syms(disambig_syms_in);
  std::sort(disambig_syms.begin(), disambig_syms.end());

  vector<int32> all_syms;
  GetInputSymbols(ifst, false/*no eps*/, &all_syms);
  std::sort(all_syms.begin(), all_syms.end());
  vector<int32> phones;
  for (size_t i = 0; i < all_syms.size(); i++)
    if (!std::binary_search(disambig_syms.begin(),
                            disambig_syms.end(), all_syms[i]) &&
        all_syms[i] < nonterm_phones_offset)
      phones.push_back(all_syms[i]);


  InverseLeftBiphoneContextFst inv_c(nonterm_phones_offset,
                                     phones, disambig_syms);

  // The following statement is equivalent to the following
  // (if FSTs had the '*' operator for composition):
  //   (*ofst) = inv(inv_c) * (*ifst)
  ComposeDeterministicOnDemandInverse(ifst, &inv_c, ofst);

  inv_c.SwapIlabelInfo(ilabels);
}

ComposeContextLeftBiphone() [2/2]

void fst::ComposeContextLeftBiphone	(	int32	nonterm_phones_offset,
		const std::vector< int32 > &	disambig_syms,
		const VectorFst< StdArc > &	ifst,
		VectorFst< StdArc > *	ofst,
		std::vector< std::vector< int32 > > *	ilabels
	)

This is a variant of the function ComposeContext() which is to be used with our "grammar FST" framework (see The ContextFst object, i.e.

../doc/grammar.dox, for more details). This does not take the 'context_width' and 'central_position' arguments because they are assumed to be 2 and 1 respectively (meaning, left-biphone phonetic context).

This function creates a context FST and composes it on the left with "ifst" to make "ofst".

Parameters

[in]	nonterm_phones_offset	The integer id of the symbol #nonterm_bos in the phones.txt file. You can just set this to a large value (like 1 million) if you are not actually using nonterminals (e.g. for testing purposes).
[in]	disambig_syms	List of disambiguation symbols, e.g. the integer ids of #0, #1, #2 ... in the phones.txt.
[in,out]	ifst	The FST we are composing with C (e.g. LG.fst).
[out]	ofst	Composed output FST (would be CLG.fst).
[out]	ilabels	Vector, indexed by ilabel of CLG.fst, providing information about the meaning of that ilabel; see The ilabel_info object (http://kaldi-asr.org/doc/tree_externals.html#tree_ilabel) and also Special symbols in CLG.fst (http://kaldi-asr.org/doc/grammar#grammar_special_clg).

Definition at line 196 of file grammar-context-fst.cc.

References ComposeDeterministicOnDemandInverse(), GetInputSymbols(), rnnlm::i, and InverseLeftBiphoneContextFst::SwapIlabelInfo().

Referenced by GetEncodingMultiple(), and main().

                                           {

  vector<int32> disambig_syms(disambig_syms_in);
  std::sort(disambig_syms.begin(), disambig_syms.end());

  vector<int32> all_syms;
  GetInputSymbols(ifst, false/*no eps*/, &all_syms);
  std::sort(all_syms.begin(), all_syms.end());
  vector<int32> phones;
  for (size_t i = 0; i < all_syms.size(); i++)
    if (!std::binary_search(disambig_syms.begin(),
                            disambig_syms.end(), all_syms[i]) &&
        all_syms[i] < nonterm_phones_offset)
      phones.push_back(all_syms[i]);


  InverseLeftBiphoneContextFst inv_c(nonterm_phones_offset,
                                     phones, disambig_syms);

  // The following statement is equivalent to the following
  // (if FSTs had the '*' operator for composition):
  //   (*ofst) = inv(inv_c) * (*ifst)
  ComposeDeterministicOnDemandInverse(ifst, &inv_c, ofst);

  inv_c.SwapIlabelInfo(ilabels);
}

ComputeStateInfo()

void ComputeStateInfo	(	const VectorFst< Arc > &	fst,
		std::vector< char > *	epsilon_info
	)

This function will set epsilon_info to have size equal to the NumStates() of the FST, containing a logical-or of the enum values kStateHasEpsilonArcsEntering, kStateHasNonEpsilonArcsEntering, kStateHasEpsilonArcsLeaving, and kStateHasNonEpsilonArcsLeaving.

The meaning should be obvious. Note: an epsilon arc is defined as an arc where ilabel == olabel == 0.

Definition at line 28 of file epsilon-property-inl.h.

References kStateHasEpsilonArcsEntering, kStateHasEpsilonArcsLeaving, kStateHasNonEpsilonArcsEntering, and kStateHasNonEpsilonArcsLeaving.

Referenced by kaldi::CreateFactorTransducer(), EnsureEpsilonProperty(), and TestEnsureEpsilonProperty().

                                                     {
  typedef typename Arc::StateId StateId;
  typedef VectorFst<Arc> Fst;
  epsilon_info->clear();
  epsilon_info->resize(fst.NumStates(), static_cast<char>(0));
  for (StateId s = 0; s < fst.NumStates(); s++) {
    for (ArcIterator<Fst> aiter(fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (arc.ilabel == 0 && arc.olabel == 0) {
        (*epsilon_info)[arc.nextstate] |= static_cast<char>(kStateHasEpsilonArcsEntering);
        (*epsilon_info)[s] |= static_cast<char>(kStateHasEpsilonArcsLeaving);
      } else {
        (*epsilon_info)[arc.nextstate] |= static_cast<char>(kStateHasNonEpsilonArcsEntering);
        (*epsilon_info)[s] |= static_cast<char>(kStateHasNonEpsilonArcsLeaving);
      }
    }
  }
}

ConvertFstToLattice()

void ConvertFstToLattice	(	const ExpandedFst< ArcTpl< TropicalWeight > > &	ifst,
		MutableFst< ArcTpl< LatticeWeightTpl< Real > > > *	ofst
	)

Converts TropicalWeight to LatticeWeight (puts all the weight on the first float in the lattice's pair).

Definition at line 266 of file lattice-utils-inl.h.

Referenced by ConvertLattice().

                                                        {
  int32 num_states_cache = 50000;
  fst::CacheOptions cache_opts(true, num_states_cache);
  fst::MapFstOptions mapfst_opts(cache_opts);
  StdToLatticeMapper<Real> mapper;
  MapFst<StdArc, ArcTpl<LatticeWeightTpl<Real> >,
         StdToLatticeMapper<Real> > map_fst(ifst, mapper, mapfst_opts);
  *ofst = map_fst;
}

ConvertLattice() [1/7]

void ConvertLattice	(	const ExpandedFst< ArcTpl< Weight > > &	ifst,
		MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > *	ofst,
		bool	invert = true
	)

Convert lattice from a normal FST to a CompactLattice FST.

This is a bit like converting to the Gallic semiring, except the semiring behaves in a different way (designed to take the best path). Note: the ilabels end up as the symbols on the arcs of the output acceptor, and the olabels go to the strings. To make it the other way around (useful for the speech-recognition application), set invert=true [the default].

Definition at line 33 of file lattice-utils-inl.h.

References Factor(), and KALDI_PARANOID_ASSERT.

Referenced by ConvertLattice(), kaldi::ConvertLatticeToUnweightedAcceptor(), kaldi::ConvertToCompactLattice(), kaldi::ConvertToLattice(), DiscriminativeExampleSplitter::CreateOutputLattice(), kaldi::DecodeUtteranceLatticeIncremental(), DiscriminativeExampleSplitter::DoExcise(), kaldi::nnet2::ExampleToPdfPost(), kaldi::GetDiagnosticsAndPrintOutput(), NnetDiscriminativeUpdater::LatticeComputations(), kaldi::LatticeToString(), main(), MinimumBayesRisk::MinimumBayesRisk(), DiscriminativeExampleSplitter::PrepareLattice(), kaldi::RandCompactLattice(), kaldi::SentenceLevelConfidence(), kaldi::TestCompactLatticeTableCross(), TestConvert2(), kaldi::TestLatticeTableCross(), kaldi::TestWordAlignedLattice(), and kaldi::TestWordAlignLatticeLexicon().

                 {
  typedef ArcTpl<Weight> Arc;
  typedef typename Arc::StateId StateId;
  typedef CompactLatticeWeightTpl<Weight, Int> CompactWeight;
  typedef ArcTpl<CompactWeight> CompactArc;

  VectorFst<ArcTpl<Weight> > ffst;
  std::vector<std::vector<Int> > labels;
  if (invert) // normal case: want the ilabels as sequences on the arcs of
    Factor(ifst, &ffst, &labels);  // the output... Factor makes seqs of
                                   // ilabels.
  else {
    VectorFst<ArcTpl<Weight> > invfst(ifst);
    Invert(&invfst);
    Factor(invfst, &ffst,  &labels);
  }

  TopSort(&ffst); // Put the states in ffst in topological order, which is
  // easier on the eye when reading the text-form lattices and corresponds to
  // what we get when we generate the lattices in the decoder.

  ofst->DeleteStates();

  // The states will be numbered exactly the same as the original FST.
  // Add the states to the new FST.
  StateId num_states = ffst.NumStates();
  for (StateId s = 0; s < num_states; s++) {
    StateId news = ofst->AddState();
    assert(news == s);
  }
  ofst->SetStart(ffst.Start());
  for (StateId s = 0; s < num_states; s++) {
    Weight final_weight = ffst.Final(s);
    if (final_weight != Weight::Zero()) {
      CompactWeight final_compact_weight(final_weight, std::vector<Int>());
      ofst->SetFinal(s, final_compact_weight);
    }
    for (ArcIterator<ExpandedFst<Arc> > iter(ffst, s);
         !iter.Done();
         iter.Next()) {
      const Arc &arc = iter.Value();
      KALDI_PARANOID_ASSERT(arc.weight != Weight::Zero());
      // note: zero-weight arcs not allowed anyway so weight should not be zero,
      // but no harm in checking.
      CompactArc compact_arc(arc.olabel, arc.olabel,
                             CompactWeight(arc.weight, labels[arc.ilabel]),
                             arc.nextstate);
      ofst->AddArc(s, compact_arc);
    }
  }
}

ConvertLattice() [2/7]

void fst::ConvertLattice	(	const ExpandedFst< ArcTpl< LatticeWeightTpl< float > > > &	ifst,
		MutableFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< double >, Int > > > *	ofst
	)

Definition at line 87 of file lattice-utils.h.

References ConvertLattice().

                                                                                                        {
  VectorFst<ArcTpl<CompactLatticeWeightTpl<LatticeWeightTpl<float>, Int> > > fst;
  ConvertLattice(ifst, &fst);
  ConvertLattice(fst, ofst);
}

ConvertLattice() [3/7]

void ConvertLattice	(	const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > &	ifst,
		MutableFst< ArcTpl< Weight > > *	ofst,
		bool	invert = true
	)

Convert lattice CompactLattice format to Lattice.

This is a bit like converting from the Gallic semiring. As for any CompactLattice, "ifst" must be an acceptor (i.e., ilabels and olabels should be identical). If invert=false, the labels on "ifst" become the ilabels on "ofst" and the strings in the weights of "ifst" becomes the olabels. If invert=true [default], this is reversed (useful for speech recognition lattices; our standard non-compact format has the words on the output side to match HCLG).

Definition at line 89 of file lattice-utils-inl.h.

References rnnlm::n, and kaldi::swap().

                 {
  typedef ArcTpl<Weight> Arc;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;
  typedef CompactLatticeWeightTpl<Weight, Int> CompactWeight;
  typedef ArcTpl<CompactWeight> CompactArc;
  ofst->DeleteStates();
  // make the states in the new FST have the same numbers as
  // the original ones, and add chains of states as necessary
  // to encode the string-valued weights.
  StateId num_states = ifst.NumStates();
  for (StateId s = 0; s < num_states; s++) {
    StateId news = ofst->AddState();
    assert(news == s);
  }
  ofst->SetStart(ifst.Start());
  for (StateId s = 0; s < num_states; s++) {
    CompactWeight final_weight = ifst.Final(s);
    if (final_weight != CompactWeight::Zero()) {
      StateId cur_state = s;
      size_t string_length = final_weight.String().size();
      for (size_t n = 0; n < string_length; n++) {
        StateId next_state = ofst->AddState();
        Label ilabel = 0;
        Arc arc(ilabel, final_weight.String()[n],
                (n == 0 ? final_weight.Weight() : Weight::One()),
                next_state);
        if (invert) std::swap(arc.ilabel, arc.olabel);
        ofst->AddArc(cur_state, arc);
        cur_state = next_state;
      }
      ofst->SetFinal(cur_state,
                     string_length > 0 ? Weight::One() : final_weight.Weight());
    }
    for (ArcIterator<ExpandedFst<CompactArc> > iter(ifst, s);
         !iter.Done();
         iter.Next()) {
      const CompactArc &arc = iter.Value();
      size_t string_length = arc.weight.String().size();
      StateId cur_state = s;
      // for all but the last element in the string--
      // add a temporary state.
      for (size_t n = 0 ; n+1 < string_length; n++) {
        StateId next_state = ofst->AddState();
        Label ilabel = (n == 0 ? arc.ilabel : 0),
            olabel = static_cast<Label>(arc.weight.String()[n]);
        Weight weight = (n == 0 ? arc.weight.Weight() : Weight::One());
        Arc new_arc(ilabel, olabel, weight, next_state);
        if (invert) std::swap(new_arc.ilabel, new_arc.olabel);
        ofst->AddArc(cur_state, new_arc);
        cur_state = next_state;
      }
      Label ilabel = (string_length <= 1 ? arc.ilabel : 0),
          olabel = (string_length > 0 ? arc.weight.String()[string_length-1] : 0);
      Weight weight = (string_length <= 1 ? arc.weight.Weight() : Weight::One());
      Arc new_arc(ilabel, olabel, weight, arc.nextstate);
      if (invert) std::swap(new_arc.ilabel, new_arc.olabel);
      ofst->AddArc(cur_state, new_arc);
    }
  }
}

ConvertLattice() [4/7]

void fst::ConvertLattice	(	const ExpandedFst< ArcTpl< LatticeWeightTpl< double > > > &	ifst,
		MutableFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< float >, Int > > > *	ofst
	)

Definition at line 96 of file lattice-utils.h.

References ConvertLattice().

                                                                                                       {
  VectorFst<ArcTpl<CompactLatticeWeightTpl<LatticeWeightTpl<double>, Int> > > fst;
  ConvertLattice(ifst, &fst);
  ConvertLattice(fst, ofst);
}

ConvertLattice() [5/7]

void fst::ConvertLattice	(	const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< double >, Int > > > &	ifst,
		MutableFst< ArcTpl< LatticeWeightTpl< float > > > *	ofst
	)

Converts CompactLattice with double to Lattice with float.

Definition at line 105 of file lattice-utils.h.

References ConvertLattice().

                                                                         {
  VectorFst<ArcTpl<CompactLatticeWeightTpl<LatticeWeightTpl<float>, Int> > > fst;
  ConvertLattice(ifst, &fst);
  ConvertLattice(fst, ofst);
}

ConvertLattice() [6/7]

void fst::ConvertLattice	(	const ExpandedFst< ArcTpl< CompactLatticeWeightTpl< LatticeWeightTpl< float >, Int > > > &	ifst,
		MutableFst< ArcTpl< LatticeWeightTpl< double > > > *	ofst
	)

Converts CompactLattice with float to Lattice with double.

Definition at line 114 of file lattice-utils.h.

References ConvertFstToLattice(), and ConvertLattice().

                                                                          {
  VectorFst<ArcTpl<CompactLatticeWeightTpl<LatticeWeightTpl<double>, Int> > > fst;
  ConvertLattice(ifst, &fst);
  ConvertLattice(fst, ofst);
}

ConvertLattice() [7/7]

void ConvertLattice	(	const ExpandedFst< ArcTpl< WeightIn > > &	ifst,
		MutableFst< ArcTpl< WeightOut > > *	ofst
	)

Convert between CompactLattices and Lattices of different floating point types...

this works between any pair of weight types for which ConvertLatticeWeight is defined (c.f. lattice-weight.h), and also includes conversion from LatticeWeight to TropicalWeight.

Definition at line 157 of file lattice-utils-inl.h.

References ConvertLatticeWeight(), and KALDI_PARANOID_ASSERT.

                                          {
  typedef ArcTpl<WeightIn> ArcIn;
  typedef ArcTpl<WeightOut> ArcOut;
  typedef typename ArcIn::StateId StateId;
  ofst->DeleteStates();
  // The states will be numbered exactly the same as the original FST.
  // Add the states to the new FST.
  StateId num_states = ifst.NumStates();
  for (StateId s = 0; s < num_states; s++) {
    StateId news = ofst->AddState();
    assert(news == s);
  }
  ofst->SetStart(ifst.Start());
  for (StateId s = 0; s < num_states; s++) {
    WeightIn final_iweight = ifst.Final(s);
    if (final_iweight != WeightIn::Zero()) {
      WeightOut final_oweight;
      ConvertLatticeWeight(final_iweight, &final_oweight);
      ofst->SetFinal(s, final_oweight);
    }
    for (ArcIterator<ExpandedFst<ArcIn> > iter(ifst, s);
         !iter.Done();
         iter.Next()) {
      ArcIn arc = iter.Value();
      KALDI_PARANOID_ASSERT(arc.weight != WeightIn::Zero());
      ArcOut oarc;
      ConvertLatticeWeight(arc.weight, &oarc.weight);
      oarc.ilabel = arc.ilabel;
      oarc.olabel = arc.olabel;
      oarc.nextstate = arc.nextstate;
      ofst->AddArc(s, oarc);
    }
  }
}

ConvertLatticeWeight() [1/3]

void fst::ConvertLatticeWeight ( const LatticeWeightTpl< Float1 > &  w_in, LatticeWeightTpl< Float2 > *  w_out  )

inline

Define some ConvertLatticeWeight functions that are used in various lattice conversions...

make them all templates, some with no arguments, since some must be templates.

Definition at line 819 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::SetValue1(), LatticeWeightTpl< FloatType >::SetValue2(), LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by ConvertLattice().

                                     {
  w_out->SetValue1(w_in.Value1());
  w_out->SetValue2(w_in.Value2());
}

ConvertLatticeWeight() [2/3]

void fst::ConvertLatticeWeight ( const CompactLatticeWeightTpl< LatticeWeightTpl< Float1 >, Int > &  w_in, CompactLatticeWeightTpl< LatticeWeightTpl< Float2 >, Int > *  w_out  )

inline

Definition at line 827 of file lattice-weight.h.

                                                                   {
  LatticeWeightTpl<Float2> weight2(w_in.Weight().Value1(),
                                   w_in.Weight().Value2());
  w_out->SetWeight(weight2);
  w_out->SetString(w_in.String());
}

ConvertLatticeWeight() [3/3]

void fst::ConvertLatticeWeight ( const LatticeWeightTpl< Float1 > &  w_in, TropicalWeightTpl< Float2 > *  w_out  )

inline

Definition at line 838 of file lattice-weight.h.

References Times(), LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

                                      {
  TropicalWeightTpl<Float2> w1(w_in.Value1());
  TropicalWeightTpl<Float2> w2(w_in.Value2());
  *w_out = Times(w1, w2);
}

ConvertNbestToVector()

void ConvertNbestToVector	(	const Fst< Arc > &	fst,
		std::vector< VectorFst< Arc > > *	fsts_out
	)

This function converts an FST with a special structure, which is output by the OpenFst functions ShortestPath and RandGen, and converts them into a std::vector of separate FSTs.

This special structure is that the only state that has more than one (arcs-out or final-prob) is the start state. fsts_out is resized to the appropriate size.

Definition at line 221 of file fstext-utils-inl.h.

References KALDI_ASSERT.

Referenced by main(), MinimizeEncoded(), NbestAsFsts(), and kaldi::TestWordAlignLatticeLexicon().

                                                                {
  typedef typename Arc::Weight Weight;
  typedef typename Arc::StateId StateId;
  fsts_out->clear();
  StateId start_state = fst.Start();
  if (start_state == kNoStateId) return; // No output.
  size_t n_arcs = fst.NumArcs(start_state);
  bool start_is_final = (fst.Final(start_state) != Weight::Zero());
  fsts_out->reserve(n_arcs + (start_is_final ? 1 : 0));

  if (start_is_final) {
    fsts_out->resize(fsts_out->size() + 1);
    StateId start_state_out = fsts_out->back().AddState();
    fsts_out->back().SetFinal(start_state_out, fst.Final(start_state));
  }

  for (ArcIterator<Fst<Arc> > start_aiter(fst, start_state);
       !start_aiter.Done();
       start_aiter.Next()) {
    fsts_out->resize(fsts_out->size() + 1);
    VectorFst<Arc> &ofst = fsts_out->back();
    const Arc &first_arc = start_aiter.Value();
    StateId cur_state = start_state,
        cur_ostate = ofst.AddState();
    ofst.SetStart(cur_ostate);
    StateId next_ostate = ofst.AddState();
    ofst.AddArc(cur_ostate, Arc(first_arc.ilabel, first_arc.olabel,
                                first_arc.weight, next_ostate));
    cur_state = first_arc.nextstate;
    cur_ostate = next_ostate;
    while (1) {
      size_t this_n_arcs = fst.NumArcs(cur_state);
      KALDI_ASSERT(this_n_arcs <= 1); // or it violates our assumptions
                                      // about the input.
      if (this_n_arcs == 1) {
        KALDI_ASSERT(fst.Final(cur_state) == Weight::Zero());
        // or problem with ShortestPath.
        ArcIterator<Fst<Arc> > aiter(fst, cur_state);
        const Arc &arc = aiter.Value();
        next_ostate = ofst.AddState();
        ofst.AddArc(cur_ostate, Arc(arc.ilabel, arc.olabel,
                                    arc.weight, next_ostate));
        cur_state = arc.nextstate;
        cur_ostate = next_ostate;
      } else {
        KALDI_ASSERT(fst.Final(cur_state) != Weight::Zero());
        // or problem with ShortestPath.
        ofst.SetFinal(cur_ostate, fst.Final(cur_state));
        break;
      }
    }
  }
}

ConvertToCost() [1/3]

double fst::ConvertToCost ( const LatticeWeightTpl< Float > &  w )

inline

Definition at line 847 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by LatticeIncrementalDeterminizer::AddArcToClat(), kaldi::CompactLatticeLimitDepth(), kaldi::CompactLatticeShortestPath(), PrunedCompactLatticeComposer::ComputeBackwardCosts(), LatticeDeterminizerPruned< Weight, IntType >::ComputeBackwardWeight(), PrunedCompactLatticeComposer::ComputeForwardCosts(), kaldi::ComputeLatticeAlphasAndBetas(), PrunedCompactLatticeComposer::ComputeLatticeStateInfo(), LatticeDeterminizerPruned< Weight, IntType >::InitialToStateId(), kaldi::LatticeForwardBackward(), kaldi::LatticeForwardBackwardMpeVariants(), main(), ArcPosteriorComputer::OutputPosteriors(), LatticeIncrementalDeterminizer::ProcessArcsFromChunkStartState(), LatticeDeterminizerPruned< Weight, IntType >::ProcessFinal(), PrunedCompactLatticeComposer::ProcessQueueElement(), PrunedCompactLatticeComposer::ProcessTransition(), LatticeDeterminizerPruned< Weight, IntType >::ProcessTransition(), LatticeDeterminizerPruned< Weight, IntType >::ProcessTransitions(), kaldi::PruneLattice(), and kaldi::SentenceLevelConfidence().

                                                              {
  return static_cast<double>(w.Value1()) + static_cast<double>(w.Value2());
}

ConvertToCost() [2/3]

double fst::ConvertToCost ( const CompactLatticeWeightTpl< LatticeWeightTpl< Float >, Int > &  w )

inline

Definition at line 852 of file lattice-weight.h.

                                                                                            {
  return static_cast<double>(w.Weight().Value1()) + static_cast<double>(w.Weight().Value2());
}

ConvertToCost() [3/3]

double fst::ConvertToCost ( const TropicalWeightTpl< Float > &  w )

inline

Definition at line 857 of file lattice-weight.h.

                                                               {
  return w.Value();
}

CopyToVectorFst()

void CopyToVectorFst	(	GrammarFst *	grammar_fst,
		VectorFst< StdArc > *	vector_fst
	)

This function copies a GrammarFst to a VectorFst (intended mostly for testing and comparison purposes).

GrammarFst doesn't actually inherit from class Fst, so we can't just construct an FST from the GrammarFst.

grammar_fst gets expanded by this call, and although we could make it a const reference (because the ArcIterator does actually use const_cast), we make it a non-const pointer to emphasize that this call does change grammar_fst.

Definition at line 988 of file grammar-fst.cc.

References ArcIterator< GrammarFst >::Done(), GrammarFst::Final(), GrammarFstArc::ilabel, ArcIterator< GrammarFst >::Next(), GrammarFstArc::nextstate, GrammarFstArc::olabel, GrammarFst::Start(), ArcIterator< GrammarFst >::Value(), and GrammarFstArc::weight.

Referenced by main().

                                                    {
  typedef GrammarFstArc::StateId GrammarStateId;  // int64
  typedef StdArc::StateId StdStateId;  // int
  typedef StdArc::Label Label;
  typedef StdArc::Weight Weight;

  std::vector<std::pair<GrammarStateId, StdStateId> > queue;
  std::unordered_map<GrammarStateId, StdStateId> state_map;

  vector_fst->DeleteStates();
  state_map[grammar_fst->Start()] = vector_fst->AddState();  // state 0.
  vector_fst->SetStart(0);

  queue.push_back(
      std::pair<GrammarStateId, StdStateId>(grammar_fst->Start(), 0));

  while (!queue.empty()) {
    std::pair<GrammarStateId, StdStateId> p = queue.back();
    queue.pop_back();
    GrammarStateId grammar_state = p.first;
    StdStateId std_state = p.second;
    vector_fst->SetFinal(std_state, grammar_fst->Final(grammar_state));
    ArcIterator<GrammarFst> aiter(*grammar_fst, grammar_state);
    for (; !aiter.Done(); aiter.Next()) {
      const GrammarFstArc &grammar_arc = aiter.Value();
      StdArc std_arc;
      std_arc.ilabel = grammar_arc.ilabel;
      std_arc.olabel = grammar_arc.olabel;
      std_arc.weight = grammar_arc.weight;
      GrammarStateId next_grammar_state = grammar_arc.nextstate;
      StdStateId next_std_state;
      std::unordered_map<GrammarStateId, StdStateId>::const_iterator
          state_iter = state_map.find(next_grammar_state);
      if (state_iter == state_map.end()) {
        next_std_state = vector_fst->AddState();
        state_map[next_grammar_state] = next_std_state;
        queue.push_back(std::pair<GrammarStateId, StdStateId>(
            next_grammar_state, next_std_state));
      } else {
        next_std_state = state_iter->second;
      }
      std_arc.nextstate = next_std_state;
      vector_fst->AddArc(std_state, std_arc);
    }
  }
}

CreateBackoffFst()

StdVectorFst* fst::CreateBackoffFst

(

)

Definition at line 64 of file deterministic-fst-test.cc.

Referenced by TestBackoffAndCache(), and TestCompose().

                                 {
  StdVectorFst *fst = new StdVectorFst();
  fst->AddState();   // state 0
  fst->SetStart(0);
  fst->AddArc(0, StdArc(10, 10, 0.0, 1));

  fst->AddState();    // state 1
  fst->AddArc(1, StdArc(12, 12, 0.0, 4));
  fst->AddArc(1, StdArc(0,0,  0.1,2));  // backoff from 1 to 2

  fst->AddState();    // state 2
  fst->AddArc(2, StdArc(13, 13, 0.2, 4));
  fst->AddArc(2, StdArc(0,0,  0.3,3));  // backoff from 2 to 3

  fst->AddState();     // state 3
  fst->AddArc(3, StdArc(14, 14, 0.4, 4));

  fst->AddState();    // state 4
  fst->AddArc(4, StdArc(15, 15, 0.5, 5));

  fst->AddState();     // state 5
  fst->SetFinal(5, 0.6);

  return fst;
}

CreateFactorFst()

void CreateFactorFst	(	const std::vector< std::vector< I > > &	sequences,
		MutableFst< Arc > *	fst
	)

The function CreateFactorFst will create an FST that expands out the "factors" that are the indices of the "sequences" array, into linear sequences of symbols.

There is a single start and end state (state 0), and for each nonzero index i into the array "sequences", there is an arc from state 0 that has output-label i, and enters a chain of states with output epsilons and input labels corresponding to the remaining elements of the sequences, terminating again in state 0. This FST is output-deterministic and sorted on olabel. Composing an FST on the left with the output of this function, should be the same as calling "ExpandInputSequences". Use TableCompose (see table-matcher.h) for efficiency.

Definition at line 250 of file factor-inl.h.

References rnnlm::i, and KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by Factor(), and TestFactor().

                                           {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;
  typedef typename Arc::Weight Weight;

  assert(fst != NULL);
  fst->DeleteStates();
  StateId loopstate = fst->AddState();
  assert(loopstate == 0);
  fst->SetStart(0);
  fst->SetFinal(0, Weight::One());
  if (sequences.size() != 0) assert(sequences[0].size() == 0);  // can't replace epsilon...

  for (Label olabel = 1; olabel < static_cast<Label>(sequences.size()); olabel++) {
    size_t len = sequences[olabel].size();
    if (len == 0) {
      Arc arc(0, olabel, Weight::One(), loopstate);
      fst->AddArc(loopstate, arc);
    } else {
      StateId curstate = loopstate;
      for (size_t i = 0; i < len; i++) {
        StateId nextstate = (i == len-1 ? loopstate : fst->AddState());
        Arc arc(sequences[olabel][i], (i == 0 ? olabel : 0), Weight::One(), nextstate);
        fst->AddArc(curstate, arc);
        curstate = nextstate;
      }
    }
  }
  fst->SetProperties(kOLabelSorted, kOLabelSorted);
}

CreateILabelInfoSymbolTable() [1/2]

SymbolTable* fst::CreateILabelInfoSymbolTable	(	const std::vector< std::vector< int32 > > &	ilabel_info,
		const SymbolTable &	phones_symtab,
		std::string	separator,
		std::string	disambig_prefix
	)

The following function is mainly of use for printing and debugging.

Definition at line 345 of file context-fst.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and KALDI_ERR.

Referenced by main().

                                                                     {  // e.g. separator = "/", initial-disambig="#-1"
  KALDI_ASSERT(!info.empty() && info[0].empty());
  SymbolTable *ans = new SymbolTable("ilabel-info-symtab");
  int64 s = ans->AddSymbol(phones_symtab.Find(static_cast<int64>(0)));
  assert(s == 0);
  for (size_t i = 1; i < info.size(); i++) {
    if (info[i].size() == 0) {
      KALDI_ERR << "Invalid ilabel-info";
    }
    if (info[i].size() == 1 &&
       info[i][0] <= 0) {
      if (info[i][0] == 0) {  // special symbol at start that we want to call #-1.
        s = ans->AddSymbol(initial_disambig);
        if (s != i) {
          KALDI_ERR << "Disambig symbol " << initial_disambig
                    << " already in vocab";
        }
      } else {
        std::string disambig_sym = phones_symtab.Find(-info[i][0]);
        if (disambig_sym == "") {
          KALDI_ERR << "Disambig symbol " << -info[i][0]
                    << " not in phone symbol-table";
        }
        s = ans->AddSymbol(disambig_sym);
        if (s != i) {
          KALDI_ERR << "Disambig symbol " << disambig_sym
                    << " already in vocab";
        }
      }
    } else {
      // is a phone-context-window.
      std::string newsym;
      for (size_t j = 0; j < info[i].size(); j++) {
        std::string phonesym = phones_symtab.Find(info[i][j]);
        if (phonesym == "") {
          KALDI_ERR << "Symbol " << info[i][j]
                    << " not in phone symbol-table";
        }
        if (j != 0) newsym += separator;
        newsym += phonesym;
      }
      int64 s = ans->AddSymbol(newsym);
      if (s != static_cast<int64>(i)) {
        KALDI_ERR << "Some problem with duplicate symbols";
      }
    }
  }
  return ans;
}

CreateILabelInfoSymbolTable() [2/2]

SymbolTable* fst::CreateILabelInfoSymbolTable	(	const vector< vector< int32 > > &	info,
		const SymbolTable &	phones_symtab,
		std::string	separator,
		std::string	initial_disambig
	)

The following function is mainly of use for printing and debugging.

Definition at line 345 of file context-fst.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and KALDI_ERR.

Referenced by main().

                                                                     {  // e.g. separator = "/", initial-disambig="#-1"
  KALDI_ASSERT(!info.empty() && info[0].empty());
  SymbolTable *ans = new SymbolTable("ilabel-info-symtab");
  int64 s = ans->AddSymbol(phones_symtab.Find(static_cast<int64>(0)));
  assert(s == 0);
  for (size_t i = 1; i < info.size(); i++) {
    if (info[i].size() == 0) {
      KALDI_ERR << "Invalid ilabel-info";
    }
    if (info[i].size() == 1 &&
       info[i][0] <= 0) {
      if (info[i][0] == 0) {  // special symbol at start that we want to call #-1.
        s = ans->AddSymbol(initial_disambig);
        if (s != i) {
          KALDI_ERR << "Disambig symbol " << initial_disambig
                    << " already in vocab";
        }
      } else {
        std::string disambig_sym = phones_symtab.Find(-info[i][0]);
        if (disambig_sym == "") {
          KALDI_ERR << "Disambig symbol " << -info[i][0]
                    << " not in phone symbol-table";
        }
        s = ans->AddSymbol(disambig_sym);
        if (s != i) {
          KALDI_ERR << "Disambig symbol " << disambig_sym
                    << " already in vocab";
        }
      }
    } else {
      // is a phone-context-window.
      std::string newsym;
      for (size_t j = 0; j < info[i].size(); j++) {
        std::string phonesym = phones_symtab.Find(info[i][j]);
        if (phonesym == "") {
          KALDI_ERR << "Symbol " << info[i][j]
                    << " not in phone symbol-table";
        }
        if (j != 0) newsym += separator;
        newsym += phonesym;
      }
      int64 s = ans->AddSymbol(newsym);
      if (s != static_cast<int64>(i)) {
        KALDI_ERR << "Some problem with duplicate symbols";
      }
    }
  }
  return ans;
}

CreateMapFst()

void CreateMapFst	(	const std::vector< I > &	symbol_map,
		MutableFst< Arc > *	fst
	)

CreateMapFst will create an FST representing this symbol_map.

The FST has a single loop state with single-arc loops with isymbol = symbol_map[i], osymbol = i. The resulting FST applies this map to the input symbols of something we compose with it on the right. Must have symbol_map[0] == 0.

Definition at line 285 of file factor-inl.h.

References KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by main().

                                        {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;
  typedef typename Arc::Weight Weight;

  assert(fst != NULL);
  fst->DeleteStates();
  StateId loopstate = fst->AddState();
  assert(loopstate == 0);
  fst->SetStart(0);
  fst->SetFinal(0, Weight::One());
  assert(symbol_map.empty() || symbol_map[0] == 0);  // FST cannot map epsilon to something else.
  for (Label olabel = 1; olabel < static_cast<Label>(symbol_map.size()); olabel++) {
    Arc arc(symbol_map[olabel], olabel, Weight::One(), loopstate);
    fst->AddArc(loopstate, arc);
  }
}

CreateNewSymbols()

void CreateNewSymbols	(	SymbolTable *	input_sym_table,
		int	nSym,
		std::string	prefix,
		std::vector< Label > *	symsOut
	)

Definition at line 581 of file pre-determinize-inl.h.

References rnnlm::i.

Referenced by TestAddSelfLoops().

                                                                                         {
  // Creates nSym new symbols named (prefix)0, (prefix)1 and so on.
  // Crashes if it cannot create them because one or more of them were in the symbol
  // table already.
  assert(symsOut && symsOut->size() == 0);
  for (int i = 0;i < nSym;i++) {
    std::stringstream ss; ss << prefix << i;
    std::string str = ss.str();
    if (input_sym_table->Find(str) != -1) {  // should not be present.
    }
    assert(symsOut);
    symsOut->push_back( (Label) input_sym_table->AddSymbol(str));
  }
}

CreateResultFst()

StdVectorFst* fst::CreateResultFst

(

)

Definition at line 91 of file deterministic-fst-test.cc.

Referenced by TestBackoffAndCache(), and TestCompose().

                                {
  StdVectorFst *fst = new StdVectorFst();
  fst->AddState();   // state 0
  fst->SetStart(0);
  fst->AddArc(0, StdArc(10, 10, 0.0, 1));

  fst->AddState();    // state 1
  fst->AddArc(1, StdArc(12, 12, 0.0, 4));
  fst->AddArc(1, StdArc(13,13,0.3,4));  // went through 1 backoff
  fst->AddArc(1, StdArc(14,14,0.8,4));  // went through 2 backoffs

  fst->AddState();    // state 2
  fst->AddState();    // state 3

  fst->AddState();    // state 4
  fst->AddArc(4, StdArc(15, 15, 0.5, 5));

  fst->AddState();     // state 5
  fst->SetFinal(5, 0.6);

  return fst;
}

CreateSuperFinal()

Arc::StateId CreateSuperFinal

(

MutableFst< Arc > *

fst

)

Definition at line 687 of file pre-determinize-inl.h.

Referenced by LatticeLexiconWordAligner::LatticeLexiconWordAligner(), LatticePhoneAligner::LatticePhoneAligner(), LatticeWordAligner::LatticeWordAligner(), main(), PreDeterminize(), and MinimumBayesRisk::PrepareLatticeAndInitStats().

                                                           {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  assert(fst != NULL);
  StateId num_states = fst->NumStates();
  StateId num_final = 0;
  std::vector<StateId> final_states;
  for (StateId s = 0; s < num_states; s++) {
    if (fst->Final(s) != Weight::Zero()) {
      num_final++;
      final_states.push_back(s);
    }
  }
  if (final_states.size() == 1) {
    if (fst->Final(final_states[0]) == Weight::One()) {
      ArcIterator<MutableFst<Arc> > iter(*fst, final_states[0]);
      if (iter.Done()) {
        // We already have a final state w/ no transitions out and unit weight.
        // So we're done.
        return final_states[0];
      }
    }
  }

  StateId final_state = fst->AddState();
  fst->SetFinal(final_state, Weight::One());
  for (size_t idx = 0; idx < final_states.size(); idx++) {
    StateId s = final_states[idx];
    Weight weight = fst->Final(s);
    fst->SetFinal(s, Weight::Zero());
    Arc arc;
    arc.ilabel = 0;
    arc.olabel = 0;
    arc.nextstate = final_state;
    arc.weight = weight;
    fst->AddArc(s, arc);
  }
  return final_state;
}

DefaultLatticeScale()

std::vector<std::vector<double> > fst::DefaultLatticeScale ( )

inline

Returns a default 2x2 matrix scaling factor for LatticeWeight.

Definition at line 130 of file lattice-utils.h.

Referenced by ScaleLattice(), and TestScalePair().

                                                           {
  std::vector<std::vector<double> > ans(2);
  ans[0].resize(2, 0.0);
  ans[1].resize(2, 0.0);
  ans[0][0] = ans[1][1] = 1.0;
  return ans;
}

DeleteISymbols()

int64 DeleteISymbols	(	MutableFst< Arc > *	fst,
		std::vector< typename Arc::Label >	isyms
	)

Definition at line 651 of file pre-determinize-inl.h.

References rnnlm::i.

Referenced by TestDeterminize(), TestMinimize(), and TestPreDeterminize().

                                                                               {

  // We could do this using the Mapper concept, but this is much easier to understand.

  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;

  int64 num_deleted = 0;

  if (isyms.size() == 0) return 0;
  Label  isyms_min = *std::min_element(isyms.begin(), isyms.end()),
         isyms_max = *std::max_element(isyms.begin(), isyms.end());
  bool isyms_consecutive = (isyms_max+1-isyms_min == static_cast<Label>(isyms.size()));
  std::set<Label> isyms_set;
  if (!isyms_consecutive)
    for (size_t i = 0;i < isyms.size();i++)
      isyms_set.insert(isyms[i]);

  for (StateIterator<MutableFst<Arc> > siter(*fst); ! siter.Done(); siter.Next()) {
    StateId state = siter.Value();
    for (MutableArcIterator<MutableFst<Arc> > aiter(fst, state); ! aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (arc.ilabel >= isyms_min && arc.ilabel <= isyms_max) {
        if (isyms_consecutive || isyms_set.count(arc.ilabel) != 0) {
          num_deleted++;
          Arc mod_arc (arc);
          mod_arc.ilabel = 0;  // change label to epsilon.
          aiter.SetValue(mod_arc);
        }
      }
    }
  }
  return num_deleted;
}

DeleteTestFst()

void fst::DeleteTestFst

(

StdVectorFst *

fst

)

Definition at line 114 of file deterministic-fst-test.cc.

                                      {
  delete fst;
}

DeterminizeInLog()

void fst::DeterminizeInLog ( VectorFst< StdArc > *  fst )

inline

Definition at line 388 of file fstext-utils-inl.h.

Referenced by main().

                                              {
  // DeterminizeInLog determinizes 'fst' in the log semiring.

  ArcSort(fst, ILabelCompare<StdArc>());  // helps DeterminizeStar to be faster.
  VectorFst<LogArc> *fst_log = new VectorFst<LogArc>;  // Want to determinize in log semiring.
  Cast(*fst, fst_log);
  VectorFst<StdArc> tmp;
  *fst = tmp;  // make fst empty to free up memory. [actually may make no difference..]
  VectorFst<LogArc> *fst_det_log = new VectorFst<LogArc>;
  Determinize(*fst_log, fst_det_log);
  Cast(*fst_det_log, fst);
  delete fst_log;
  delete fst_det_log;
}

DeterminizeLatticeDeletePhones()

template void fst::DeterminizeLatticeDeletePhones	(	ArcTpl< kaldi::LatticeWeight >::Label	first_phone_label,
		MutableFst< ArcTpl< kaldi::LatticeWeight > > *	fst
	)

DeterminizeLatticePhonePruned< kaldi::LatticeWeight, kaldi::int32 >() [1/2]

template bool fst::DeterminizeLatticePhonePruned< kaldi::LatticeWeight, kaldi::int32 >	(	const kaldi::TransitionModel &	trans_model,
		const ExpandedFst< kaldi::LatticeArc > &	ifst,
		double	prune,
		MutableFst< kaldi::CompactLatticeArc > *	ofst,
		DeterminizeLatticePhonePrunedOptions	opts
	)

DeterminizeLatticePhonePruned< kaldi::LatticeWeight, kaldi::int32 >() [2/2]

template bool fst::DeterminizeLatticePhonePruned< kaldi::LatticeWeight, kaldi::int32 >	(	const kaldi::TransitionModel &	trans_model,
		MutableFst< kaldi::LatticeArc > *	ifst,
		double	prune,
		MutableFst< kaldi::CompactLatticeArc > *	ofst,
		DeterminizeLatticePhonePrunedOptions	opts
	)

DeterminizeLatticePhonePrunedFirstPass()

bool fst::DeterminizeLatticePhonePrunedFirstPass	(	const kaldi::TransitionModel &	trans_model,
		double	beam,
		MutableFst< ArcTpl< Weight > > *	fst,
		const DeterminizeLatticePrunedOptions &	opts
	)

This function does a first pass determinization with phone symbols inserted at phone boundary.

It uses a transition model to work out the transition-id to phone map. First, phones will be inserted into the word level lattice. Second, determinization will be applied on top of the phone + word lattice. Finally, the inserted phones will be removed, converting the lattice back to a word level lattice. The output lattice of this pass is not deterministic, since we remove the phone symbols as a last step. It is supposed to be followed by another pass of determinization at the word level. It could also be useful for some other applications such as fMLLR estimation, confidence estimation, discriminative training, etc.

Definition at line 1393 of file determinize-lattice-pruned.cc.

References DeterminizeLatticeDeletePhones(), and DeterminizeLatticeInsertPhones().

                                                 {
  // First, insert the phones.
  typename ArcTpl<Weight>::Label first_phone_label =
      DeterminizeLatticeInsertPhones(trans_model, fst);
  TopSort(fst);

  // Second, do determinization with phone inserted.
  bool ans = DeterminizeLatticePruned<Weight>(*fst, beam, fst, opts);

  // Finally, remove the inserted phones.
  DeterminizeLatticeDeletePhones(first_phone_label, fst);
  TopSort(fst);

  return ans;
}

DeterminizeLatticePruned< kaldi::LatticeWeight >() [1/2]

template bool fst::DeterminizeLatticePruned< kaldi::LatticeWeight >	(	const ExpandedFst< kaldi::LatticeArc > &	ifst,
		double	prune,
		MutableFst< kaldi::CompactLatticeArc > *	ofst,
		DeterminizeLatticePrunedOptions	opts
	)

DeterminizeLatticePruned< kaldi::LatticeWeight >() [2/2]

template bool fst::DeterminizeLatticePruned< kaldi::LatticeWeight >	(	const ExpandedFst< kaldi::LatticeArc > &	ifst,
		double	prune,
		MutableFst< kaldi::LatticeArc > *	ofst,
		DeterminizeLatticePrunedOptions	opts
	)

DeterminizeStarInLog()

void DeterminizeStarInLog ( VectorFst< StdArc > *  fst, float  delta, bool *  debug_ptr, int  max_states  )

inline

Definition at line 371 of file fstext-utils-inl.h.

References DeterminizeStar().

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), and main().

                                                                                                {
  // DeterminizeStarInLog determinizes 'fst' in the log semiring, using
  // the DeterminizeStar algorithm (which also removes epsilons).

  ArcSort(fst, ILabelCompare<StdArc>());  // helps DeterminizeStar to be faster.
  VectorFst<LogArc> *fst_log = new VectorFst<LogArc>;  // Want to determinize in log semiring.
  Cast(*fst, fst_log);
  VectorFst<StdArc> tmp;
  *fst = tmp;  // make fst empty to free up memory. [actually may make no difference..]
  VectorFst<LogArc> *fst_det_log = new VectorFst<LogArc>;
  DeterminizeStar(*fst_log, fst_det_log, delta, debug_ptr, max_states);
  Cast(*fst_det_log, fst);
  delete fst_log;
  delete fst_det_log;
}

Divide() [1/5]

ArcticWeightTpl<T> fst::Divide ( const ArcticWeightTpl< T > &  w1, const ArcticWeightTpl< T > &  w2, DivideType  typ = DIVIDE_ANY  )

inline

Definition at line 125 of file arctic-weight.h.

                                                                {
  T f1 = w1.Value(), f2 = w2.Value();
  if (f2 == -std::numeric_limits<T>::infinity())
    return std::numeric_limits<T>::quiet_NaN();
  else if (f1 == -std::numeric_limits<T>::infinity())
    return -std::numeric_limits<T>::infinity();
  else
    return ArcticWeightTpl<T>(f1 - f2);
}

Divide() [2/5]

ArcticWeightTpl<float> fst::Divide ( const ArcticWeightTpl< float > &  w1, const ArcticWeightTpl< float > &  w2, DivideType  typ = DIVIDE_ANY  )

inline

Definition at line 137 of file arctic-weight.h.

                                                                    {
  return Divide<float>(w1, w2, typ);
}

Divide() [3/5]

ArcticWeightTpl<double> fst::Divide ( const ArcticWeightTpl< double > &  w1, const ArcticWeightTpl< double > &  w2, DivideType  typ = DIVIDE_ANY  )

inline

Definition at line 143 of file arctic-weight.h.

                                                                     {
  return Divide<double>(w1, w2, typ);
}

Divide() [4/5]

LatticeWeightTpl<FloatType> fst::Divide ( const LatticeWeightTpl< FloatType > &  w1, const LatticeWeightTpl< FloatType > &  w2, DivideType  typ = DIVIDE_ANY  )

inline

Definition at line 370 of file lattice-weight.h.

References KALDI_WARN, LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), and LatticeWeightTpl< FloatType >::Zero().

Referenced by CompactLatticeWeightTest(), Divide(), LatticeWeightTest(), LatticeDeterminizerPruned< Weight, IntType >::NormalizeSubset(), LatticeDeterminizer< Weight, IntType >::NormalizeSubset(), DeterminizerStar< F >::ProcessTransition(), PushCompactLatticeWeights(), RemoveEpsLocalClass< Arc, ReweightPlus >::RemoveEpsPattern1(), RemoveEpsLocalClass< Arc, ReweightPlus >::Reweight(), and TestRemoveEpsLocalSpecial().

                                                                       {
  typedef FloatType T;
  T a = w1.Value1() - w2.Value1(), b = w1.Value2() - w2.Value2();
  if (a != a || b != b || a == -std::numeric_limits<T>::infinity()
     || b == -std::numeric_limits<T>::infinity()) {
    KALDI_WARN << "LatticeWeightTpl::Divide, NaN or invalid number produced. "
               << "[dividing by zero?]  Returning zero";
    return LatticeWeightTpl<T>::Zero();
  }
  if (a == std::numeric_limits<T>::infinity() ||
     b == std::numeric_limits<T>::infinity())
    return LatticeWeightTpl<T>::Zero(); // not a valid number if only one is infinite.
  return LatticeWeightTpl<T>(a, b);
}

Divide() [5/5]

CompactLatticeWeightTpl<WeightType, IntType> fst::Divide ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2, DivideType  div = DIVIDE_ANY  )

inline

Definition at line 689 of file lattice-weight.h.

References Divide(), KALDI_ERR, CompactLatticeWeightTpl< WeightType, IntType >::String(), CompactLatticeWeightTpl< WeightType, IntType >::Weight(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

                                                                                       {
  if (w1.Weight() == WeightType::Zero()) {
    if (w2.Weight() != WeightType::Zero()) {
      return CompactLatticeWeightTpl<WeightType, IntType>::Zero();
    } else {
      KALDI_ERR << "Division by zero [0/0]";
    }
  } else if (w2.Weight() == WeightType::Zero()) {
    KALDI_ERR << "Error: division by zero";
  }
  WeightType w = Divide(w1.Weight(), w2.Weight());

  const std::vector<IntType> v1 = w1.String(), v2 = w2.String();
  if (v2.size() > v1.size()) {
    KALDI_ERR << "Cannot divide, length mismatch";
  }
  typename std::vector<IntType>::const_iterator v1b = v1.begin(),
      v1e = v1.end(), v2b = v2.begin(), v2e = v2.end();
  if (div == DIVIDE_LEFT) {
    if (!std::equal(v2b, v2e, v1b)) { // v2 must be identical to first part of v1.
      KALDI_ERR << "Cannot divide, data mismatch";
    }
    return CompactLatticeWeightTpl<WeightType, IntType>(
        w, std::vector<IntType>(v1b+(v2e-v2b), v1e)); // return last part of v1.
  } else if (div == DIVIDE_RIGHT) {
    if (!std::equal(v2b, v2e, v1e-(v2e-v2b))) { // v2 must be identical to last part of v1.
      KALDI_ERR << "Cannot divide, data mismatch";
    }
    return CompactLatticeWeightTpl<WeightType, IntType>(
        w, std::vector<IntType>(v1b, v1e-(v2e-v2b))); // return first part of v1.

  } else {
    KALDI_ERR << "Cannot divide CompactLatticeWeightTpl with DIVIDE_ANY";
  }
  return CompactLatticeWeightTpl<WeightType,IntType>::Zero(); // keep compiler happy.
}

EnsureEpsilonProperty()

void EnsureEpsilonProperty

(

VectorFst< Arc > *

fst

)

This function modifies the fst (while maintaining equivalence) in such a way that, after the modification, all states of the FST which have epsilon-arcs entering them, have no non-epsilon arcs entering them, and all states which have epsilon-arcs leaving them, have no non-epsilon arcs leaving them.

It does this by creating extra states and adding extra epsilon transitions. An epsilon arc is defined as an arc where both the ilabel and the olabel are epsilons. This function may fail with KALDI_ASSERT for certain cyclic FSTs, but is safe in the acyclic case.

new_state_vec is for those states that have both epsilon and non-epsilon arcs entering. For these states, we'll create a new state for the non-epsilon arcs to enter and put it in this array, and we'll put an epsilon transition from the new state to the old state.

First modify arcs to point to states in new_state_vec when necessary.

Now handle the situation where states have both epsilon and non-epsilon arcs leaving.

Definition at line 49 of file epsilon-property-inl.h.

References ComputeStateInfo(), kStateHasEpsilonArcsEntering, kStateHasEpsilonArcsLeaving, kStateHasNonEpsilonArcsEntering, and kStateHasNonEpsilonArcsLeaving.

Referenced by main(), and TestEnsureEpsilonProperty().

                                                {

  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  typedef VectorFst<Arc> Fst;
  std::vector<char> epsilon_info;
  ComputeStateInfo(*fst, &epsilon_info);


  StateId num_states_old = fst->NumStates();
  StateId non_coaccessible_state = fst->AddState();

  std::vector<StateId> new_state_vec(num_states_old, kNoStateId);
  for (StateId s = 0; s < num_states_old; s++) {
    if ((epsilon_info[s] & kStateHasEpsilonArcsEntering) != 0 &&
        (epsilon_info[s] & kStateHasNonEpsilonArcsEntering) != 0) {
      assert(s != fst->Start()); // a type of cyclic FST we can't handle
                                 // easily.
      StateId new_state = fst->AddState();
      new_state_vec[s] = new_state;
      fst->AddArc(new_state, Arc(0, 0, Weight::One(), s));
    }
  }

  for (StateId s = 0; s < num_states_old; s++) {
    for (MutableArcIterator<Fst> aiter(fst, s);
         !aiter.Done(); aiter.Next()) {
      Arc arc = aiter.Value();
      if (arc.ilabel != 0 || arc.olabel != 0) { // non-epsilon arc
        StateId replacement_state;
        if (arc.nextstate >= 0 && arc.nextstate < num_states_old &&
            (replacement_state = new_state_vec[arc.nextstate]) !=
             kNoStateId) {
          arc.nextstate = replacement_state;
          aiter.SetValue(arc);
        }
      }
    }
  }

  for (StateId s = 0; s < num_states_old; s++) {
    if ((epsilon_info[s] & kStateHasEpsilonArcsLeaving) != 0 &&
        (epsilon_info[s] & kStateHasNonEpsilonArcsLeaving) != 0) {
      // state has non-epsilon and epsilon arcs leaving.
      // create a new state and move the non-epsilon arcs to leave
      // from there instead.
      StateId new_state = fst->AddState();
      for (MutableArcIterator<Fst> aiter(fst, s); !aiter.Done();
           aiter.Next()) {
        Arc arc = aiter.Value();
        if (arc.ilabel != 0 || arc.olabel != 0) { // non-epsilon arc.
          assert(arc.nextstate != s); // we don't handle cyclic FSTs.
          // move this arc to leave from the new state:
          fst->AddArc(new_state, arc); 
          arc.nextstate = non_coaccessible_state;
          aiter.SetValue(arc); // invalidate the arc, Connect() will remove it.
        }
      }
      // Create an epsilon arc to the new state.
      fst->AddArc(s, Arc(0, 0, Weight::One(), new_state));
    }
  }
  Connect(fst); // Removes arcs to the non-coaccessible state.
}

EqualAlign()

bool EqualAlign	(	const Fst< Arc > &	ifst,
		typename Arc::StateId	length,
		int	rand_seed,
		MutableFst< Arc > *	ofst,
		int	num_retries = 10
	)

EqualAlign is similar to RandGen, but it generates a sequence with exactly "length" input symbols.

It returns true on success, false on failure (failure is partly random but should never happen in practice for normal speech models.) It generates a random path through the input FST, finds out which subset of the states it visits along the way have self-loops with inupt symbols on them, and outputs a path with exactly enough self-loops to have the requested number of input symbols. Note that EqualAlign does not use the probabilities on the FST. It just uses equal probabilities in the first stage of selection (since the output will anyway not be a truly random sample from the FST). The input fst "ifst" must be connected or this may enter an infinite loop.

Definition at line 803 of file fstext-utils-inl.h.

References FindSelfLoopWithILabel(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_WARN, and kaldi::RandInt().

Referenced by main(), MinimizeEncoded(), and TestEqualAlign().

                                 {
  srand(rand_seed);
  KALDI_ASSERT(ofst->NumStates() == 0);  // make sure ofst empty.
  // make sure all states can reach final-state (or this algorithm may enter
  // infinite loop.
  KALDI_ASSERT(ifst.Properties(kCoAccessible, true) == kCoAccessible);

  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  if (ifst.Start() == kNoStateId) {
    KALDI_WARN << "Empty input fst.";
    return false;
  }
  // First select path through ifst.
  std::vector<StateId> path;
  std::vector<size_t> arc_offsets;  // arc taken out of each state.
  std::vector<int> nof_ilabels;

  StateId num_ilabels = 0;
  int retry_no = 0;

  // Under normal circumstances, this will be one-pass-only process
  // Multiple tries might be needed in special cases, typically when
  // the number of frames is close to number of transitions from
  // the start node to the final node. It usually happens for really
  // short utterances
  do {
    num_ilabels = 0;
    arc_offsets.clear();
    path.clear();
    path.push_back(ifst.Start());

    while (1) {
      // Select either an arc or final-prob.
      StateId s = path.back();
      size_t num_arcs = ifst.NumArcs(s);
      size_t num_arcs_tot = num_arcs;
      if (ifst.Final(s) != Weight::Zero()) num_arcs_tot++;
      // kaldi::RandInt is a bit like Rand(), but gets around situations
      // where RAND_MAX is very small.
      // Change this to Rand() % num_arcs_tot if compile issues arise
      size_t arc_offset = static_cast<size_t>(kaldi::RandInt(0, num_arcs_tot-1));

      if (arc_offset < num_arcs) {  // an actual arc.
        ArcIterator<Fst<Arc> > aiter(ifst, s);
        aiter.Seek(arc_offset);
        const Arc &arc = aiter.Value();
        if (arc.nextstate == s) {
          continue;  // don't take this self-loop arc
        } else {
          arc_offsets.push_back(arc_offset);
          path.push_back(arc.nextstate);
          if (arc.ilabel != 0) num_ilabels++;
        }
      } else {
        break;  // Chose final-prob.
      }
    }

    nof_ilabels.push_back(num_ilabels);
  } while (( ++retry_no < num_retries) && (num_ilabels > length));

  if (num_ilabels > length) {
    std::stringstream ilabel_vec;
    std::copy(nof_ilabels.begin(), nof_ilabels.end(),
          std::ostream_iterator<int>(ilabel_vec, ","));
    std::string s = ilabel_vec.str();
    s.erase(s.end() - 1);
    KALDI_WARN << "EqualAlign: the randomly constructed paths lengths: " << s;
    KALDI_WARN << "EqualAlign: utterance has too few frames " << length
               << " to align.";
    return false;  // can't make it shorter by adding self-loops!.
  }

  StateId num_self_loops = 0;
  std::vector<ssize_t> self_loop_offsets(path.size());
  for (size_t i = 0; i < path.size(); i++)
    if ( (self_loop_offsets[i] = FindSelfLoopWithILabel(ifst, path[i]))
         != static_cast<ssize_t>(-1) )
      num_self_loops++;

  if (num_self_loops == 0
      && num_ilabels < length) {
    KALDI_WARN << "No self-loops on chosen path; cannot match length.";
    return false;  // no self-loops to make it longer.
  }

  StateId num_extra = length - num_ilabels;  // Number of self-loops we need.

  StateId min_num_loops = 0;
  if (num_extra != 0) min_num_loops = num_extra / num_self_loops;  // prevent div by zero.
  StateId num_with_one_more_loop = num_extra - (min_num_loops*num_self_loops);
  KALDI_ASSERT(num_with_one_more_loop < num_self_loops || num_self_loops == 0);

  ofst->AddState();
  ofst->SetStart(0);
  StateId cur_state = 0;
  StateId counter = 0;  // tell us when we should stop adding one more loop.
  for (size_t i = 0; i < path.size(); i++) {
    // First, add any self-loops that are necessary.
    StateId num_loops = 0;
    if (self_loop_offsets[i] != static_cast<ssize_t>(-1)) {
      num_loops = min_num_loops + (counter < num_with_one_more_loop ? 1 : 0);
      counter++;
    }
    for (StateId j = 0; j < num_loops; j++) {
      ArcIterator<Fst<Arc> > aiter(ifst, path[i]);
      aiter.Seek(self_loop_offsets[i]);
      Arc arc = aiter.Value();
      KALDI_ASSERT(arc.nextstate == path[i]
             && arc.ilabel != 0);  // make sure self-loop with ilabel.
      StateId next_state = ofst->AddState();
      ofst->AddArc(cur_state, Arc(arc.ilabel, arc.olabel, arc.weight, next_state));
      cur_state = next_state;
    }
    if (i+1 < path.size()) {  // add forward transition.
      ArcIterator<Fst<Arc> > aiter(ifst, path[i]);
      aiter.Seek(arc_offsets[i]);
      Arc arc = aiter.Value();
      KALDI_ASSERT(arc.nextstate == path[i+1]);
      StateId next_state = ofst->AddState();
      ofst->AddArc(cur_state, Arc(arc.ilabel, arc.olabel, arc.weight, next_state));
      cur_state = next_state;
    } else {  // add final-prob.
      Weight weight = ifst.Final(path[i]);
      KALDI_ASSERT(weight != Weight::Zero());
      ofst->SetFinal(cur_state, weight);
    }
  }
  return true;
}

ExpandInputSequences()

void ExpandInputSequences	(	const std::vector< std::vector< I > > &	sequences,
		MutableFst< Arc > *	fst
	)

ExpandInputSequences expands out the input symbols into sequences of input symbols.

It creates linear chains of states for each arc that had >1 augmented symbol on it. It also sets the input symbol table to NULL, since in case you did have a symbol table there it would no longer be valid. It leaves any weight and output symbols on the first arc of the chain.

Definition at line 163 of file factor-inl.h.

References KALDI_ASSERT_IS_INTEGER_TYPE, and rnnlm::n.

Referenced by TestFactor().

                                                {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;
  typedef typename Arc::Weight Weight;
  fst->SetInputSymbols(NULL);
  size_t size = sequences.size();
  if (sequences.size() > 0) assert(sequences[0].size() == 0);  // should be eps.
  StateId num_states_at_start = fst->NumStates();
  for (StateId s = 0; s < num_states_at_start; s++) {
    StateId num_arcs = fst->NumArcs(s);
    for (StateId aidx = 0; aidx < num_arcs; aidx++) {
      ArcIterator<MutableFst<Arc> > aiter(*fst, s);
      aiter.Seek(aidx);
      Arc arc = aiter.Value();

      Label ilabel = arc.ilabel;
      Label dest_state = arc.nextstate;
      if (ilabel != 0) {  // non-eps [nothing to do if eps]...
        assert(ilabel < static_cast<Label>(size));
        size_t len = sequences[ilabel].size();
        if (len <= 1) {
          if (len == 0) arc.ilabel = 0;
          else arc.ilabel = sequences[ilabel][0];
          MutableArcIterator<MutableFst<Arc> > mut_aiter(fst, s);
          mut_aiter.Seek(aidx);
          mut_aiter.SetValue(arc);
        } else {  // len>=2.  Must create new states...
          StateId curstate = -1;  // keep compiler happy: this value never used.
          for (size_t n = 0; n < len; n++) {  // adding/modifying "len" arcs.
            StateId nextstate;
            if (n < len-1) {
              nextstate = fst->AddState();
              assert(nextstate >= num_states_at_start);
            } else nextstate = dest_state;  // going back to original arc's
            // destination.
            if (n == 0) {
              arc.ilabel = sequences[ilabel][0];
              arc.nextstate = nextstate;
              MutableArcIterator<MutableFst<Arc> > mut_aiter(fst, s);
              mut_aiter.Seek(aidx);
              mut_aiter.SetValue(arc);
            } else {
              arc.ilabel = sequences[ilabel][n];
              arc.olabel = 0;
              arc.weight = Weight::One();
              arc.nextstate = nextstate;
              fst->AddArc(curstate, arc);
            }
            curstate = nextstate;
          }
        }
      }
    }
  }
}

Factor() [1/2]

void Factor	(	const Fst< Arc > &	fst,
		MutableFst< Arc > *	ofst,
		std::vector< std::vector< I > > *	symbols
	)

Factor identifies linear chains of states with an olabel (if any) only on the first arc of the chain, and possibly a sequence of ilabels; it outputs an FST with different symbols on the input that represent sequences of the original input symbols; it outputs the mapping from the new symbol to sequences of original symbols, as "symbols" [zero is reserved for epsilon].

As a side effect it also sorts the FST in depth-first order. Factor will usually do the best job when the olabels have been pushed to the left, i.e. if you make a call like

Push<Arc, REWEIGHT_TO_INITIAL>(fsta, &fstb, kPushLabels);

This is because it only creates a chain with olabels on the first arc of the chain (or a chain with no olabels). [it's possible to construct cases where pushing makes things worse, though]. After Factor, the composition of *ofst with the result of calling CreateFactorFst(*symbols) should be equivalent to fst. Alternatively, calling ExpandInputSequences with ofst and *symbols would produce something equivalent to fst.

Definition at line 69 of file factor-inl.h.

References GetStateProperties(), rnnlm::i, KALDI_ASSERT_IS_INTEGER_TYPE, kStateArcsIn, kStateArcsOut, kStateIlabelsOut, and Times().

Referenced by ConvertLattice(), Factor(), and TestFactor().

                                                      {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;
  typedef typename Arc::Weight Weight;
  assert(symbols_out != NULL);
  ofst->DeleteStates();
  if (fst.Start() < 0) return;  // empty FST.
  std::vector<StateId> order;
  DfsOrderVisitor<Arc> dfs_order_visitor(&order);
  DfsVisit(fst, &dfs_order_visitor);
  assert(order.size() > 0);
  StateId max_state = *(std::max_element(order.begin(), order.end()));
  std::vector<StatePropertiesType> state_properties;
  GetStateProperties(fst, max_state, &state_properties);

  std::vector<bool> remove(max_state+1);  // if true, will remove this state.

  // Now identify states that will be removed (made the middle of a chain).
  // The basic rule is that if the FstStateProperties equals
  // (kStateArcsIn|kStateArcsOut) or (kStateArcsIn|kStateArcsOut|kStateIlabelsOut),
  // then it is in the middle of a chain.  This eliminates state with
  // multiple input or output arcs, final states, and states with arcs out
  // that have olabels [we assume these are pushed to the left, so occur on the
  // 1st arc of a chain.

  for (StateId i = 0; i <= max_state; i++)
    remove[i] = (state_properties[i] == (kStateArcsIn|kStateArcsOut)
                 || state_properties[i] == (kStateArcsIn|kStateArcsOut|kStateIlabelsOut));
  std::vector<StateId> state_mapping(max_state+1, kNoStateId);

  typedef unordered_map<std::vector<I>, Label, kaldi::VectorHasher<I> > SymbolMapType;
  SymbolMapType symbol_mapping;
  Label symbol_counter = 0;
  {
    std::vector<I> eps;
    symbol_mapping[eps] = symbol_counter++;
  }
  std::vector<I> this_sym;  // a temporary used inside the loop.
  for (size_t i = 0; i < order.size(); i++) {
    StateId state = order[i];
    if (!remove[state]) {  // Process this state...
      StateId &new_state = state_mapping[state];
      if (new_state == kNoStateId) new_state = ofst->AddState();
      for (ArcIterator<Fst<Arc> > aiter(fst, state); !aiter.Done(); aiter.Next()) {
        Arc arc = aiter.Value();
        if (arc.ilabel == 0) this_sym.clear();
        else {
          this_sym.resize(1);
          this_sym[0] = arc.ilabel;
        }
        while (remove[arc.nextstate]) {
          ArcIterator<Fst<Arc> > aiter2(fst, arc.nextstate);
          assert(!aiter2.Done());
          const Arc &nextarc = aiter2.Value();
          arc.weight = Times(arc.weight, nextarc.weight);
          assert(nextarc.olabel == 0);
          if (nextarc.ilabel != 0) this_sym.push_back(nextarc.ilabel);
          assert(static_cast<Label>(static_cast<I>(nextarc.ilabel))
                 == nextarc.ilabel); // check within integer range.
          arc.nextstate = nextarc.nextstate;
        }
        StateId &new_nextstate = state_mapping[arc.nextstate];
        if (new_nextstate == kNoStateId) new_nextstate = ofst->AddState();
        arc.nextstate = new_nextstate;
        if (symbol_mapping.count(this_sym) != 0) arc.ilabel = symbol_mapping[this_sym];
        else arc.ilabel = symbol_mapping[this_sym] = symbol_counter++;
        ofst->AddArc(new_state, arc);
      }
      if (fst.Final(state) != Weight::Zero())
        ofst->SetFinal(new_state, fst.Final(state));
    }
  }
  ofst->SetStart(state_mapping[fst.Start()]);

  // Now output the symbol sequences.
  symbols_out->resize(symbol_counter);
  for (typename SymbolMapType::const_iterator iter = symbol_mapping.begin();
      iter != symbol_mapping.end(); ++iter) {
    (*symbols_out)[iter->second] = iter->first;
  }
}

Factor() [2/2]

void Factor	(	const Fst< Arc > &	fst,
		MutableFst< Arc > *	ofst1,
		MutableFst< Arc > *	ofst2
	)

This is a more conventional interface of Factor that outputs the result as two FSTs.

Definition at line 154 of file factor-inl.h.

References CreateFactorFst(), and Factor().

                                    {
  typedef typename Arc::Label Label;
  std::vector<std::vector<Label> > symbols;
  Factor(fst, ofst2, &symbols);
  CreateFactorFst(symbols, ofst1);
}

FileExists()

bool fst::FileExists

(

std::string

strFilename

)

Definition at line 31 of file deterministic-fst-test.cc.

                                       {
  struct stat stFileInfo;
  bool blnReturn;
  int intStat;

  // Attempt to get the file attributes
  intStat = stat(strFilename.c_str(), &stFileInfo);
  if (intStat == 0) {
    // We were able to get the file attributes
    // so the file obviously exists.
    blnReturn = true;
  } else {
    // We were not able to get the file attributes.
    // This may mean that we don't have permission to
    // access the folder which contains this file. If you
    // need to do that level of checking, lookup the
    // return values of stat which will give you
    // more details on why stat failed.
    blnReturn = false;
  }

  return blnReturn;
}

FindSelfLoopWithILabel()

ssize_t fst::FindSelfLoopWithILabel	(	const Fst< Arc > &	fst,
		typename Arc::StateId	s
	)

Definition at line 794 of file fstext-utils-inl.h.

Referenced by EqualAlign().

                                                                           {
  for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done(); aiter.Next())
    if (aiter.Value().nextstate == s
       && aiter.Value().ilabel != 0) return static_cast<ssize_t>(aiter.Position());
  return static_cast<ssize_t>(-1);
}

FollowingInputSymbolsAreSame()

bool FollowingInputSymbolsAreSame	(	bool	end_is_epsilon,
		const Fst< Arc > &	fst
	)

Returns true if and only if the FST is such that the input symbols on arcs exiting any given state all have the same value.

If end_is_epsilon, treat end-state as an epsilon output arc [i.e. ensure end-states cannot have non-epsilon output transitions.]

Definition at line 497 of file fstext-utils-inl.h.

References FollowingInputSymbolsAreSameClass().

Referenced by MinimizeEncoded(), and TestMakeSymbolsSame().

                                                                            {
  IdentityFunction<typename Arc::Label> f;
  return FollowingInputSymbolsAreSameClass(end_is_epsilon, fst, f);
}

FollowingInputSymbolsAreSameClass()

bool FollowingInputSymbolsAreSameClass	(	bool	end_is_epsilon,
		const Fst< Arc > &	fst,
		const F &	f
	)

Definition at line 504 of file fstext-utils-inl.h.

Referenced by FollowingInputSymbolsAreSame(), MinimizeEncoded(), and TestMakeSymbolsSameClass().

                                                                                             {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  typedef typename F::Result ClassType;
  const ClassType noClass = f(kNoLabel), epsClass = f(0);
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    ClassType c = noClass;
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (c == noClass)
        c = f(arc.ilabel);
      else
        if (c != f(arc.ilabel))
          return false;
    }
    if (end_is_epsilon && c != noClass &&
       c != epsClass && fst.Final(s) != Weight::Zero())
      return false;
  }
  return true;
}

GenAcceptorFromSequence()

static VectorFst<Arc>* fst::GenAcceptorFromSequence ( const vector< typename Arc::Label > &  symbols, float  cost  )

static

Definition at line 34 of file context-fst-test.cc.

References rnnlm::i, and kaldi::Rand().

                                                                                                     {
  typedef typename Arc::Weight Weight;
  typedef typename Arc::StateId StateId;

  vector<float> split_cost(symbols.size()+1, 0.0);  // for #-arcs + end-state.
  {  // compute split_cost.  it must sum to "cost".
    std::set<int32> indices;
    size_t num_indices = 1 + (kaldi::Rand() % split_cost.size());
    while (indices.size() < num_indices) indices.insert(kaldi::Rand() % split_cost.size());
    for (std::set<int32>::iterator iter = indices.begin(); iter != indices.end(); ++iter) {
      split_cost[*iter] = cost / num_indices;
    }
  }

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  StateId cur_state = fst->AddState();
  fst->SetStart(cur_state);
  for (size_t i = 0; i < symbols.size(); i++) {
    StateId next_state = fst->AddState();
    Arc arc;
    arc.ilabel = symbols[i];
    arc.olabel = symbols[i];
    arc.nextstate = next_state;
    arc.weight = (Weight) split_cost[i];
    fst->AddArc(cur_state, arc);
    cur_state = next_state;

  }
  fst->SetFinal(cur_state, (Weight)split_cost[symbols.size()]);
  return fst;
}

GenRandPhoneSeq()

static VectorFst<Arc>* fst::GenRandPhoneSeq ( vector< typename Arc::Label > &  phone_syms, vector< typename Arc::Label > &  disambig_syms, typename Arc::Label  subsequential_symbol, int  num_subseq_syms, float  seq_prob, vector< typename Arc::Label > *  phoneseq_out  )

static

Definition at line 124 of file context-fst-test.cc.

References rnnlm::i, KALDI_ASSERT, kaldi::Rand(), and kaldi::RandUniform().

                                                                                {
  KALDI_ASSERT(phoneseq_out != NULL);
  typedef typename Arc::Label Label;
  // Generate an FST that is a random phone sequence, ending
  // with "num_subseq_syms" subsequential symbols.  It will
  // have disambiguation symbols randomly interspersed throughout.
  // The number of phones is random (possibly zero).
  size_t len = (kaldi::Rand() % 4) * (kaldi::Rand() % 3);  // up to 3*2=6 phones.
  float disambig_prob = 0.33;
  phoneseq_out->clear();
  vector<Label> syms;  // the phones
  for (size_t i = 0; i < len; i++) {
    while (kaldi::RandUniform() < disambig_prob) syms.push_back(disambig_syms[kaldi::Rand() % disambig_syms.size()]);
    Label phone_id = phone_syms[kaldi::Rand() % phone_syms.size()];
    phoneseq_out->push_back(phone_id);  // record in output the underlying phone sequence.
    syms.push_back(phone_id);
  }
  for (size_t i = 0; static_cast<int32>(i) < num_subseq_syms; i++) {
    while (kaldi::RandUniform() < disambig_prob) syms.push_back(disambig_syms[kaldi::Rand() % disambig_syms.size()]);
    syms.push_back(subsequential_symbol);
  }
  while (kaldi::RandUniform() < disambig_prob) syms.push_back(disambig_syms[kaldi::Rand() % disambig_syms.size()]);

  // OK, now have the symbols of the FST as a vector.
  return GenAcceptorFromSequence<Arc>(syms, seq_prob);
}

GetEncodingMultiple()

int32 fst::GetEncodingMultiple ( int32  nonterm_phones_offset )

inline

Definition at line 90 of file grammar-context-fst.h.

References ComposeContextLeftBiphone(), and kNontermMediumNumber.

Referenced by GrammarFst::DecodeSymbol(), GrammarFst::ExpandState(), GrammarFstPreparer::FixArcsToFinalStates(), GrammarFstPreparer::GetCategoryOfArc(), kaldi::GetHTransducer(), GrammarFstPreparer::IsEntryState(), GrammarFstPreparer::MaybeAddFinalProbToState(), and GrammarFstPreparer::NeedEpsilons().

                                                              {
  int32 medium_number = static_cast<int32>(kNontermMediumNumber);
  return medium_number *
      ((nonterm_phones_offset + medium_number) / medium_number);
}

GetInputSymbols()

void GetInputSymbols	(	const Fst< Arc > &	fst,
		bool	include_eps,
		std::vector< I > *	symbols
	)

GetInputSymbols gets the list of symbols on the input of fst (including epsilon, if include_eps == true), as a sorted, unique list.

Definition at line 97 of file fstext-utils-inl.h.

References kaldi::CopySetToVector(), KALDI_ASSERT, and KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by ComposeContext(), ComposeContextLeftBiphone(), kaldi::CreateEditDistance(), kaldi::GetRandomAlignmentForPhone(), and TestMakeLinearAcceptor().

                                            {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  unordered_set<I> all_syms;
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    typename Arc::StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done();  aiter.Next()) {
      const Arc &arc = aiter.Value();
      all_syms.insert(arc.ilabel);
    }
  }
  // Remove epsilon, if instructed.
  if (!include_eps && all_syms.count(0) != 0)
    all_syms.erase(0);
  KALDI_ASSERT(symbols != NULL);
  kaldi::CopySetToVector(all_syms, symbols);
  std::sort(symbols->begin(), symbols->end());
}

GetLinearSymbolSequence()

bool GetLinearSymbolSequence	(	const Fst< Arc > &	fst,
		std::vector< I > *	isymbols_out,
		std::vector< I > *	osymbols_out,
		typename Arc::Weight *	tot_weight_out
	)

GetLinearSymbolSequence gets the symbol sequence from a linear FST.

If the FST is not just a linear sequence, it returns false. If it is a linear sequence (including the empty FST), it returns true. In this case it outputs the symbol sequences as "isymbols_out" and "osymbols_out" (removing epsilons), and the total weight as "tot_weight". The total weight will be Weight::Zero() if the FST is empty. If any of the output pointers are NULL, it does not create that output.

Definition at line 178 of file fstext-utils-inl.h.

References Times().

Referenced by kaldi::AlignUtteranceWrapper(), CheckPhones(), kaldi::DecodeUtterance(), DecodeUtterance(), kaldi::DecodeUtteranceLatticeFaster(), kaldi::DecodeUtteranceLatticeIncremental(), kaldi::DecodeUtteranceLatticeSimple(), OnlineFasterDecoder::EndOfUtterance(), kaldi::GetDiagnosticsAndPrintOutput(), kaldi::LatticeToString(), main(), kaldi::MaybeDoSanityCheck(), MinimizeEncoded(), MinimumBayesRisk::MinimumBayesRisk(), NnetBatchDecoder::ProcessOutputUtterance(), TestEqualAlign(), TestMakeLinearAcceptor(), and DecodeUtteranceLatticeFasterClass::~DecodeUtteranceLatticeFasterClass().

                                                                 {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  Weight tot_weight = Weight::One();
  std::vector<I> ilabel_seq;
  std::vector<I> olabel_seq;

  StateId cur_state = fst.Start();
  if (cur_state == kNoStateId) {  // empty sequence.
    if (isymbols_out != NULL) isymbols_out->clear();
    if (osymbols_out != NULL) osymbols_out->clear();
    if (tot_weight_out != NULL) *tot_weight_out = Weight::Zero();
    return true;
  }
  while (1) {
    Weight w = fst.Final(cur_state);
    if (w != Weight::Zero()) {  // is final..
      tot_weight = Times(w, tot_weight);
      if (fst.NumArcs(cur_state) != 0) return false;
      if (isymbols_out != NULL) *isymbols_out = ilabel_seq;
      if (osymbols_out != NULL) *osymbols_out = olabel_seq;
      if (tot_weight_out != NULL) *tot_weight_out = tot_weight;
      return true;
    } else {
      if (fst.NumArcs(cur_state) != 1) return false;

      ArcIterator<Fst<Arc> > iter(fst, cur_state);  // get the only arc.
      const Arc &arc = iter.Value();
      tot_weight = Times(arc.weight, tot_weight);
      if (arc.ilabel != 0) ilabel_seq.push_back(arc.ilabel);
      if (arc.olabel != 0) olabel_seq.push_back(arc.olabel);
      cur_state = arc.nextstate;
    }
  }
}

GetOutputSymbols()

void GetOutputSymbols	(	const Fst< Arc > &	fst,
		bool	include_eps,
		std::vector< I > *	symbols
	)

GetOutputSymbols gets the list of symbols on the output of fst (including epsilon, if include_eps == true)

Definition at line 76 of file fstext-utils-inl.h.

References kaldi::CopySetToVector(), KALDI_ASSERT, and KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by kaldi::CreateEditDistance().

                                             {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  std::set<I> all_syms;
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    typename Arc::StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done();  aiter.Next()) {
      const Arc &arc = aiter.Value();
      all_syms.insert(arc.olabel);
    }
  }

  // Remove epsilon, if instructed.
  if (!include_eps && !all_syms.empty() && *all_syms.begin() == 0)
    all_syms.erase(0);
  KALDI_ASSERT(symbols != NULL);
  kaldi::CopySetToVector(all_syms, symbols);
}

GetStateProperties()

void GetStateProperties	(	const Fst< Arc > &	fst,
		typename Arc::StateId	max_state,
		std::vector< StatePropertiesType > *	props
	)

This function works out various properties of the states in the FST, using the bit properties defined in StatePropertiesEnum.

Definition at line 37 of file factor-inl.h.

References kStateArcsIn, kStateArcsOut, kStateFinal, kStateIlabelsOut, kStateInitial, kStateMultipleArcsIn, kStateMultipleArcsOut, and kStateOlabelsOut.

Referenced by Factor().

                                                               {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  assert(props != NULL);
  props->clear();
  if (fst.Start() < 0) return;  // Empty fst.
  props->resize(max_state+1, 0);
  assert(fst.Start() <= max_state);
  (*props)[fst.Start()] |= kStateInitial;
  for (StateId s = 0; s <= max_state; s++) {
    StatePropertiesType &s_info = (*props)[s];
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (arc.ilabel != 0) s_info |= kStateIlabelsOut;
      if (arc.olabel != 0) s_info |= kStateOlabelsOut;
      StateId nexts = arc.nextstate;
      assert(nexts <= max_state);  // or input was invalid.
      StatePropertiesType &nexts_info = (*props)[nexts];
      if (s_info&kStateArcsOut) s_info |= kStateMultipleArcsOut;
      s_info |= kStateArcsOut;
      if (nexts_info&kStateArcsIn) nexts_info |= kStateMultipleArcsIn;
      nexts_info |= kStateArcsIn;
    }
    if (fst.Final(s) != Weight::Zero())  s_info |= kStateFinal;
  }
}

GetSymbols()

void GetSymbols	(	const SymbolTable &	symtab,
		bool	include_eps,
		std::vector< I > *	syms_out
	)

Definition at line 329 of file fstext-utils-inl.h.

References KALDI_ASSERT.

Referenced by main().

                                        {
  KALDI_ASSERT(syms_out != NULL);
  syms_out->clear();
  for (SymbolTableIterator iter(symtab);
      !iter.Done();
      iter.Next()) {
    if (include_eps || iter.Value() != 0) {
      syms_out->push_back(iter.Value());
      KALDI_ASSERT(syms_out->back() == iter.Value());  // an integer-range thing.
    }
  }
}

GraphLatticeScale()

std::vector<std::vector<double> > fst::GraphLatticeScale ( double  lmwt )

inline

Definition at line 147 of file lattice-utils.h.

Referenced by main().

                                                                    {
  std::vector<std::vector<double> > ans(2);
  ans[0].resize(2, 0.0);
  ans[1].resize(2, 0.0);
  ans[0][0] = lmwt;
  ans[1][1] = 1.0;
  return ans;
}

HighestNumberedInputSymbol()

Arc::Label HighestNumberedInputSymbol

(

const Fst< Arc > &

fst

)

Returns the highest numbered input symbol id of the FST (or zero for an empty FST.

Definition at line 54 of file fstext-utils-inl.h.

Referenced by DeterminizeLatticeInsertPhones(), main(), SafeDeterminizeMinimizeWrapper(), SafeDeterminizeWrapper(), TestDeterminizeStarInLog(), and TestPreDeterminize().

                                                                  {
  typename Arc::Label ans = 0;
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    typename Arc::StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done();  aiter.Next()) {
      const Arc &arc = aiter.Value();
      ans = std::max(ans, arc.ilabel);
    }
  }
  return ans;
}

HighestNumberedOutputSymbol()

Arc::Label HighestNumberedOutputSymbol

(

const Fst< Arc > &

fst

)

Returns the highest numbered output symbol id of the FST (or zero for an empty FST.

Definition at line 41 of file fstext-utils-inl.h.

Referenced by LatticeWordAligner::LatticeWordAligner().

                                                                   {
  typename Arc::Label ans = 0;
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    typename Arc::StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done();  aiter.Next()) {
      const Arc &arc = aiter.Value();
      ans = std::max(ans, arc.olabel);
    }
  }
  return ans;
}

InputDeterminizeSingleState() [1/2]

static void fst::InputDeterminizeSingleState ( StdArc::StateId  s, VectorFst< StdArc > *  fst  )

static

Definition at line 31 of file fstdeterminizestart.cc.

References rnnlm::i, and kaldi::LogAdd().

                                                         {
  bool was_input_deterministic = true;
  typedef StdArc Arc;
  typedef Arc::StateId StateId;
  typedef Arc::Label Label;
  typedef Arc::Weight Weight;

  struct InfoForIlabel {
    std::vector<size_t> arc_indexes;  // indexes of all arcs with this ilabel
    float tot_cost;  // total cost of all arcs leaving state s for this
                     // ilabel, summed as if they were negative log-probs.
    StateId new_state;  // state-id of new state, if any, that we have created
                        // to remove duplicate symbols with this ilabel.
    InfoForIlabel(): new_state(-1) { }
  };

  std::unordered_map<Label, InfoForIlabel> label_map;

  size_t arc_index = 0;
  for (ArcIterator<VectorFst<Arc> > aiter(*fst, s);
       !aiter.Done(); aiter.Next(), ++arc_index) {
    const Arc &arc = aiter.Value();
    InfoForIlabel &info = label_map[arc.ilabel];
    if (info.arc_indexes.empty()) {
      info.tot_cost = arc.weight.Value();
    } else {
      info.tot_cost = -kaldi::LogAdd(-info.tot_cost, -arc.weight.Value());
      was_input_deterministic = false;
    }
    info.arc_indexes.push_back(arc_index);
  }

  if (was_input_deterministic)
    return;  // Nothing to do.

  // 'new_arcs' will contain the modified list of arcs
  // leaving state s
  std::vector<Arc> new_arcs;
  new_arcs.reserve(arc_index);
  arc_index = 0;
  for (ArcIterator<VectorFst<Arc> > aiter(*fst, s);
       !aiter.Done(); aiter.Next(), ++arc_index) {
    const Arc &arc = aiter.Value();
    Label ilabel = arc.ilabel;
    InfoForIlabel &info = label_map[ilabel];
    if (info.arc_indexes.size() == 1) {
      new_arcs.push_back(arc);  // no changes needed
    } else {
      if (info.new_state < 0) {
        info.new_state = fst->AddState();
        // add arc from state 's' to newly created state.
        new_arcs.push_back(Arc(ilabel, 0, Weight(info.tot_cost),
                               info.new_state));
      }
      // add arc from new state to original destination of this arc.
      fst->AddArc(info.new_state, Arc(0, arc.olabel,
                                      Weight(arc.weight.Value() - info.tot_cost),
                                      arc.nextstate));
    }
  }
  fst->DeleteArcs(s);
  for (size_t i = 0; i < new_arcs.size(); i++)
    fst->AddArc(s, new_arcs[i]);
}

InputDeterminizeSingleState() [2/2]

static void fst::InputDeterminizeSingleState ( StdArc::StateId  s, VectorFst< StdArc > *  fst  )

static

This utility function input-determinizes a specified state s of the FST 'fst'.

(This input-determinizes while treating epsilon as a real symbol, although for the application we expect to use it, there won't be epsilons).

What this function does is: for any symbol i that appears as the ilabel of more than one arc leaving state s of FST 'fst', it creates an additional state, it creates a new state t with epsilon-input transitions leaving it for each of those multiple arcs leaving state s; it deletes the original arcs leaving state s; and it creates a single arc leaving state s to the newly created state with the ilabel i on it. It sets the weights as necessary to preserve equivalence and also to ensure that if, prior to this modification, the FST was stochastic when cast to the log semiring (see IsStochasticInLog()), it still will be. I.e. when interpreted as negative logprobs, the weight from state s to t would be the sum of the weights on the original arcs leaving state s.

This is used as a very cheap solution when preparing FSTs for the grammar decoder, to ensure that there is only one entry-state to the sub-FST for each phonetic left-context; this keeps the grammar-FST code (i.e. the code that stitches them together) simple. Of course it will tend to introduce unnecessary epsilons, and if we were careful we might be able to remove some of those, but this wouldn't have a substantial impact on overall decoder performance so we don't bother.

Definition at line 472 of file grammar-fst.cc.

References rnnlm::i, and kaldi::LogAdd().

Referenced by main(), and GrammarFstPreparer::Prepare().

                                                                {
  bool was_input_deterministic = true;
  typedef StdArc Arc;
  typedef Arc::StateId StateId;
  typedef Arc::Label Label;
  typedef Arc::Weight Weight;

  struct InfoForIlabel {
    std::vector<size_t> arc_indexes;  // indexes of all arcs with this ilabel
    float tot_cost;  // total cost of all arcs leaving state s for this
                     // ilabel, summed as if they were negative log-probs.
    StateId new_state;  // state-id of new state, if any, that we have created
                        // to remove duplicate symbols with this ilabel.
    InfoForIlabel(): new_state(-1) { }
  };

  std::unordered_map<Label, InfoForIlabel> label_map;

  size_t arc_index = 0;
  for (ArcIterator<VectorFst<Arc> > aiter(*fst, s);
       !aiter.Done(); aiter.Next(), ++arc_index) {
    const Arc &arc = aiter.Value();
    InfoForIlabel &info = label_map[arc.ilabel];
    if (info.arc_indexes.empty()) {
      info.tot_cost = arc.weight.Value();
    } else {
      info.tot_cost = -kaldi::LogAdd(-info.tot_cost, -arc.weight.Value());
      was_input_deterministic = false;
    }
    info.arc_indexes.push_back(arc_index);
  }

  if (was_input_deterministic)
    return;  // Nothing to do.

  // 'new_arcs' will contain the modified list of arcs
  // leaving state s
  std::vector<Arc> new_arcs;
  new_arcs.reserve(arc_index);
  arc_index = 0;
  for (ArcIterator<VectorFst<Arc> > aiter(*fst, s);
       !aiter.Done(); aiter.Next(), ++arc_index) {
    const Arc &arc = aiter.Value();
    Label ilabel = arc.ilabel;
    InfoForIlabel &info = label_map[ilabel];
    if (info.arc_indexes.size() == 1) {
      new_arcs.push_back(arc);  // no changes needed
    } else {
      if (info.new_state < 0) {
        info.new_state = fst->AddState();
        // add arc from state 's' to newly created state.
        new_arcs.push_back(Arc(ilabel, 0, Weight(info.tot_cost),
                               info.new_state));
      }
      // add arc from new state to original destination of this arc.
      fst->AddArc(info.new_state, Arc(0, arc.olabel,
                                      Weight(arc.weight.Value() - info.tot_cost),
                                      arc.nextstate));
    }
  }
  fst->DeleteArcs(s);
  for (size_t i = 0; i < new_arcs.size(); i++)
    fst->AddArc(s, new_arcs[i]);
}

IsStochasticFst() [1/2]

bool IsStochasticFst ( const Fst< LogArc > &  fst, float  delta, LogArc::Weight *  min_sum, LogArc::Weight *  max_sum  )

inline

Definition at line 1173 of file fstext-utils-inl.h.

References ApproxEqual(), and Plus().

Referenced by IsStochasticFstInLog(), main(), MinimizeEncoded(), RhoCompose(), and TestRemoveEpsLocalSpecial().

                                            {
  typedef LogArc Arc;
  typedef Arc::StateId StateId;
  typedef Arc::Weight Weight;
  bool first_time = true;
  bool ans = true;
  if (min_sum) *min_sum = LogArc::Weight::One();
  if (max_sum) *max_sum = LogArc::Weight::One();
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    Weight sum = fst.Final(s);
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      sum = Plus(sum, arc.weight);
    }
    if (!ApproxEqual(Weight::One(), sum, delta)) ans = false;
    if (first_time) {
      first_time = false;
      if (max_sum) *max_sum = sum;
      if (min_sum) *min_sum = sum;
    } else {
      // note that max and min are reversed from their normal
      // meanings here (max and min w.r.t. the underlying probabilities).
      if (max_sum && sum.Value() < max_sum->Value()) *max_sum = sum;
      if (min_sum && sum.Value() > min_sum->Value()) *min_sum = sum;
    }
  }
  if (first_time) {  // just avoid NaNs if FST was empty.
    if (max_sum) *max_sum = Weight::One();
    if (min_sum) *min_sum = Weight::One();
  }
  return ans;
}

IsStochasticFst() [2/2]

bool IsStochasticFst ( const Fst< Arc > &  fst, float  delta = kDelta, typename Arc::Weight *  min_sum = NULL, typename Arc::Weight *  max_sum = NULL  )

inline

This function returns true if, in the semiring of the FST, the sum (within the semiring) of all the arcs out of each state in the FST is one, to within delta.

After MakeStochasticFst, this should be true (for a connected FST).

Parameters

fst	[in] the FST that we are testing.
delta	[in] the tolerance to within which we test equality to 1.
min_sum	[out] if non, NULL, contents will be set to the minimum sum of weights.
max_sum	[out] if non, NULL, contents will be set to the maximum sum of weights.

Returns

Returns true if the FST is stochastic, and false otherwise.

Definition at line 1135 of file fstext-utils-inl.h.

References ApproxEqual(), and Plus().

                                                  {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  NaturalLess<Weight> nl;
  bool first_time = true;
  bool ans = true;
  if (min_sum) *min_sum = Arc::Weight::One();
  if (max_sum) *max_sum = Arc::Weight::One();
  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    Weight sum = fst.Final(s);
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      sum = Plus(sum, arc.weight);
    }
    if (!ApproxEqual(Weight::One(), sum, delta)) ans = false;
    if (first_time) {
      first_time = false;
      if (max_sum) *max_sum = sum;
      if (min_sum) *min_sum = sum;
    } else {
      if (max_sum && nl(*max_sum, sum)) *max_sum = sum;
      if (min_sum && nl(sum, *min_sum)) *min_sum = sum;
    }
  }
  if (first_time) {  // just avoid NaNs if FST was empty.
    if (max_sum) *max_sum = Weight::One();
    if (min_sum) *min_sum = Weight::One();
  }
  return ans;
}

IsStochasticFstInLog()

bool IsStochasticFstInLog ( const Fst< StdArc > &  fst, float  delta, StdArc::Weight *  min_sum, StdArc::Weight *  max_sum  )

inline

Definition at line 1215 of file fstext-utils-inl.h.

References IsStochasticFst(), and KALDI_ERR.

Referenced by main(), MinimizeEncoded(), and TestPushSpecial().

                                                 {
  bool ans = false;
  LogArc::Weight log_min = LogArc::Weight::One(),
    log_max = LogArc::Weight::Zero();
  if (fst.Type() == "const") {
    ConstFst<LogArc> logfst;
    Cast(dynamic_cast<const ConstFst<StdArc>&>(fst), &logfst);
    ans = IsStochasticFst(logfst, delta, &log_min, &log_max);
  } else if (fst.Type() == "vector") {
    VectorFst<LogArc> logfst;
    Cast(dynamic_cast<const VectorFst<StdArc>&>(fst), &logfst);
    ans = IsStochasticFst(logfst, delta, &log_min, &log_max);
  } else {
    KALDI_ERR << "This version currently supports ConstFst<StdArc> "
              << "or VectorFst<StdArc>";
  }
  if (min_sum) *min_sum = StdArc::Weight(log_min.Value());
  if (max_sum) *max_sum = StdArc::Weight(log_max.Value());
  return ans;
}

LatticeScale()

std::vector<std::vector<double> > fst::LatticeScale ( double  lmwt, double  acwt  )

inline

Definition at line 156 of file lattice-utils.h.

References CompactLatticeHasAlignment(), RemoveAlignmentsFromCompactLattice(), and ScaleLattice().

Referenced by main().

                                                                            {
  std::vector<std::vector<double> > ans(2);
  ans[0].resize(2, 0.0);
  ans[1].resize(2, 0.0);
  ans[0][0] = lmwt;
  ans[1][1] = acwt;
  return ans;
}

LatticeWeightTest()

void fst::LatticeWeightTest

(

)

Definition at line 64 of file lattice-weight-test.cc.

References ApproxEqual(), kaldi::AssertEqual(), Compare(), Divide(), rnnlm::i, KALDI_ASSERT, LatticeWeightTpl< FloatType >::Member(), LatticeWeightTpl< BaseFloat >::One(), Plus(), LatticeWeightTpl< FloatType >::Quantize(), RandomLatticeWeight(), LatticeWeightTpl< FloatType >::Read(), LatticeWeightTpl< FloatType >::Reverse(), Times(), LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by main().

                         {
  for(int32 i = 0; i < 100; i++) {
    LatticeWeight l1 = RandomLatticeWeight(), l2 = RandomLatticeWeight();
    LatticeWeight l3 = Plus(l1, l2);
    LatticeWeight l4 = Times(l1, l2);
    BaseFloat f1 = l1.Value1() + l1.Value2(), f2 = l2.Value1() + l2.Value2(), f3 = l3.Value1() + l3.Value2(),
        f4 = l4.Value1() + l4.Value2();
    kaldi::AssertEqual(std::min(f1, f2), f3);
    kaldi::AssertEqual(f1 + f2, f4);

    KALDI_ASSERT(Plus(l3, l3) == l3);
    KALDI_ASSERT(Plus(l1, l2) == Plus(l2, l1)); // commutativity of plus
    KALDI_ASSERT(Times(l1, l2) == Times(l2, l1)); // commutativity of Times (true for this semiring, not always)
    KALDI_ASSERT(Plus(l3, LatticeWeight::Zero()) == l3); // x + 0 = x
    KALDI_ASSERT(Times(l3, LatticeWeight::One()) == l3); // x * 1 = x
    KALDI_ASSERT(Times(l3, LatticeWeight::Zero()) == LatticeWeight::Zero()); // x * 0 = 0

    KALDI_ASSERT(l3.Reverse().Reverse() == l3);

    NaturalLess<LatticeWeight> nl;
    bool a = nl(l1, l2);
    bool b = (Plus(l1, l2) == l1 && l1 != l2);
    KALDI_ASSERT(a == b);

    KALDI_ASSERT(Compare(l1, Plus(l1, l2)) != 1); // so do not have l1 > l1 + l2
    LatticeWeight l5 = RandomLatticeWeight(), l6 = RandomLatticeWeight();
    {
      LatticeWeight wa = Times(Plus(l1, l2), Plus(l5, l6)),
          wb =  Plus(Times(l1, l5), Plus(Times(l1, l6),
                                        Plus(Times(l2, l5), Times(l2, l6))));
      if (!ApproxEqual(wa, wb)) {
        std::cout << "l1 = " << l1 << ", l2 = " << l2
                  << ", l5 = " << l5 << ", l6 = " << l6 << "\n";
        std::cout << "ERROR: " << wa << " != " <<  wb << "\n";
      }
      // KALDI_ASSERT(Times(Plus(l1, l2), Plus(l5, l6))
      // == Plus(Times(l1, l5), Plus(Times(l1,l6),
      // Plus(Times(l2, l5), Times(l2, l6))))); // * distributes over +
    }
    KALDI_ASSERT(l1.Member() && l2.Member() && l3.Member() && l4.Member()
                 && l5.Member() && l6.Member());
    if (l2 != LatticeWeight::Zero())
      KALDI_ASSERT(ApproxEqual(Divide(Times(l1, l2), l2), l1)); // (a*b) / b = a if b != 0
    KALDI_ASSERT(ApproxEqual(l1, l1.Quantize()));

    std::ostringstream s1;
    s1 << l1;
    std::istringstream s2(s1.str());
    s2 >> l2;
    KALDI_ASSERT(ApproxEqual(l1, l2, 0.001));
    std::cout << s1.str() << '\n';
    {
      std::ostringstream s1b;
      l1.Write(s1b);
      std::istringstream s2b(s1b.str());
      l3.Read(s2b);
      KALDI_ASSERT(l1 == l3);
    }
  }
}

MakeFollowingInputSymbolsSame()

void MakeFollowingInputSymbolsSame	(	bool	end_is_epsilon,
		MutableFst< Arc > *	fst
	)

MakeFollowingInputSymbolsSame ensures that all arcs exiting any given fst state have the same input symbol.

It does this by detecting states that have differing input symbols on arcs that exit it, and inserting, for each of the following arcs with non-epsilon input symbol, a new dummy state that has an input-epsilon link from the fst state. The output symbol and weight stay on the link to the dummy state (in order to keep the FST output-deterministic and stochastic, if it already was). If end_is_epsilon, treat "being a final-state" like having an epsilon output link.

Definition at line 610 of file fstext-utils-inl.h.

References MakeFollowingInputSymbolsSameClass().

Referenced by MinimizeEncoded(), and TestMakeSymbolsSame().

                                                                              {
  IdentityFunction<typename Arc::Label> f;
  MakeFollowingInputSymbolsSameClass(end_is_epsilon, fst, f);
}

MakeFollowingInputSymbolsSameClass()

void MakeFollowingInputSymbolsSameClass	(	bool	end_is_epsilon,
		MutableFst< Arc > *	fst,
		const F &	f
	)

As MakeFollowingInputSymbolsSame, but takes a functor object that maps labels to classes.

Definition at line 616 of file fstext-utils-inl.h.

References rnnlm::i, and rnnlm::j.

Referenced by kaldi::AddSelfLoopsNoReorder(), MakeFollowingInputSymbolsSame(), MinimizeEncoded(), and TestMakeSymbolsSameClass().

                                                                                               {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  typedef typename F::Result ClassType;
  std::vector<StateId> bad_states;
  ClassType noClass = f(kNoLabel);
  ClassType epsClass = f(0);
  for (StateIterator<Fst<Arc> > siter(*fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    ClassType c = noClass;
    bool bad = false;
    for (ArcIterator<Fst<Arc> > aiter(*fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (c == noClass)
        c = f(arc.ilabel);
      else
        if (c != f(arc.ilabel)) {
          bad = true;
          break;
        }
    }
    if (end_is_epsilon && c != noClass &&
       c != epsClass && fst->Final(s) != Weight::Zero())
      bad = true;
    if (bad)
      bad_states.push_back(s);
  }
  std::vector<Arc> my_arcs;
  for (size_t i = 0; i < bad_states.size(); i++) {
    StateId s = bad_states[i];
    my_arcs.clear();
    for (ArcIterator<MutableFst<Arc> > aiter(*fst, s); !aiter.Done(); aiter.Next())
      my_arcs.push_back(aiter.Value());

    for (size_t j = 0; j < my_arcs.size(); j++) {
      Arc &arc = my_arcs[j];
      if (arc.ilabel != 0) {
        StateId newstate = fst->AddState();
        // Create a new state for each non-eps arc in original FST, out of each bad state.
        // Not as optimal as it could be, but does avoid some complicated weight-pushing
        // issues in which, to maintain stochasticity, we would have to know which semiring
        // we want to maintain stochasticity in.
        fst->AddArc(newstate, Arc(arc.ilabel, 0, Weight::One(), arc.nextstate));
        MutableArcIterator<MutableFst<Arc> > maiter(fst, s);
        maiter.Seek(j);
        maiter.SetValue(Arc(0, arc.olabel, arc.weight, newstate));
      }
    }
  }
}

MakeLinearAcceptor()

void MakeLinearAcceptor	(	const std::vector< I > &	labels,
		MutableFst< Arc > *	ofst
	)

Creates unweighted linear acceptor from symbol sequence.

Definition at line 311 of file fstext-utils-inl.h.

References rnnlm::i.

Referenced by TrainingGraphCompiler::CompileGraphFromText(), TrainingGraphCompiler::CompileGraphsFromText(), main(), MinimizeEncoded(), and TestMakeLinearAcceptor().

                                                                           {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  ofst->DeleteStates();
  StateId cur_state = ofst->AddState();
  ofst->SetStart(cur_state);
  for (size_t i = 0; i < labels.size(); i++) {
    StateId next_state = ofst->AddState();
    Arc arc(labels[i], labels[i], Weight::One(), next_state);
    ofst->AddArc(cur_state, arc);
    cur_state = next_state;
  }
  ofst->SetFinal(cur_state, Weight::One());
}

MakeLinearAcceptorWithAlternatives()

void MakeLinearAcceptorWithAlternatives	(	const std::vector< std::vector< I > > &	labels,
		MutableFst< Arc > *	ofst
	)

Creates an unweighted acceptor with a linear structure, with alternatives at each position.

Epsilon is treated like a normal symbol here. Each position in "labels" must have at least one alternative.

Definition at line 290 of file fstext-utils-inl.h.

References rnnlm::i, rnnlm::j, and KALDI_ASSERT.

Referenced by MinimizeEncoded().

                                                               {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  ofst->DeleteStates();
  StateId cur_state = ofst->AddState();
  ofst->SetStart(cur_state);
  for (size_t i = 0; i < labels.size(); i++) {
    KALDI_ASSERT(labels[i].size() != 0);
    StateId next_state = ofst->AddState();
    for (size_t j = 0; j < labels[i].size(); j++) {
      Arc arc(labels[i][j], labels[i][j], Weight::One(), next_state);
      ofst->AddArc(cur_state, arc);
    }
    cur_state = next_state;
  }
  ofst->SetFinal(cur_state, Weight::One());
}

MakeLoopFst()

VectorFst< Arc > * MakeLoopFst

(

const std::vector< const ExpandedFst< Arc > * > &

fsts

)

MakeLoopFst creates an FST that has a state that is both initial and final (weight == Weight::One()), and for each non-NULL pointer fsts[i], it has an arc out whose output-symbol is i and which goes to a sub-graph whose input language is equivalent to fsts[i], where the final-state becomes a transition to the loop-state.

Each fst in "fsts" should be an acceptor. The fst MakeLoopFst returns is output-deterministic, but not output-epsilon free necessarily, and arcs are sorted on output label. Note: if some of the pointers in the input vector "fsts" have the same value, "MakeLoopFst" uses this to speed up the computation. Formally: suppose I is the set of indexes i such that fsts[i] != NULL. Let L[i] be the language that the acceptor fsts[i] accepts. Let the language K be the set of input-output pairs i:l such that i in I and l in L[i]. Then the FST returned by MakeLoopFst accepts the language K*, where * is the Kleene closure (CLOSURE_STAR) of K. We could have implemented this via a combination of "project", "concat", "union" and "closure". But that FST would have been less well optimized and would have a lot of final-states.

Definition at line 669 of file fstext-utils-inl.h.

References rnnlm::i, and KALDI_ASSERT.

Referenced by kaldi::GetHTransducer(), MinimizeEncoded(), and TestMakeLoopFst().

                                                                             {
  typedef typename Arc::Weight Weight;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;

  VectorFst<Arc> *ans = new VectorFst<Arc>;
  StateId loop_state = ans->AddState();  // = 0.
  ans->SetStart(loop_state);
  ans->SetFinal(loop_state, Weight::One());

  // "cache" is used as an optimization when some of the pointers in "fsts"
  // may have the same value.
  unordered_map<const ExpandedFst<Arc> *, Arc> cache;

  for (Label i = 0; i < static_cast<Label>(fsts.size()); i++) {
    const ExpandedFst<Arc> *fst = fsts[i];
    if (fst == NULL) continue;
    { // optimization with cache: helpful if some members of "fsts" may
      // contain the same pointer value (e.g. in GetHTransducer).
      typename unordered_map<const ExpandedFst<Arc> *, Arc>::iterator
          iter = cache.find(fst);
      if (iter != cache.end()) {
        Arc arc = iter->second;
        arc.olabel = i;
        ans->AddArc(0, arc);
        continue;
      }
    }

    KALDI_ASSERT(fst->Properties(kAcceptor, true) == kAcceptor);  // expect acceptor.

    StateId fst_num_states = fst->NumStates();
    StateId fst_start_state = fst->Start();

    if (fst_start_state == kNoStateId)
      continue;  // empty fst.

    bool share_start_state =
        fst->Properties(kInitialAcyclic, true) == kInitialAcyclic
        && fst->NumArcs(fst_start_state) == 1
        && fst->Final(fst_start_state) == Weight::Zero();

    std::vector<StateId> state_map(fst_num_states);  // fst state -> ans state
    for (StateId s = 0; s < fst_num_states; s++) {
      if (s == fst_start_state && share_start_state) state_map[s] = loop_state;
      else state_map[s] = ans->AddState();
    }
    if (!share_start_state) {
      Arc arc(0, i, Weight::One(), state_map[fst_start_state]);
      cache[fst] = arc;
      ans->AddArc(0, arc);
    }
    for (StateId s = 0; s < fst_num_states; s++) {
      // Add arcs out of state s.
      for (ArcIterator<ExpandedFst<Arc> > aiter(*fst, s); !aiter.Done(); aiter.Next()) {
        const Arc &arc = aiter.Value();
        Label olabel = (s == fst_start_state && share_start_state ? i : 0);
        Arc newarc(arc.ilabel, olabel, arc.weight, state_map[arc.nextstate]);
        ans->AddArc(state_map[s], newarc);
        if (s == fst_start_state && share_start_state)
          cache[fst] = newarc;
      }
      if (fst->Final(s) != Weight::Zero()) {
        KALDI_ASSERT(!(s == fst_start_state && share_start_state));
        ans->AddArc(state_map[s], Arc(0, 0, fst->Final(s), loop_state));
      }
    }
  }
  return ans;
}

MakeLoopFstCompare()

VectorFst<Arc>* fst::MakeLoopFstCompare

(

const vector< const ExpandedFst< Arc > *> &

fsts

)

Definition at line 281 of file fstext-utils-test.cc.

References ClearSymbols(), fst::pre_determinize_helpers::Closure(), and rnnlm::i.

Referenced by TestMakeLoopFst().

                                                                                 {
  VectorFst<Arc> *ans = new VectorFst<Arc>;
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  for (Label i = 0; i <  fsts.size(); i++) {
    if (fsts[i] != NULL) {
      VectorFst<Arc> i_fst;  // accepts symbol i on output.
      i_fst.AddState(); i_fst.AddState();
      i_fst.SetStart(0); i_fst.SetFinal(1, Weight::One());
      i_fst.AddArc(0, Arc(0, i, Weight::One(), 1));
      VectorFst<Arc> other_fst(*(fsts[i]));  // copy it.
      ClearSymbols(false, true, &other_fst);  // Clear output symbols so symbols
      // are on input side.
      Concat(&i_fst, other_fst);  // now i_fst is "i_fst [concat] other_fst".
      Union(ans, i_fst);
    }
  }
  Closure(ans, CLOSURE_STAR);
  return ans;
}

MakePrecedingInputSymbolsSame()

void MakePrecedingInputSymbolsSame	(	bool	start_is_epsilon,
		MutableFst< Arc > *	fst
	)

MakePrecedingInputSymbolsSame ensures that all arcs entering any given fst state have the same input symbol.

It does this by detecting states that have differing input symbols going in, and inserting, for each of the preceding arcs with non-epsilon input symbol, a new dummy state that has an epsilon link to the fst state. If "start_is_epsilon", ensure that start-state can have only epsilon-links into it.

Definition at line 528 of file fstext-utils-inl.h.

References MakePrecedingInputSymbolsSameClass().

Referenced by MinimizeEncoded(), and TestMakeSymbolsSame().

                                                                                {
  IdentityFunction<typename Arc::Label> f;
  MakePrecedingInputSymbolsSameClass(start_is_epsilon, fst, f);
}

MakePrecedingInputSymbolsSameClass()

void MakePrecedingInputSymbolsSameClass	(	bool	start_is_epsilon,
		MutableFst< Arc > *	fst,
		const F &	f
	)

As MakePrecedingInputSymbolsSame, but takes a functor object that maps labels to classes.

Definition at line 534 of file fstext-utils-inl.h.

References ConstIntegerSet< I >::count(), rnnlm::i, and KALDI_ASSERT.

Referenced by kaldi::AddSelfLoopsReorder(), MakePrecedingInputSymbolsSame(), MinimizeEncoded(), and TestMakeSymbolsSameClass().

                                                                                                 {
  typedef typename F::Result ClassType;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  std::vector<ClassType> classes;
  ClassType noClass = f(kNoLabel);
  ClassType epsClass = f(0);
  if (start_is_epsilon) {  // treat having-start-state as epsilon in-transition.
    StateId start_state = fst->Start();
    if (start_state < 0 || start_state == kNoStateId) // empty FST.
      return;
    classes.resize(start_state+1, noClass);
    classes[start_state] = epsClass;
  }

  // Find bad states (states with multiple input-symbols into them).
  std::set<StateId> bad_states;  // states that we need to change.
  for (StateIterator<Fst<Arc> > siter(*fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(*fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (classes.size() <= static_cast<size_t>(arc.nextstate))
        classes.resize(arc.nextstate+1, noClass);
      if (classes[arc.nextstate] == noClass)
        classes[arc.nextstate] = f(arc.ilabel);
      else
        if (classes[arc.nextstate] != f(arc.ilabel))
          bad_states.insert(arc.nextstate);
    }
  }
  if (bad_states.empty()) return;  // Nothing to do.
  kaldi::ConstIntegerSet<StateId> bad_states_ciset(bad_states);  // faster lookup.

  // Work out list of arcs we have to change as (state, arc-offset).
  // Can't do the actual changes in this pass, since we have to add new
  // states which invalidates the iterators.
  std::vector<std::pair<StateId, size_t> > arcs_to_change;
  for (StateIterator<Fst<Arc> > siter(*fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(*fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (arc.ilabel != 0 &&
         bad_states_ciset.count(arc.nextstate) != 0)
        arcs_to_change.push_back(std::make_pair(s, aiter.Position()));
    }
  }
  KALDI_ASSERT(!arcs_to_change.empty());  // since !bad_states.empty().

  std::map<std::pair<StateId, ClassType>, StateId> state_map;
  // state_map is a map from (bad-state, input-symbol-class) to dummy-state.

  for (size_t i = 0; i < arcs_to_change.size(); i++) {
    StateId s = arcs_to_change[i].first;
    ArcIterator<MutableFst<Arc> > aiter(*fst, s);
    aiter.Seek(arcs_to_change[i].second);
    Arc arc = aiter.Value();

    // Transition is non-eps transition to "bad" state.  Introduce new state (or find
    // existing one).
    std::pair<StateId, ClassType> p(arc.nextstate, f(arc.ilabel));
    if (state_map.count(p) == 0) {
      StateId newstate = state_map[p] = fst->AddState();
      fst->AddArc(newstate, Arc(0, 0, Weight::One(), arc.nextstate));
    }
    StateId dst_state = state_map[p];
    arc.nextstate = dst_state;

    // Initialize the MutableArcIterator only now, as the call to NewState()
    // may have invalidated the first arc iterator.
    MutableArcIterator<MutableFst<Arc> > maiter(fst, s);
    maiter.Seek(arcs_to_change[i].second);
    maiter.SetValue(arc);
  }
}

MapInputSymbols()

void MapInputSymbols	(	const std::vector< I > &	symbol_mapping,
		MutableFst< Arc > *	fst
	)

Definition at line 168 of file fstext-utils-inl.h.

References KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by MinimizeEncoded(), and TestFactor().

                                           {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  // false == don't copy the "symbol_mapping", retain pointer--
  // safe since short-lived object.
  MapInputSymbolsMapper<Arc, I> mapper(symbol_mapping, false);
  Map(fst, mapper);
}

MinimizeCompactLattice()

bool MinimizeCompactLattice	(	MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *	clat,
		float	delta = fst::kDelta
	)

This function minimizes the compact lattice.

It is to be called after determinization (see ./determinize-lattice-pruned.h) and pushing (see ./push-lattice.h). If the lattice is not determinized and pushed this function will not combine as many states as it could, but it won't crash. Returns true on success, and false if it failed due to topological sorting failing. The output will be topologically sorted.

Definition at line 274 of file minimize-lattice.cc.

References CompactLatticeMinimizer< Weight, IntType >::Minimize().

Referenced by main(), DeterminizeLatticeTask::operator()(), and kaldi::TestMinimizeCompactLattice().

                 {
  CompactLatticeMinimizer<Weight, IntType> minimizer(clat, delta);
  return minimizer.Minimize();
}

MinimizeCompactLattice< kaldi::LatticeWeight, kaldi::int32 >()

template bool fst::MinimizeCompactLattice< kaldi::LatticeWeight, kaldi::int32 >	(	MutableFst< kaldi::CompactLatticeArc > *	clat,
		float	delta
	)

MinimizeEncoded()

void fst::MinimizeEncoded	(	VectorFst< Arc > *	fst,
		float	delta = kDelta
	)

Definition at line 114 of file fstext-utils.h.

References ApplyProbabilityScale(), ConvertNbestToVector(), EqualAlign(), FollowingInputSymbolsAreSame(), FollowingInputSymbolsAreSameClass(), GetLinearSymbolSequence(), IsStochasticFst(), IsStochasticFstInLog(), MakeFollowingInputSymbolsSame(), MakeFollowingInputSymbolsSameClass(), MakeLinearAcceptor(), MakeLinearAcceptorWithAlternatives(), MakeLoopFst(), MakePrecedingInputSymbolsSame(), MakePrecedingInputSymbolsSameClass(), MapInputSymbols(), rnnlm::n, NbestAsFsts(), PhiCompose(), PrecedingInputSymbolsAreSame(), PrecedingInputSymbolsAreSameClass(), PropagateFinal(), RemoveSomeInputSymbols(), RemoveUselessArcs(), RemoveWeights(), RhoCompose(), SafeDeterminizeMinimizeWrapper(), SafeDeterminizeMinimizeWrapperInLog(), and SafeDeterminizeWrapper().

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), main(), SafeDeterminizeMinimizeWrapper(), and SafeDeterminizeMinimizeWrapperInLog().

                                                                {

  Map(fst, QuantizeMapper<Arc>(delta));
  EncodeMapper<Arc> encoder(kEncodeLabels | kEncodeWeights, ENCODE);
  Encode(fst, &encoder);
  internal::AcceptorMinimize(fst);
  Decode(fst, encoder);
}

NbestAsFsts()

void NbestAsFsts	(	const Fst< Arc > &	fst,
		size_t	n,
		std::vector< VectorFst< Arc > > *	fsts_out
	)

Takes the n-shortest-paths (using ShortestPath), but outputs the result as a vector of up to n fsts.

This function will size the "fsts_out" vector to however many paths it got (which will not exceed n). n must be >= 1.

Definition at line 279 of file fstext-utils-inl.h.

References ConvertNbestToVector(), and KALDI_ASSERT.

Referenced by MinimizeEncoded(), kaldi::SentenceLevelConfidence(), and TestMakeLinearAcceptor().

                                                       {
  KALDI_ASSERT(n > 0);
  KALDI_ASSERT(fsts_out != NULL);
  VectorFst<Arc> nbest_fst;
  ShortestPath(fst, &nbest_fst, n);
  ConvertNbestToVector(nbest_fst, fsts_out);
}

NumArcs()

Arc::StateId NumArcs

(

const ExpandedFst< Arc > &

fst

)

Returns the total number of arcs in an FST.

Definition at line 67 of file fstext-utils-inl.h.

Referenced by kaldi::DeterminizeLatticeWrapper(), main(), and TrivialFactorWeightFstImpl< A, F >::NumArcs().

                                                         {
  typedef typename Arc::StateId StateId;
  StateId num_arcs = 0;
  for (StateId s = 0; s < fst.NumStates(); s++)
    num_arcs += fst.NumArcs(s);
  return num_arcs;
}

operator!=() [1/2]

bool fst::operator!= ( const LatticeWeightTpl< FloatType > &  wa, const LatticeWeightTpl< FloatType > &  wb  )

inline

Definition at line 277 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

                                                              {
  // Volatile qualifier thwarts over-aggressive compiler optimizations
  // that lead to problems esp. with NaturalLess().
  volatile FloatType va1 = wa.Value1(), va2 = wa.Value2(),
      vb1 = wb.Value1(), vb2 = wb.Value2();
  return (va1 != vb1 || va2 != vb2);
}

operator!=() [2/2]

bool fst::operator!= ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2  )

inline

Definition at line 564 of file lattice-weight.h.

References CompactLatticeWeightTpl< WeightType, IntType >::String(), and CompactLatticeWeightTpl< WeightType, IntType >::Weight().

                                                                               {
  return (w1.Weight() != w2.Weight() || w1.String() != w2.String());
}

operator<<() [1/2]

std::ostream & operator<< ( std::ostream &  strm, const LatticeWeightTpl< FloatType > &  w  )

inline

Definition at line 397 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::WriteFloatType().

                                                                                       {
  LatticeWeightTpl<FloatType>::WriteFloatType(strm, w.Value1());
  CHECK(FLAGS_fst_weight_separator.size() == 1);
  strm << FLAGS_fst_weight_separator[0]; // comma by default;
  // may or may not be settable from Kaldi programs.
  LatticeWeightTpl<FloatType>::WriteFloatType(strm, w.Value2());
  return strm;
}

operator<<() [2/2]

std::ostream& fst::operator<< ( std::ostream &  strm, const CompactLatticeWeightTpl< WeightType, IntType > &  w  )

inline

Definition at line 729 of file lattice-weight.h.

References rnnlm::i.

                                                                                                        {
  strm << w.Weight();
  CHECK(FLAGS_fst_weight_separator.size() == 1);
  strm << FLAGS_fst_weight_separator[0]; // comma by default.
  for(size_t i = 0; i < w.String().size(); i++) {
    strm << w.String()[i];
    if (i+1 < w.String().size())
      strm << kStringSeparator; // '_'; defined in string-weight.h in OpenFst code.
  }
  return strm;
}

operator==() [1/2]

bool fst::operator== ( const LatticeWeightTpl< FloatType > &  wa, const LatticeWeightTpl< FloatType > &  wb  )

inline

Definition at line 267 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by DiscriminativeSupervision::DiscriminativeSupervision(), and ArpaLmCompilerImplInterface::~ArpaLmCompilerImplInterface().

                                                              {
  // Volatile qualifier thwarts over-aggressive compiler optimizations
  // that lead to problems esp. with NaturalLess().
  volatile FloatType va1 = wa.Value1(), va2 = wa.Value2(),
      vb1 = wb.Value1(), vb2 = wb.Value2();
  return (va1 == vb1 && va2 == vb2);
}

operator==() [2/2]

bool fst::operator== ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2  )

inline

Definition at line 558 of file lattice-weight.h.

References CompactLatticeWeightTpl< WeightType, IntType >::String(), and CompactLatticeWeightTpl< WeightType, IntType >::Weight().

                                                                               {
  return (w1.Weight() == w2.Weight() && w1.String() == w2.String());
}

operator>>() [1/2]

std::istream & operator>> ( std::istream &  strm, LatticeWeightTpl< FloatType > &  w  )

inline

Definition at line 407 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::ReadNoParen().

                                                                                  {
  CHECK(FLAGS_fst_weight_separator.size() == 1);
  // separator defaults to ','
  return w1.ReadNoParen(strm, FLAGS_fst_weight_separator[0]);
}

operator>>() [2/2]

std::istream& fst::operator>> ( std::istream &  strm, CompactLatticeWeightTpl< WeightType, IntType > &  w  )

inline

Definition at line 742 of file lattice-weight.h.

References rnnlm::i, CompactLatticeWeightTpl< WeightType, IntType >::SetString(), and CompactLatticeWeightTpl< WeightType, IntType >::SetWeight().

                                                                                                  {
  std::string s;
  strm >> s;
  if (strm.fail()) {
    return strm;
  }
  CHECK(FLAGS_fst_weight_separator.size() == 1);
  size_t pos = s.find_last_of(FLAGS_fst_weight_separator); // normally ","
  if (pos == std::string::npos) {
    strm.clear(std::ios::badbit);
    return strm;
  }
  // get parts of str before and after the separator (default: ',');
  std::string s1(s, 0, pos), s2(s, pos+1);
  std::istringstream strm1(s1);
  WeightType weight;
  strm1 >> weight;
  w.SetWeight(weight);
  if (strm1.fail() || !strm1.eof()) {
    strm.clear(std::ios::badbit);
    return strm;
  }
  // read string part.
  std::vector<IntType> string;
  const char *c = s2.c_str();
  while(*c != '\0') {
    if (*c == kStringSeparator) // '_'
      c++;
    char *c2;
    long int i = strtol(c, &c2, 10);
    if (c2 == c || static_cast<long int>(static_cast<IntType>(i)) != i) {
      strm.clear(std::ios::badbit);
      return strm;
    }
    c = c2;
    string.push_back(static_cast<IntType>(i));
  }
  w.SetString(string);
  return strm;
}

PenalizeArcsWithSomeInputSymbols()

void fst::PenalizeArcsWithSomeInputSymbols	(	const std::vector< I > &	symbols_in,
		float	penalty,
		VectorFst< Arc > *	fst
	)

Definition at line 58 of file fstrmsymbols.cc.

References ConstIntegerSet< I >::count(), and Times().

Referenced by main().

                                                           {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Label Label;
  typedef typename Arc::Weight Weight;

  Weight penalty_weight(penalty);

  kaldi::ConstIntegerSet<I> symbol_set(symbols_in);

  StateId num_states = fst->NumStates();
  for (StateId s = 0; s < num_states; s++) {
    for (MutableArcIterator<VectorFst<Arc> > iter(fst, s);
         !iter.Done(); iter.Next()) {
      if (symbol_set.count(iter.Value().ilabel) != 0) {
        Arc arc = iter.Value();
        arc.weight = Times(arc.weight, penalty_weight);
        iter.SetValue(arc);
      }
    }
  }
}

PhiCompose()

void PhiCompose	(	const Fst< Arc > &	fst1,
		const Fst< Arc > &	fst2,
		typename Arc::Label	phi_label,
		MutableFst< Arc > *	ofst
	)

Definition at line 1021 of file fstext-utils-inl.h.

References KALDI_ASSERT.

Referenced by main(), and MinimizeEncoded().

                                       {
  KALDI_ASSERT(phi_label != kNoLabel); // just use regular compose in this case.
  typedef Fst<Arc> F;
  typedef PhiMatcher<SortedMatcher<F> > PM;
  CacheOptions base_opts;
  base_opts.gc_limit = 0; // Cache only the last state for fastest copy.
  // ComposeFstImplOptions templated on matcher for fst1, matcher for fst2.
  // The matcher for fst1 doesn't matter; we'll use fst2's matcher.
  ComposeFstImplOptions<SortedMatcher<F>, PM> impl_opts(base_opts);

  // the false below is something called phi_loop which is something I don't
  // fully understand, but I don't think we want it.

  // These pointers are taken ownership of, by ComposeFst.
  PM *phi_matcher =
      new PM(fst2, MATCH_INPUT, phi_label, false);
  SortedMatcher<F> *sorted_matcher =
      new SortedMatcher<F>(fst1, MATCH_NONE); // tell it
  // not to use this matcher, as this would mean we would
  // not follow phi transitions.
  impl_opts.matcher1 = sorted_matcher;
  impl_opts.matcher2 = phi_matcher;
  *ofst = ComposeFst<Arc>(fst1, fst2, impl_opts);
  Connect(ofst);
}

Plus() [1/5]

ArcticWeightTpl<T> fst::Plus ( const ArcticWeightTpl< T > &  w1, const ArcticWeightTpl< T > &  w2  )

inline

Definition at line 87 of file arctic-weight.h.

                                                               {
  return w1.Value() > w2.Value() ? w1 : w2;
}

Plus() [2/5]

ArcticWeightTpl<float> fst::Plus ( const ArcticWeightTpl< float > &  w1, const ArcticWeightTpl< float > &  w2  )

inline

Definition at line 92 of file arctic-weight.h.

                                                                       {
  return Plus<float>(w1, w2);
}

Plus() [3/5]

ArcticWeightTpl<double> fst::Plus ( const ArcticWeightTpl< double > &  w1, const ArcticWeightTpl< double > &  w2  )

inline

Definition at line 97 of file arctic-weight.h.

                                                                         {
  return Plus<double>(w1, w2);
}

Plus() [4/5]

LatticeWeightTpl<FloatType> fst::Plus ( const LatticeWeightTpl< FloatType > &  w1, const LatticeWeightTpl< FloatType > &  w2  )

inline

Definition at line 311 of file lattice-weight.h.

References Compare().

Referenced by DeterminizerStar< F >::EpsilonClosure::AddOneElement(), CompactLatticeWeightTest(), DeterminizerStar< F >::EpsilonClosure::GetEpsilonClosure(), IsStochasticFst(), LatticeWeightTest(), LatticeDeterminizerPruned< Weight, IntType >::NormalizeSubset(), LatticeDeterminizer< Weight, IntType >::NormalizeSubset(), ReweightPlusDefault< Weight >::operator()(), ReweightPlusLogArc::operator()(), CompactLatticeWeightCommonDivisorTpl< BaseWeightType, IntType >::operator()(), LatticePhoneAligner::ProcessFinal(), LatticeWordAligner::ProcessFinal(), DeterminizerStar< F >::ProcessFinal(), DeterminizerStar< F >::ProcessTransition(), PushCompactLatticeWeights(), RemoveEpsLocalClass< Arc, ReweightPlus >::RemoveEpsPattern1(), RemoveEpsLocalClass< Arc, ReweightPlus >::RemoveEpsPattern2(), LatticeIncrementalDeterminizer::SetFinalCosts(), kaldi::TestPushCompactLatticeWeights(), TestRemoveEpsLocalSpecial(), and kaldi::UnitTestAddOuterProductPlusMinus().

                                                                               {
  return (Compare(w1, w2) >= 0 ? w1 : w2);
}

Plus() [5/5]

CompactLatticeWeightTpl<WeightType, IntType> fst::Plus ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2  )

inline

Definition at line 664 of file lattice-weight.h.

References Compare().

                                                            {
  return (Compare(w1, w2) >= 0 ? w1 : w2);
}

PrecedingInputSymbolsAreSame()

bool PrecedingInputSymbolsAreSame	(	bool	start_is_epsilon,
		const Fst< Arc > &	fst
	)

Returns true if and only if the FST is such that the input symbols on arcs entering any given state all have the same value.

if "start_is_epsilon", treat start-state as an epsilon input arc [i.e. ensure only epsilon can enter start-state].

Definition at line 460 of file fstext-utils-inl.h.

References PrecedingInputSymbolsAreSameClass().

Referenced by MinimizeEncoded(), and TestMakeSymbolsSame().

                                                                              {
  IdentityFunction<typename Arc::Label> f;
  return PrecedingInputSymbolsAreSameClass(start_is_epsilon, fst, f);
}

PrecedingInputSymbolsAreSameClass()

bool PrecedingInputSymbolsAreSameClass	(	bool	start_is_epsilon,
		const Fst< Arc > &	fst,
		const F &	f
	)

This is as PrecedingInputSymbolsAreSame, but with a functor f that maps labels to classes.

The function tests whether the symbols preceding any given state are in the same class. Formally, f is of a type F that has an operator of type F::Result F::operator() (F::Arg a) const; where F::Result is an integer type and F::Arc can be constructed from Arc::Label. this must apply to valid labels and also to kNoLabel (so we can have a marker for the invalid labels.

Definition at line 466 of file fstext-utils-inl.h.

Referenced by MinimizeEncoded(), PrecedingInputSymbolsAreSame(), and TestMakeSymbolsSameClass().

                                                                                               {
  typedef typename F::Result ClassType;
  typedef typename Arc::StateId StateId;
  std::vector<ClassType> classes;
  ClassType noClass = f(kNoLabel);

  if (start_is_epsilon) {
    StateId start_state = fst.Start();
    if (start_state < 0 || start_state == kNoStateId)
      return true;  // empty fst-- doesn't matter.
    classes.resize(start_state+1, noClass);
    classes[start_state] = 0;
  }

  for (StateIterator<Fst<Arc> > siter(fst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    for (ArcIterator<Fst<Arc> > aiter(fst, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (classes.size() <= arc.nextstate)
        classes.resize(arc.nextstate+1, noClass);
      if (classes[arc.nextstate] == noClass)
        classes[arc.nextstate] = f(arc.ilabel);
      else
        if (classes[arc.nextstate] != f(arc.ilabel))
          return false;
    }
  }
  return true;
}

PreDeterminize()

void PreDeterminize	(	MutableFst< Arc > *	fst,
		typename Arc::Label	first_new_sym,
		std::vector< Int > *	symsOut
	)

Definition at line 317 of file pre-determinize-inl.h.

References fst::pre_determinize_helpers::Closure(), fst::pre_determinize_helpers::CopySetToVector(), CreateSuperFinal(), rnnlm::i, fst::pre_determinize_helpers::InsertMember(), KALDI_ASSERT, KALDI_ERR, KALDI_VLOG, and rnnlm::n.

Referenced by SafeDeterminizeMinimizeWrapper(), SafeDeterminizeWrapper(), TestDeterminize(), TestDeterminizeStarInLog(), TestFactor(), TestMinimize(), TestPreDeterminize(), and TestPush().

                                             {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef size_t ArcId;  // Our own typedef, not standard OpenFst.  Use size_t
  // for compatibility with argument of ArcIterator::Seek().
  typedef typename Arc::Weight Weight;
  assert(first_new_sym > 0);
  assert(fst != NULL);
  if (fst->Start() == kNoStateId) return;  // for empty FST, nothing to do.
  assert(symsOut != NULL && symsOut->size() == 0);  // we will output the symbols we add into this.

  {  // (D)(i)(a): check is trim (i.e. connected, in OpenFST parlance).
    KALDI_VLOG(2) <<  "PreDeterminize: Checking FST properties";
    uint64 props = fst->Properties(kAccessible|kCoAccessible, true);  // true-> computes properties if unknown at time when called.
    if (props != (kAccessible|kCoAccessible)) {  // All states are not both accessible and co-accessible...
      KALDI_ERR << "PreDeterminize: FST is not trim";
    }
  }

  {  // (D)(i)(b): make single final state.
    KALDI_VLOG(2) <<  "PreDeterminize: creating single final state";
    CreateSuperFinal(fst);
  }

  {  // (D)(i)(c): sort arcs on input.
    KALDI_VLOG(2) <<  "PreDeterminize: sorting arcs on input";
    ILabelCompare<Arc> icomp;
    ArcSort(fst, icomp);
  }

  StateId n_states = 0, max_state = 0;  // Compute n_states, max_state = highest-numbered state.
  {  // compute nStates, maxStates.
    for (StateIterator<MutableFst<Arc> > iter(*fst); ! iter.Done(); iter.Next()) {
      StateId state = iter.Value();
      assert(state>=0);
      n_states++;
      if (state > max_state) max_state = state;
    }
    KALDI_VLOG(2) <<  "PreDeterminize: n_states = "<<(n_states)<<", max_state ="<<(max_state);
  }

  std::vector<bool> p_vec(max_state+1, false);  // compute this next.
  {  // D(ii): computing the array p. ["problematic states, i.e. states with >1 input transition,
    // counting being the initial state as an input transition"].
    std::vector<bool> seen_vec(max_state+1, false);  // rather than counting incoming transitions we just have a bool that says we saw at least one.

    seen_vec[fst->Start()] = true;
    for (StateIterator<MutableFst<Arc> > siter(*fst); ! siter.Done(); siter.Next()) {
      for (ArcIterator<MutableFst<Arc> > aiter(*fst, siter.Value()); ! aiter.Done(); aiter.Next()) {
        const Arc &arc = aiter.Value();
        assert(arc.nextstate>=0&&arc.nextstate<max_state+1);
        if (seen_vec[arc.nextstate])
          p_vec[arc.nextstate] = true;  // now have >1 transition in, so problematic.
        else
          seen_vec[arc.nextstate] = true;
      }
    }
  }
  // D(iii): set up m(a)
  std::map<std::pair<StateId, ArcId>, size_t> m_map;
  // This is the array m, indexed by arcs.  It maps to the index of the symbol we add.


  // WARNING: we should be sure to clean up this memory before exiting.  Do not return
  // or throw an exception from this function, later than this point, without cleaning up!
  // Note that the vectors are shared between Q and S (they "belong to" S.
  std::vector<std::vector<StateId>* > S(max_state+1, (std::vector<StateId>*)(void*)0);
  std::vector<std::pair<std::vector<StateId>*, size_t> > Q;

  // D(iv): initialize S and Q.
  {
    std::vector<StateId> all_seed_states;  // all "problematic" states, plus initial state (if not problematic).
    if (!p_vec[fst->Start()])
      all_seed_states.push_back(fst->Start());
    for (StateId s = 0;s<=max_state; s++)
      if (p_vec[s]) all_seed_states.push_back(s);

    for (size_t idx = 0;idx < all_seed_states.size(); idx++) {
      StateId s = all_seed_states[idx];
      std::set<StateId> closure_s;
      closure_s.insert(s);  // insert "seed" state.
      pre_determinize_helpers::Closure(fst, &closure_s, p_vec);  // follow epsilons to non-problematic states.
      // Closure in this case whis will usually not add anything, for typical topologies in speech
      std::vector<StateId> closure_s_vec;
      pre_determinize_helpers::CopySetToVector(closure_s, &closure_s_vec);
      KALDI_ASSERT(closure_s_vec.size() != 0);
      std::vector<StateId> *ptr = pre_determinize_helpers::InsertMember(closure_s_vec, &S);
      KALDI_ASSERT(ptr != NULL);  // Or conceptual bug or programming error.
      Q.push_back(std::pair<std::vector<StateId>*, size_t>(ptr, 0));
    }
  }

  std::vector<bool> d_vec(max_state+1, false);  // "done vector".  Purely for debugging.


  size_t num_extra_det_states = 0;

  // (D)(v)
  while (Q.size() != 0) {

    // (D)(v)(a)
    std::pair<std::vector<StateId>*, size_t> cur_pair(Q.back());
    Q.pop_back();
    const std::vector<StateId> &A(*cur_pair.first);
    size_t n =cur_pair.second;  // next special symbol to add.

    // (D)(v)(b)
    for (size_t idx = 0;idx < A.size(); idx++) {
      assert(d_vec[A[idx]] == false && "This state has been seen before.  Algorithm error.");
      d_vec[A[idx]] = true;
    }

    // From here is (D)(v)(c).  We work out S_\eps and S_t (for t\neq eps)
    // simultaneously at first.
    std::map<Label, std::set<std::pair<std::pair<StateId, ArcId>, StateId> > > arc_hash;
    // arc_hash is a hash with info of all arcs from states in the set A to
    // non-problematic states.
    // It is a map from ilabel to pair(pair(start-state, arc-offset), end-state).
    // Here, arc-offset reflects the order in which we accessed the arc using the
    // ArcIterator (zero for the first arc).


    {  // This block sets up arc_hash
      for (size_t idx = 0;idx < A.size(); idx++) {
        StateId s = A[idx];
        assert(s>=0 && s<=max_state);
        ArcId arc_id = 0;
        for (ArcIterator<MutableFst<Arc> > aiter(*fst, s); ! aiter.Done(); aiter.Next(), ++arc_id) {
          const Arc &arc = aiter.Value();

          std::pair<std::pair<StateId, ArcId>, StateId>
              this_pair(std::pair<StateId, ArcId>(s, arc_id), arc.nextstate);
          bool inserted = (arc_hash[arc.ilabel].insert(this_pair)).second;
          assert(inserted);  // Otherwise we had a duplicate.
        }
      }
    }

    // (D)(v)(d)
    if (arc_hash.count(0) == 1) {  // We have epsilon transitions out.
      std::set<std::pair<std::pair<StateId, ArcId>, StateId> >  &eps_set = arc_hash[0];
      typedef typename std::set<std::pair<std::pair<StateId, ArcId>, StateId> >::iterator set_iter_t;
      for (set_iter_t siter = eps_set.begin(); siter != eps_set.end(); ++siter) {
        const std::pair<std::pair<StateId, ArcId>, StateId>  &this_pr = *siter;
        if (p_vec[this_pr.second]) {  // Eps-transition to problematic state.
          assert(m_map.count(this_pr.first) == 0);
          m_map[this_pr.first] = n;
          n++;
        }
      }
    }

    // (D)(v)(e)
    {
      typedef typename std::map<Label, std::set<std::pair<std::pair<StateId, ArcId>, StateId> > >::iterator map_iter_t;
      typedef typename std::set<std::pair<std::pair<StateId, ArcId>, StateId> >::iterator set_iter_t2;
      for (map_iter_t miter = arc_hash.begin(); miter != arc_hash.end(); ++miter) {
        Label t = miter->first;
        std::set<std::pair<std::pair<StateId, ArcId>, StateId> >  &S_t = miter->second;
        if (t != 0) {  // For t != epsilon,
          std::set<StateId> V_t;  // set of destination non-problem states.  Will create this set now.

          // exists_noproblem is true iff |U_t| > 0.
          size_t k = 0;

          // First loop "for each transition a in T_t" (i.e. transitions to problematic states)
          // The if-statement if (|S_t|>1) is pushed inside the loop, as the loop also computes
          // the set V_t.
          for (set_iter_t2 siter = S_t.begin(); siter != S_t.end(); ++siter) {
            const std::pair<std::pair<StateId, ArcId>, StateId>  &this_pr = *siter;
            if (p_vec[this_pr.second]) {  // only consider problematic states (just set T_t)
              if (S_t.size() > 1) {  // This is where we pushed the if-statement in.
                assert(m_map.count(this_pr.first) == 0);
                m_map[this_pr.first] = k;
                k++;
                num_extra_det_states++;
              }
            } else {  // Create the set V_t.
              V_t.insert(this_pr.second);
            }
          }
          if (V_t.size() != 0) {
            pre_determinize_helpers::Closure(fst, &V_t, p_vec);  // follow epsilons to non-problematic states.
            std::vector<StateId> closure_V_t_vec;
            pre_determinize_helpers::CopySetToVector(V_t, &closure_V_t_vec);
            std::vector<StateId> *ptr = pre_determinize_helpers::InsertMember(closure_V_t_vec, &S);
            if (ptr != NULL) {  // was inserted.
              Q.push_back(std::pair<std::vector<StateId>*, size_t>(ptr, k));
            }
          }
        }
      }
    }
  } // end while (Q.size() != 0)


  {  // (D)(vi): Check that for each state in the FST, d(s) = true.
    for (StateIterator<MutableFst<Arc> > siter(*fst); ! siter.Done(); siter.Next()) {
      StateId val = siter.Value();
      assert(d_vec[val] == true);
    }
  }

  {  // (D)(vii): compute symbol-table ID's.
    // sets up symsOut array.
    int64 n = -1;
    for (typename std::map<std::pair<StateId, ArcId>, size_t>::iterator m_iter = m_map.begin();
        m_iter != m_map.end();
        ++m_iter) {
      n = std::max(n, (int64) m_iter->second);  // m_iter->second is of type size_t.
    }
    // At this point n is the highest symbol-id (type size_t) of symbols we must add.
    n++;  // This is now the number of symbols we must add.
    for (size_t i = 0;static_cast<int64>(i)<n;i++) symsOut->push_back(first_new_sym + i);
  }

  // (D)(viii): set up hash.
  std::map<std::pair<StateId, size_t>, StateId> h_map;

  {  // D(ix): add extra symbols!  This is where the work gets done.

    // Core part of this is below, search for (*)
    size_t n_states_added = 0;

    for (typename std::map<std::pair<StateId, ArcId>, size_t>::iterator m_iter = m_map.begin();
        m_iter != m_map.end();
        ++m_iter) {
      StateId state = m_iter->first.first;
      ArcId arcpos = m_iter->first.second;
      size_t m_a = m_iter->second;

      MutableArcIterator<MutableFst<Arc> > aiter(fst, state);
      aiter.Seek(arcpos);
      Arc arc = aiter.Value();

      // (*) core part here.
      if (arc.ilabel == 0)
        arc.ilabel = (*symsOut)[m_a];
      else {
        std::pair<StateId, size_t> pr(arc.nextstate, m_a);
        if (!h_map.count(pr)) {
          n_states_added++;
          StateId newstate = fst->AddState();
          assert(newstate>=0);
          Arc new_arc( (*symsOut)[m_a], (Label)0, Weight::One(), arc.nextstate);
          fst->AddArc(newstate, new_arc);
          h_map[pr] = newstate;
        }
        arc.nextstate = h_map[pr];
      }
      aiter.SetValue(arc);
    }

    KALDI_VLOG(2) <<  "Added " <<(n_states_added)<<" new states and added/changed "<<(m_map.size())<<" arcs";

  }
  // Now free up memory.
  for (size_t i = 0;i < S.size();i++)
    delete S[i];
} // end function PreDeterminize

PrepareForGrammarFst()

void PrepareForGrammarFst	(	int32	nonterm_phones_offset,
		VectorFst< StdArc > *	fst
	)

This function prepares 'ifst' for use in GrammarFst: it ensures that it has the expected properties, changing it slightly as needed.

'ifst' is expected to be a fully compiled HCLG graph that is intended to be used in GrammarFst. The user will most likely want to copy it to the ConstFst type after calling this function.

The following describes what this function does, and the reasons why it has to do these things:

• To keep the ArcIterator code simple (to avoid branches in loops), even for expanded states we store the destination fst-instance index separately per state, not per arc. This requires that any transitions across FST boundaries from a single FST must be to a single destination FST (for a given source state). We fix this problem by introducing epsilon arcs and new states whenever we find a state that would cause a problem for the above.
• In order to signal to the GrammarFst code that a particular state has cross-FST-boundary transitions, we set the final-prob to a nonzero value on that state. Specifically, we use a weight with Value() == 4096.0. When the GrammarFst code sees that value it knows that it was not a 'real' final-prob. Prior to doing this we ensure, by adding epsilon transitions as needed, that the state did not previously have a final-prob.
• For arcs that are final arcs in an FST that represents a nonterminal (these arcs would have #nonterm_exit on them), we ensure that the states that they transition to have unit final-prob (i.e. final-prob equal to One()), by incorporating any final-prob into the arc itself. This avoids the GrammarFst code having to inspect those final-probs when expanding states.

Parameters

[in]	nonterm_phones_offset	The integer id of the symbols #nonterm_bos in the phones.txt file.
[in,out]	fst	The FST to be (slightly) modified.

Definition at line 982 of file grammar-fst.cc.

References GrammarFstPreparer::Prepare().

Referenced by main().

                                                  {
  GrammarFstPreparer p(nonterm_phones_offset, fst);
  p.Prepare();
}

Print()

void fst::Print	(	const Fst< Arc > &	fst,
		std::string	message
	)

Definition at line 362 of file fstext-utils-test.cc.

Referenced by TransitionModel::GetPhones(), MaxChangeStats::MaxChangeStats(), NnetDiscriminativeStats::NnetDiscriminativeStats(), DiscriminativeObjectiveInfo::PrintAll(), SplitExampleStats::SplitExampleStats(), and GeneralDescriptor::~GeneralDescriptor().

                                                                       {
  std::cout << message << "\n";
  FstPrinter<Arc> fstprinter(fst, NULL, NULL, NULL, false, true, "\t");
  fstprinter.Print(&std::cout, "standard output");
}

PrintProxyFstPath()

bool PrintProxyFstPath	(	const VectorFst< StdArc > &	proxy,
		vector< vector< StdArc::Label > > *	path,
		vector< StdArc::Weight > *	weight,
		StdArc::StateId	cur_state,
		vector< StdArc::Label >	cur_path,
		StdArc::Weight	cur_weight
	)

Definition at line 30 of file generate-proxy-keywords.cc.

References Times().

Referenced by main().

                                                {
  if (proxy.Final(cur_state) != StdArc::Weight::Zero()) {
    // Assumes only final state has non-zero weight.
    cur_weight = Times(proxy.Final(cur_state), cur_weight);
    path->push_back(cur_path);
    weight->push_back(cur_weight);
    return true;
  }

  for (ArcIterator<StdFst> aiter(proxy, cur_state);
       !aiter.Done(); aiter.Next()) {
    const StdArc &arc = aiter.Value();
    StdArc::Weight temp_weight = Times(arc.weight, cur_weight);
    cur_path.push_back(arc.ilabel);
    PrintProxyFstPath(proxy, path, weight,
                      arc.nextstate, cur_path, temp_weight);
    cur_path.pop_back();
  }

  return true;
}

PropagateFinal()

void PropagateFinal	(	typename Arc::Label	phi_label,
		MutableFst< Arc > *	fst
	)

Definition at line 1084 of file fstext-utils-inl.h.

References KALDI_WARN, and PropagateFinalInternal().

Referenced by main(), and MinimizeEncoded().

                                          {
  typedef typename Arc::StateId StateId;
  if (fst->Properties(kIEpsilons, true)) // just warn.
    KALDI_WARN << "PropagateFinal: this may not work as desired "
        "since your FST has input epsilons.";
  StateId num_states = fst->NumStates();
  for (StateId s = 0; s < num_states; s++)
    PropagateFinalInternal(phi_label, s, fst);
}

PropagateFinalInternal()

void fst::PropagateFinalInternal	(	typename Arc::Label	phi_label,
		typename Arc::StateId	s,
		MutableFst< Arc > *	fst
	)

Definition at line 1051 of file fstext-utils-inl.h.

References KALDI_ASSERT, and Times().

Referenced by PropagateFinal().

                          {
  typedef typename Arc::Weight Weight;
  if (fst->Final(s) == Weight::Zero()) {
    // search for phi transition.  We assume there
    // is just one-- phi nondeterminism is not allowed
    // anyway.
    int num_phis = 0;
    for (ArcIterator<Fst<Arc> > aiter(*fst, s);
         !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (arc.ilabel == phi_label) {
        num_phis++;
        if (arc.nextstate == s) continue; // don't expect
        // phi loops but ignore them anyway.

        // If this recurses infinitely, it means there
        // are loops of phi transitions, which there should
        // not be in a normal backoff LM.  We could make this
        // routine work for this case, but currently there is
        // no need.
        PropagateFinalInternal(phi_label, arc.nextstate, fst);
        if (fst->Final(arc.nextstate) != Weight::Zero())
          fst->SetFinal(s, Times(fst->Final(arc.nextstate), arc.weight));
      }
      KALDI_ASSERT(num_phis <= 1 && "Phi nondeterminism found");
    }
  }
}

PruneCompactLattice()

void fst::PruneCompactLattice	(	Weight	beam,
		MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > *	fst
	)

Referenced by LatticeToStdMapper< Real >::Properties().

PruneSpecial()

void PruneSpecial	(	const Fst< Arc > &	ifst,
		VectorFst< Arc > *	ofst,
		typename Arc::Weight	beam,
		size_t	max_states = 0
	)

The function PruneSpecial is like the standard OpenFst function "prune", except it does not expand the entire "ifst"- this is useful for cases where ifst is an on-demand FST such as a ComposeFst and we don't want to visit it all.

It supports pruning either to a specified beam (if beam is not One()), or to a specified max_states (if max_states is > 0). One of the two must be specified.

Requirements:

• Costs must be non-negative (equivalently, weights must not be greater than One()).
• There must be a Compare(a, b) function that compares two weights and returns (-1,0,1) if (a<b, a=b, a>b). We define this in Kaldi, for TropicalWeight, LogWeight (I think), and LatticeWeight... also CompactLatticeWeight, but we doubt that will be used here; better to use PruneCompactLattice().

Definition at line 161 of file prune-special-inl.h.

Referenced by main().

                                     {
  PruneSpecialClass<Arc> c(ifst, ofst, beam, max_states);
}

PushCompactLatticeStrings()

bool PushCompactLatticeStrings

(

MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *

clat

)

This function pushes the transition-ids as far towards the start as they will go.

It can be useful prior to lattice-align-words (for non-linear lattices). We can't use the generic OpenFst "push" function because it uses the sum as the divisor, which is not appropriate in this case (a+b generally won't divide a or b in this semiring). It returns true on success, false if it failed due to TopSort failing, which should never happen, but we handle it gracefully by just leaving the lattice the same. This function used to be called just PushCompactLattice.

Definition at line 210 of file push-lattice.cc.

References CompactLatticePusher< Weight, IntType >::Push().

Referenced by main(), DeterminizeLatticeTask::operator()(), kaldi::TestMinimizeCompactLattice(), and kaldi::TestPushCompactLatticeStrings().

                                                                          {
  CompactLatticePusher<Weight, IntType> pusher(clat);
  return pusher.Push();
}

PushCompactLatticeStrings< kaldi::LatticeWeight, kaldi::int32 >()

template bool fst::PushCompactLatticeStrings< kaldi::LatticeWeight, kaldi::int32 >

(

MutableFst< kaldi::CompactLatticeArc > *

clat

)

PushCompactLatticeWeights()

bool PushCompactLatticeWeights

(

MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, IntType > > > *

clat

)

This function pushes the weights in the CompactLattice so that all states except possibly the start state, have Weight components (of type LatticeWeight) that "sum to one" in the LatticeWeight (i.e.

interpreting the weights as negated log-probs). It returns true on success, false if it failed due to TopSort failing, which should never happen, but we handle it gracefully by just leaving the lattice the same.

Definition at line 217 of file push-lattice.cc.

References Divide(), KALDI_ASSERT, KALDI_WARN, Plus(), Times(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by main(), DeterminizeLatticeTask::operator()(), kaldi::TestMinimizeCompactLattice(), and kaldi::TestPushCompactLatticeWeights().

                                                                         {
  if (clat->Properties(kTopSorted, true) == 0) {
    if (!TopSort(clat)) {
      KALDI_WARN << "Topological sorting of state-level lattice failed "
          "(probably your lexicon has empty words or your LM has epsilon cycles; this "
          " is a bad idea.)";
      return false;
    }
  }
  typedef CompactLatticeWeightTpl<Weight, IntType> CompactWeight;
  typedef ArcTpl<CompactWeight> CompactArc;
  typedef typename CompactArc::StateId StateId;

  StateId num_states = clat->NumStates();
  if (num_states == 0) {
    KALDI_WARN << "Pushing weights of empty compact lattice";
    return true; // this is technically success because an empty
                 // lattice is already pushed.
  }
  std::vector<Weight> weight_to_end(num_states); // Note: LatticeWeight
                                                 // contains two floats.
  for (StateId s = num_states - 1; s >= 0; s--) {
    Weight this_weight_to_end = clat->Final(s).Weight();
    for (ArcIterator<MutableFst<CompactArc> > aiter(*clat, s);
         !aiter.Done(); aiter.Next()) {
      const CompactArc &arc = aiter.Value();
      KALDI_ASSERT(arc.nextstate > s && "Cyclic lattices not allowed.");
      this_weight_to_end = Plus(this_weight_to_end,
                                Times(aiter.Value().weight.Weight(),
                                      weight_to_end[arc.nextstate]));
    }
    if (this_weight_to_end == Weight::Zero()) {
      KALDI_WARN << "Lattice has non-coaccessible states.";
    }
    weight_to_end[s] = this_weight_to_end;
  }
  weight_to_end[0] = Weight::One(); // We leave the "leftover weight" on
                                    // the start state, which won't
                                    // necessarily end up summing to one.
  for (StateId s = 0; s < num_states; s++) {
    Weight this_weight_to_end = weight_to_end[s];
    if (this_weight_to_end == Weight::Zero())
      continue;
    for (MutableArcIterator<MutableFst<CompactArc> > aiter(clat, s);
         !aiter.Done(); aiter.Next()) {
      CompactArc arc = aiter.Value();
      Weight next_weight_to_end = weight_to_end[arc.nextstate];
      if (next_weight_to_end != Weight::Zero()) {
        arc.weight.SetWeight(Times(arc.weight.Weight(),
                                   Divide(next_weight_to_end,
                                          this_weight_to_end)));
        aiter.SetValue(arc);
      }
    }
    CompactWeight final_weight = clat->Final(s);
    if (final_weight != CompactWeight::Zero()) {
      final_weight.SetWeight(Divide(final_weight.Weight(), this_weight_to_end));
      clat->SetFinal(s, final_weight);
    }
  }
  
  return true;
}

PushCompactLatticeWeights< kaldi::LatticeWeight, kaldi::int32 >()

template bool fst::PushCompactLatticeWeights< kaldi::LatticeWeight, kaldi::int32 >

(

MutableFst< kaldi::CompactLatticeArc > *

clat

)

PushInLog()

void fst::PushInLog	(	VectorFst< StdArc > *	fst,
		uint32	ptype,
		float	delta = kDelta
	)

Definition at line 91 of file fstext-utils.h.

                                                                           {

  // PushInLog pushes the FST
  // and returns a new pushed FST (labels and weights pushed to the left).
  VectorFst<LogArc> *fst_log = new VectorFst<LogArc>;  // Want to determinize in log semiring.
  Cast(*fst, fst_log);
  VectorFst<StdArc> tmp;
  *fst = tmp;  // free up memory.
  VectorFst<LogArc> *fst_pushed_log = new VectorFst<LogArc>;
  Push<LogArc, rtype>(*fst_log, fst_pushed_log, ptype, delta);
  Cast(*fst_pushed_log, fst);
  delete fst_log;
  delete fst_pushed_log;
}

PushSpecial()

void PushSpecial	(	VectorFst< StdArc > *	fst,
		float	delta
	)

Definition at line 226 of file push-special.cc.

Referenced by main(), and TestPushSpecial().

                                                      {
  if (fst->NumStates() > 0)
    PushSpecialClass c(fst, delta); // all the work
  // gets done in the initializer.
}

RandFst()

VectorFst<Arc>* fst::RandFst

(

RandFstOptions

opts = RandFstOptions()

)

Returns a random FST.

Useful for randomized algorithm testing. Only works if weight can be constructed from float.

Definition at line 56 of file rand-fst.h.

References rnnlm::i, rnnlm::j, and kaldi::Rand().

                                                                                     {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();

 start:

  // Create states.
  std::vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)opts.n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)opts.n_final;j++) {
    StateId id = all_states[kaldi::Rand() % opts.n_states];
    Weight weight = (Weight)(opts.weight_multiplier*(kaldi::Rand() % 5));
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)opts.n_arcs;i++) {
    Arc a;
    StateId start_state;
    if(!opts.acyclic) { // no restriction on arcs.
      start_state = all_states[kaldi::Rand() % opts.n_states];
      a.nextstate = all_states[kaldi::Rand() % opts.n_states];
    } else {
      start_state = all_states[kaldi::Rand() % (opts.n_states-1)];
      a.nextstate = start_state + 1 + (kaldi::Rand() % (opts.n_states-start_state-1));
    }
    a.ilabel = kaldi::Rand() % opts.n_syms;
    a.olabel = kaldi::Rand() % opts.n_syms;  // same input+output vocab.
    a.weight = (Weight) (opts.weight_multiplier*(kaldi::Rand() % 4));

    fst->AddArc(start_state, a);
  }

  // Trim resulting FST.
  Connect(fst);
  if (opts.acyclic)
    assert(fst->Properties(kAcyclic, true) & kAcyclic);
  if (fst->Start() == kNoStateId && !opts.allow_empty) {
    goto start;
  }
  return fst;
}

RandomCompactLatticeWeight()

CompactLatticeWeight fst::RandomCompactLatticeWeight

(

)

Definition at line 51 of file lattice-weight-test.cc.

References rnnlm::i, kaldi::Rand(), RandomLatticeWeight(), and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by CompactLatticeWeightTest().

                                                  {
  LatticeWeight w = RandomLatticeWeight();
  if (w == LatticeWeight::Zero()) {
    return CompactLatticeWeight(w, vector<int32>());
  } else {
    int32 len = kaldi::Rand() % 4;
    vector<int32> str;
    for(int32 i = 0; i < len; i++)
      str.push_back(kaldi::Rand() % 10 + 1);
    return CompactLatticeWeight(w, str);
  }
}

RandomLatticeWeight()

LatticeWeight fst::RandomLatticeWeight

(

)

Definition at line 38 of file lattice-weight-test.cc.

References kaldi::Rand(), kaldi::RandGauss(), and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by LatticeWeightTest(), and RandomCompactLatticeWeight().

                                    {
  int tmp = kaldi::Rand() % 4;
  if (tmp == 0) {
    return LatticeWeight::Zero();
  } else if (tmp == 1) {
    return LatticeWeight( 1, 2);  // sometimes return special values..
  } else if (tmp == 2) {
    return LatticeWeight( 2, 1);  // this tests more thoroughly certain properties...
  } else {
    return LatticeWeight( 100 * kaldi::RandGauss(), 100 * kaldi::RandGauss());
  }
}

RandPairFst()

VectorFst<Arc>* fst::RandPairFst

(

RandFstOptions

opts = RandFstOptions()

)

Returns a random FST.

Useful for randomized algorithm testing. Only works if weight can be constructed from a pair of floats

Definition at line 108 of file rand-fst.h.

References rnnlm::i, rnnlm::j, and kaldi::Rand().

                                                                                         {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();

 start:

  // Create states.
  std::vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)opts.n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0; j < (size_t)opts.n_final;j++) {
    StateId id = all_states[kaldi::Rand() % opts.n_states];
    Weight weight (opts.weight_multiplier*(kaldi::Rand() % 5), opts.weight_multiplier*(kaldi::Rand() % 5));
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)opts.n_arcs;i++) {
    Arc a;
    StateId start_state;
    if(!opts.acyclic) { // no restriction on arcs.
      start_state = all_states[kaldi::Rand() % opts.n_states];
      a.nextstate = all_states[kaldi::Rand() % opts.n_states];
    } else {
      start_state = all_states[kaldi::Rand() % (opts.n_states-1)];
      a.nextstate = start_state + 1 + (kaldi::Rand() % (opts.n_states-start_state-1));
    }
    a.ilabel = kaldi::Rand() % opts.n_syms;
    a.olabel = kaldi::Rand() % opts.n_syms;  // same input+output vocab.
    a.weight = Weight (opts.weight_multiplier*(kaldi::Rand() % 4), opts.weight_multiplier*(kaldi::Rand() % 4));

    fst->AddArc(start_state, a);
  }

  // Trim resulting FST.
  Connect(fst);
  if (opts.acyclic)
    assert(fst->Properties(kAcyclic, true) & kAcyclic);
  if (fst->Start() == kNoStateId && !opts.allow_empty) {
    goto start;
  }
  return fst;
}

ReadAndPrepareLmFst()

fst::VectorFst< fst::StdArc > * ReadAndPrepareLmFst

(

std::string

rxfilename

)

Definition at line 125 of file kaldi-fst-io.cc.

References ReadFstKaldi().

Referenced by main().

                                                                   {
  // ReadFstKaldi() will die with exception on failure.
  fst::VectorFst<fst::StdArc> *ans = fst::ReadFstKaldi(rxfilename);
  if (ans->Properties(fst::kAcceptor, true) == 0) {
    // If it's not already an acceptor, project on the output, i.e. copy olabels
    // to ilabels.  Generally the G.fst's on disk will have the disambiguation
    // symbol #0 on the input symbols of the backoff arc, and projection will
    // replace them with epsilons which is what is on the output symbols of
    // those arcs.
    fst::Project(ans, fst::PROJECT_OUTPUT);
  }
  if (ans->Properties(fst::kILabelSorted, true) == 0) {
    // Make sure LM is sorted on ilabel.
    fst::ILabelCompare<fst::StdArc> ilabel_comp;
    fst::ArcSort(ans, ilabel_comp);
  }
  return ans;
}

ReadAsConstFst()

ConstFst<StdArc>* fst::ReadAsConstFst

(

std::string

rxfilename

)

Definition at line 32 of file make-grammar-fst.cc.

References ReadFstKaldiGeneric().

Referenced by main().

                                                       {
  // the following call will throw if there is an error.
  Fst<StdArc> *fst = ReadFstKaldiGeneric(rxfilename);
  ConstFst<StdArc> *const_fst = dynamic_cast<ConstFst<StdArc>* >(fst);
  if (!const_fst) {
    const_fst = new ConstFst<StdArc>(*fst);
    delete fst;
  }
  return const_fst;
}

ReadConstFstFromStream()

static ConstFst<StdArc>* fst::ReadConstFstFromStream ( std::istream &  is )

static

Definition at line 406 of file grammar-fst.cc.

References KALDI_ERR.

Referenced by GrammarFst::Read().

                                                                {
  fst::FstHeader hdr;
  std::string stream_name("unknown");
  if (!hdr.Read(is, stream_name))
    KALDI_ERR << "Reading FST: error reading FST header";
  FstReadOptions ropts("<unspecified>", &hdr);
  ConstFst<StdArc> *ans = ConstFst<StdArc>::Read(is, ropts);
  if (!ans)
    KALDI_ERR << "Could not read ConstFst from stream.";
  return ans;
}

ReadFstKaldi() [1/4]

VectorFst< StdArc > * ReadFstKaldi

(

std::string

rxfilename

)

Definition at line 29 of file kaldi-fst-io.cc.

References KALDI_ERR, kaldi::PrintableRxfilename(), and Input::Stream().

                                                      {
  if (rxfilename == "") rxfilename = "-"; // interpret "" as stdin,
  // for compatibility with OpenFst conventions.
  kaldi::Input ki(rxfilename);
  fst::FstHeader hdr;
  if (!hdr.Read(ki.Stream(), rxfilename))
    KALDI_ERR << "Reading FST: error reading FST header from "
              << kaldi::PrintableRxfilename(rxfilename);
  FstReadOptions ropts("<unspecified>", &hdr);
  VectorFst<StdArc> *fst = VectorFst<StdArc>::Read(ki.Stream(), ropts);
  if (!fst)
    KALDI_ERR << "Could not read fst from "
              << kaldi::PrintableRxfilename(rxfilename);
  return fst;
}

ReadFstKaldi() [2/4]

void fst::ReadFstKaldi	(	std::string	rxfilename,
		VectorFst< StdArc > *	ofst
	)

ReadFstKaldi() [3/4]

void ReadFstKaldi	(	std::istream &	is,
		bool	binary,
		VectorFst< Arc > *	fst
	)

Definition at line 73 of file kaldi-fst-io-inl.h.

References kaldi::ConvertStringToInteger(), rnnlm::d, KALDI_ERR, kaldi::SplitStringToIntegers(), kaldi::SplitStringToVector(), and StrToWeight().

Referenced by main(), VectorFstTplHolder< Arc >::Read(), ReadAndPrepareLmFst(), and ReadFstKaldi().

                                       {
  typedef typename Arc::Weight Weight;
  typedef typename Arc::StateId StateId;
  if (binary) {
    // We don't have access to the filename here, so write [unknown].
    VectorFst<Arc> *ans =
        VectorFst<Arc>::Read(is, fst::FstReadOptions(std::string("[unknown]")));
    if (ans == NULL) {
      KALDI_ERR << "Error reading FST from stream.";
    }
    *fst = *ans;  // shallow copy.
    delete ans;
  } else {
    // Consume the \r on Windows, the \n that the text-form FST format starts
    // with, and any extra spaces that might have got in there somehow.
    while (std::isspace(is.peek()) && is.peek() != '\n') is.get();
    if (is.peek() == '\n') is.get(); // consume the newline.
    else { // saw spaces but no newline.. this is not expected.
      KALDI_ERR << "Reading FST: unexpected sequence of spaces "
                << " at file position " << is.tellg();
    }
    using std::string;
    using std::vector;
    using kaldi::SplitStringToIntegers;
    using kaldi::ConvertStringToInteger;
    fst->DeleteStates();
    string line;
    size_t nline = 0;
    string separator = FLAGS_fst_field_separator + "\r\n";
    while (std::getline(is, line)) {
      nline++;
      vector<string> col;
      // on Windows we'll write in text and read in binary mode.
      kaldi::SplitStringToVector(line, separator.c_str(), true, &col);
      if (col.size() == 0) break; // Empty line is a signal to stop, in our
      // archive format.
      if (col.size() > 5) {
        KALDI_ERR << "Bad line in FST: " << line;
      }
      StateId s;
      if (!ConvertStringToInteger(col[0], &s)) {
        KALDI_ERR << "Bad line in FST: " << line;
      }
      while (s >= fst->NumStates())
        fst->AddState();
      if (nline == 1) fst->SetStart(s);

      bool ok = true;
      Arc arc;
      Weight w;
      StateId d = s;
      switch (col.size()) {
        case 1:
          fst->SetFinal(s, Weight::One());
          break;
        case 2:
          if (!StrToWeight(col[1], true, &w)) ok = false;
          else fst->SetFinal(s, w);
          break;
        case 3: // 3 columns not ok for Lattice format; it's not an acceptor.
          ok = false;
          break;
        case 4:
          ok = ConvertStringToInteger(col[1], &arc.nextstate) &&
              ConvertStringToInteger(col[2], &arc.ilabel) &&
              ConvertStringToInteger(col[3], &arc.olabel);
          if (ok) {
            d = arc.nextstate;
            arc.weight = Weight::One();
            fst->AddArc(s, arc);
          }
          break;
        case 5:
          ok = ConvertStringToInteger(col[1], &arc.nextstate) &&
              ConvertStringToInteger(col[2], &arc.ilabel) &&
              ConvertStringToInteger(col[3], &arc.olabel) &&
              StrToWeight(col[4], false, &arc.weight);
          if (ok) {
            d = arc.nextstate;
            fst->AddArc(s, arc);
          }
          break;
        default:
          ok = false;
      }
      while (d >= fst->NumStates()) fst->AddState();
      if (!ok)
        KALDI_ERR << "Bad line in FST: " << line;
    }
  }
}

ReadFstKaldi() [4/4]

void fst::ReadFstKaldi	(	std::string	rxfilename,
		fst::StdVectorFst *	ofst
	)

Definition at line 109 of file kaldi-fst-io.cc.

References ReadFstKaldi().

                                                               {
  fst::StdVectorFst *fst = ReadFstKaldi(rxfilename);
  *ofst = *fst;
  delete fst;
}

ReadFstKaldiGeneric()

Fst< StdArc > * ReadFstKaldiGeneric	(	std::string	rxfilename,
		bool	throw_on_err
	)

Definition at line 45 of file kaldi-fst-io.cc.

References KALDI_ERR, KALDI_WARN, kaldi::PrintableRxfilename(), and Input::Stream().

Referenced by main(), and ReadAsConstFst().

                                                                          {
  if (rxfilename == "") rxfilename = "-"; // interpret "" as stdin,
  // for compatibility with OpenFst conventions.
  kaldi::Input ki(rxfilename);
  fst::FstHeader hdr;
  // Read FstHeader which contains the type of FST
  if (!hdr.Read(ki.Stream(), rxfilename)) {
    if(throw_on_err) {
      KALDI_ERR << "Reading FST: error reading FST header from "
                << kaldi::PrintableRxfilename(rxfilename);
    } else {
      KALDI_WARN << "We fail to read FST header from "
                 << kaldi::PrintableRxfilename(rxfilename)
                 << ". A NULL pointer is returned.";
      return NULL;
    }
  }
  // Check the type of Arc
  if (hdr.ArcType() != fst::StdArc::Type()) {
    if(throw_on_err) {
      KALDI_ERR << "FST with arc type " << hdr.ArcType() << " is not supported.";
    } else {
      KALDI_WARN << "Fst with arc type" << hdr.ArcType()
                 << " is not supported. A NULL pointer is returned.";
      return NULL;
    }
  }
  // Read the FST
  FstReadOptions ropts("<unspecified>", &hdr);
  Fst<StdArc> *fst = NULL;
  if (hdr.FstType() == "const") {
    fst = ConstFst<StdArc>::Read(ki.Stream(), ropts);
  } else if (hdr.FstType() == "vector") {
    fst = VectorFst<StdArc>::Read(ki.Stream(), ropts);
  }
  if (!fst) {
    if(throw_on_err) {
     KALDI_ERR << "Could not read fst from "
               << kaldi::PrintableRxfilename(rxfilename);
    } else {
      KALDI_WARN << "Could not read fst from "
                 << kaldi::PrintableRxfilename(rxfilename)
                 << ". A NULL pointer is returned.";
      return NULL;
    }
  }
  return fst;
}

ReadILabelInfo() [1/2]

void fst::ReadILabelInfo	(	std::istream &	is,
		bool	binary,
		std::vector< std::vector< int32 > > *	ilabel_info
	)

Utility function for reading ilabel-info vectors from disk.

Definition at line 335 of file context-fst.cc.

References rnnlm::i, kaldi::ReadBasicType(), and kaldi::ReadIntegerVector().

Referenced by main(), and TestContextFst().

                                                  {
  int32 size = info->size();
  kaldi::ReadBasicType(is, binary, &size);
  info->resize(size);
  for (int32 i = 0; i < size; i++) {
    kaldi::ReadIntegerVector(is, binary, &((*info)[i]));
  }
}

ReadILabelInfo() [2/2]

void fst::ReadILabelInfo	(	std::istream &	is,
		bool	binary,
		vector< vector< int32 > > *	info
	)

Utility function for reading ilabel-info vectors from disk.

Definition at line 335 of file context-fst.cc.

References rnnlm::i, kaldi::ReadBasicType(), and kaldi::ReadIntegerVector().

Referenced by main(), and TestContextFst().

                                                  {
  int32 size = info->size();
  kaldi::ReadBasicType(is, binary, &size);
  info->resize(size);
  for (int32 i = 0; i < size; i++) {
    kaldi::ReadIntegerVector(is, binary, &((*info)[i]));
  }
}

RemoveAlignmentsFromCompactLattice()

void RemoveAlignmentsFromCompactLattice

(

MutableFst< ArcTpl< CompactLatticeWeightTpl< Weight, Int > > > *

fst

)

Removes state-level alignments (the strings that are part of the weights).

Definition at line 222 of file lattice-utils-inl.h.

Referenced by LatticeScale(), main(), and MinimumBayesRisk::MinimumBayesRisk().

                                                                     {
  typedef CompactLatticeWeightTpl<Weight, Int> W;
  typedef ArcTpl<W> Arc;
  typedef MutableFst<Arc> Fst;
  typedef typename Arc::StateId StateId;
  StateId num_states = fst->NumStates();
  for (StateId s = 0; s < num_states; s++) {
    for (MutableArcIterator<Fst> aiter(fst, s);
         !aiter.Done();
         aiter.Next()) {
      Arc arc = aiter.Value();
      arc.weight = W(arc.weight.Weight(), std::vector<Int>());
      aiter.SetValue(arc);
    }
    W final_weight = fst->Final(s);
    if (final_weight != W::Zero())
      fst->SetFinal(s, W(final_weight.Weight(), std::vector<Int>()));
  }
}

RemoveArcsWithSomeInputSymbols()

void fst::RemoveArcsWithSomeInputSymbols	(	const std::vector< I > &	symbols_in,
		VectorFst< Arc > *	fst
	)

Definition at line 33 of file fstrmsymbols.cc.

References ConstIntegerSet< I >::count(), and KALDI_WARN.

Referenced by main().

                                                         {
  typedef typename Arc::StateId StateId;

  kaldi::ConstIntegerSet<I> symbol_set(symbols_in);

  StateId num_states = fst->NumStates();
  StateId dead_state = fst->AddState();
  for (StateId s = 0; s < num_states; s++) {
    for (MutableArcIterator<VectorFst<Arc> > iter(fst, s);
         !iter.Done(); iter.Next()) {
      if (symbol_set.count(iter.Value().ilabel) != 0) {
        Arc arc = iter.Value();
        arc.nextstate = dead_state;
        iter.SetValue(arc);
      }
    }
  }
  // Connect() will actually remove the arcs, and the dead state.
  Connect(fst);
  if (fst->NumStates() == 0)
    KALDI_WARN << "After Connect(), fst was empty.";
}

RemoveEpsLocal()

void RemoveEpsLocal

(

MutableFst< Arc > *

fst

)

RemoveEpsLocal remove some (but not necessarily all) epsilons in an FST, using an algorithm that is guaranteed to never increase the number of arcs in the FST (and will also never increase the number of states).

The algorithm is not optimal but is reasonably clever. It does not just remove epsilon arcs;it also combines pairs of input-epsilon and output-epsilon arcs into one. The algorithm preserves equivalence and stochasticity in the given semiring. If you want to preserve stochasticity in a different semiring (e.g. log), then use RemoveEpsLocalSpecial, which only works for StdArc but which preserves stochasticity, where possible (*) in the LogArc sense. The reason that we can't just cast to a different semiring is that in that case we would no longer be able to guarantee equivalence in the original semiring (this arises from what happens when we combine identical arcs). (*) by "where possible".. there are situations where we wouldn't be able to preserve stochasticity in the LogArc sense while maintaining equivalence in the StdArc sense, so in these situations we maintain equivalence.

Definition at line 309 of file remove-eps-local-inl.h.

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), SimpleDecoder::GetBestPath(), FasterDecoder::GetBestPath(), BiglmFasterDecoder::GetBestPath(), kaldi::GetHmmAsFsa(), main(), OnlineFasterDecoder::MakeLattice(), ArpaLmCompiler::RemoveRedundantStates(), SafeDeterminizeMinimizeWrapper(), SafeDeterminizeMinimizeWrapperInLog(), TestRemoveEpsLocal(), and OnlineFasterDecoder::TracebackNFrames().

                                          {
  RemoveEpsLocalClass<Arc> c(fst);  // work gets done in initializer.
}

RemoveEpsLocalSpecial()

void RemoveEpsLocalSpecial ( MutableFst< StdArc > *  fst )

inline

As RemoveEpsLocal but takes care to preserve stochasticity when cast to LogArc.

Definition at line 314 of file remove-eps-local-inl.h.

Referenced by main(), and TestRemoveEpsLocalSpecial().

                                                    {
  // work gets done in initializer.
  RemoveEpsLocalClass<StdArc, ReweightPlusLogArc> c(fst);
}

RemoveSomeInputSymbols()

void RemoveSomeInputSymbols	(	const std::vector< I > &	to_remove,
		MutableFst< Arc > *	fst
	)

RemoveSomeInputSymbols removes any symbol that appears in "to_remove", from the input side of the FST, replacing them with epsilon.

Definition at line 119 of file fstext-utils-inl.h.

References KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), main(), MinimizeEncoded(), LatticeWordAligner::RemoveEpsilonsFromLattice(), LatticeLexiconWordAligner::RemoveEpsilonsFromLattice(), SafeDeterminizeMinimizeWrapper(), SafeDeterminizeWrapper(), and WordAlignedLatticeTester::TestEquivalent().

                                                  {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  RemoveSomeInputSymbolsMapper<Arc, I> mapper(to_remove);
  Map(fst, mapper);
}

RemoveUselessArcs()

void RemoveUselessArcs

(

MutableFst< Arc > *

fst

)

Definition at line 950 of file fstext-utils-inl.h.

References rnnlm::j, KALDI_ASSERT, and KALDI_VLOG.

Referenced by MinimizeEncoded(), and TestRemoveUselessArcs().

                                             {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;
  NaturalLess<Weight> nl;
  StateId non_coacc_state = kNoStateId;
  size_t num_arcs_removed = 0, tot_arcs = 0;
  for (StateIterator<MutableFst<Arc> > siter(*fst);
      !siter.Done();
      siter.Next()) {
    std::vector<size_t> arcs_to_delete;
    std::vector<Arc> arcs;
    // pair2arclist lets us look up the arcs
    std::map<std::pair<Label, StateId>, std::vector<size_t> > pair2arclist;
    StateId state = siter.Value();
    for (ArcIterator<MutableFst<Arc> > aiter(*fst, state);
        !aiter.Done();
        aiter.Next()) {
      size_t pos = arcs.size();
      const Arc &arc = aiter.Value();
      arcs.push_back(arc);
      pair2arclist[std::make_pair(arc.ilabel, arc.nextstate)].push_back(pos);
    }
    typename std::map<std::pair<Label, StateId>, std::vector<size_t> >::iterator
        iter = pair2arclist.begin(), end = pair2arclist.end();
    for (; iter!= end; ++iter) {
      const std::vector<size_t> &poslist = iter->second;
      if (poslist.size() > 1) {  // >1 arc with same ilabel, dest-state
        size_t best_pos = poslist[0];
        Weight best_weight = arcs[best_pos].weight;
        for (size_t j = 1; j < poslist.size(); j++) {
          size_t pos = poslist[j];
          Weight this_weight = arcs[pos].weight;
          if (nl(this_weight, best_weight)) {  // NaturalLess seems to be somehow
            // "backwards".
            best_weight = this_weight;  // found a better one.
            best_pos = pos;
          }
        }
        for (size_t j = 0; j < poslist.size(); j++)
          if (poslist[j] != best_pos)
            arcs_to_delete.push_back(poslist[j]);
      } else {
        KALDI_ASSERT(poslist.size() == 1);
        size_t pos = poslist[0];
        Arc &arc = arcs[pos];
        if (arc.ilabel == 0 && arc.nextstate == state)
          arcs_to_delete.push_back(pos);
      }
    }
    tot_arcs += arcs.size();
    if (arcs_to_delete.size() != 0) {
      num_arcs_removed += arcs_to_delete.size();
      if (non_coacc_state == kNoStateId)
        non_coacc_state = fst->AddState();
      MutableArcIterator<MutableFst<Arc> > maiter(fst, state);
      for (size_t j = 0; j < arcs_to_delete.size(); j++) {
        size_t pos = arcs_to_delete[j];
        maiter.Seek(pos);
        arcs[pos].nextstate = non_coacc_state;
        maiter.SetValue(arcs[pos]);
      }
    }
  }
  if (non_coacc_state != kNoStateId)
    Connect(fst);
  KALDI_VLOG(1) << "removed " << num_arcs_removed << " of " << tot_arcs
                << "arcs.";
}

RemoveWeights()

void RemoveWeights

(

MutableFst< Arc > *

ifst

)

Definition at line 434 of file fstext-utils-inl.h.

Referenced by kaldi::DifferenceWrapper(), main(), MinimizeEncoded(), and TestAcceptorMinimize().

                                          {
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  for (StateIterator<MutableFst<Arc> > siter(*ifst); !siter.Done(); siter.Next()) {
    StateId s = siter.Value();
    for (MutableArcIterator<MutableFst<Arc> >  aiter(ifst, s); !aiter.Done(); aiter.Next()) {
      Arc arc(aiter.Value());
      arc.weight = Weight::One();
      aiter.SetValue(arc);
    }
    if (ifst->Final(s) != Weight::Zero())
      ifst->SetFinal(s, Weight::One());
  }
  ifst->SetProperties(kUnweighted, kUnweighted);
}

RhoCompose()

void RhoCompose	(	const Fst< Arc > &	fst1,
		const Fst< Arc > &	fst2,
		typename Arc::Label	rho_label,
		MutableFst< Arc > *	ofst
	)

Definition at line 1096 of file fstext-utils-inl.h.

References IsStochasticFst(), and KALDI_ASSERT.

Referenced by MinimizeEncoded().

                                       {
  KALDI_ASSERT(rho_label != kNoLabel); // just use regular compose in this case.
  typedef Fst<Arc> F;
  typedef RhoMatcher<SortedMatcher<F> > RM;
  CacheOptions base_opts;
  base_opts.gc_limit = 0; // Cache only the last state for fastest copy.
  // ComposeFstImplOptions templated on matcher for fst1, matcher for fst2.
  // The matcher for fst1 doesn't matter; we'll use fst2's matcher.
  ComposeFstImplOptions<SortedMatcher<F>, RM> impl_opts(base_opts);

  // the false below is something called rho_loop which is something I don't
  // fully understand, but I don't think we want it.

  // These pointers are taken ownership of, by ComposeFst.
  RM *rho_matcher =
      new RM(fst2, MATCH_INPUT, rho_label);
  SortedMatcher<F> *sorted_matcher =
      new SortedMatcher<F>(fst1, MATCH_NONE); // tell it
  // not to use this matcher, as this would mean we would
  // not follow rho transitions.
  impl_opts.matcher1 = sorted_matcher;
  impl_opts.matcher2 = rho_matcher;
  *ofst = ComposeFst<Arc>(fst1, fst2, impl_opts);
  Connect(ofst);
}

SafeDeterminizeMinimizeWrapper()

void SafeDeterminizeMinimizeWrapper	(	MutableFst< Arc > *	ifst,
		VectorFst< Arc > *	ofst,
		float	delta = kDelta
	)

SafeDeterminizeMinimizeWapper is as SafeDeterminizeWrapper except that it also minimizes (encoded minimization, which is safe).

This algorithm will destroy "ifst".

Definition at line 357 of file fstext-utils-inl.h.

References DeterminizeStar(), HighestNumberedInputSymbol(), MinimizeEncoded(), PreDeterminize(), RemoveEpsLocal(), and RemoveSomeInputSymbols().

Referenced by MinimizeEncoded(), and TestSafeDeterminizeWrapper().

                                                                                              {
  typename Arc::Label highest_sym = HighestNumberedInputSymbol(*ifst);
  std::vector<typename Arc::Label> extra_syms;
  PreDeterminize(ifst,
                 (typename Arc::Label)(highest_sym+1),
                 &extra_syms);
  DeterminizeStar(*ifst, ofst, delta);
  RemoveSomeInputSymbols(extra_syms, ofst);  // remove the extra symbols.
  RemoveEpsLocal(ofst);  // this is "safe" and will never hurt.
  MinimizeEncoded(ofst, delta);
}

SafeDeterminizeMinimizeWrapperInLog()

void SafeDeterminizeMinimizeWrapperInLog ( VectorFst< StdArc > *  ifst, VectorFst< StdArc > *  ofst, float  delta = kDelta  )

inline

SafeDeterminizeMinimizeWapperInLog is as SafeDeterminizeMinimizeWrapper except it first casts tothe log semiring.

Definition at line 408 of file fstext-utils-inl.h.

References MinimizeEncoded(), RemoveEpsLocal(), and SafeDeterminizeWrapper().

Referenced by MinimizeEncoded(), and TestSafeDeterminizeWrapper().

                                                                                                        {
  VectorFst<LogArc> *ifst_log = new VectorFst<LogArc>;  // Want to determinize in log semiring.
  Cast(*ifst, ifst_log);
  VectorFst<LogArc> *ofst_log = new VectorFst<LogArc>;
  SafeDeterminizeWrapper(ifst_log, ofst_log, delta);
  Cast(*ofst_log, ofst);
  delete ifst_log;
  delete ofst_log;
  RemoveEpsLocal(ofst);  // this is "safe" and will never hurt.  Do this in tropical, which is important.
  MinimizeEncoded(ofst, delta);  // Non-deterministic minimization will fail in log semiring so do it with StdARc.
}

SafeDeterminizeWrapper()

void SafeDeterminizeWrapper	(	MutableFst< Arc > *	ifst,
		MutableFst< Arc > *	ofst,
		float	delta = kDelta
	)

Does PreDeterminize and DeterminizeStar and then removes the disambiguation symbols.

This is a form of determinization that will never blow up. Note that ifst is non-const and can be considered to be destroyed by this operation. Does not do epsilon removal (RemoveEpsLocal)– this is so it's safe to cast to log and do this, and maintain equivalence in tropical.

Definition at line 345 of file fstext-utils-inl.h.

References DeterminizeStar(), HighestNumberedInputSymbol(), PreDeterminize(), and RemoveSomeInputSymbols().

Referenced by MinimizeEncoded(), SafeDeterminizeMinimizeWrapperInLog(), SafeDeterminizeWrapperInLog(), and TestSafeDeterminizeWrapper().

                                                                                       {
  typename Arc::Label highest_sym = HighestNumberedInputSymbol(*ifst);
  std::vector<typename Arc::Label> extra_syms;
  PreDeterminize(ifst,
                 (typename Arc::Label)(highest_sym+1),
                 &extra_syms);
  DeterminizeStar(*ifst, ofst, delta);
  RemoveSomeInputSymbols(extra_syms, ofst);  // remove the extra symbols.
}

SafeDeterminizeWrapperInLog()

void fst::SafeDeterminizeWrapperInLog ( VectorFst< StdArc > *  ifst, VectorFst< StdArc > *  ofst, float  delta  )

inline

Definition at line 421 of file fstext-utils-inl.h.

References SafeDeterminizeWrapper().

                                                                                                {
  VectorFst<LogArc> *ifst_log = new VectorFst<LogArc>;  // Want to determinize in log semiring.
  Cast(*ifst, ifst_log);
  VectorFst<LogArc> *ofst_log = new VectorFst<LogArc>;
  SafeDeterminizeWrapper(ifst_log, ofst_log, delta);
  Cast(*ofst_log, ofst);
  delete ifst_log;
  delete ofst_log;
}

ScaleLattice()

void ScaleLattice	(	const std::vector< std::vector< ScaleFloat > > &	scale,
		MutableFst< ArcTpl< Weight > > *	fst
	)

Scales the pairs of weights in LatticeWeight or CompactLatticeWeight by viewing the pair (a, b) as a 2-vector and pre-multiplying by the 2x2 matrix in "scale".

E.g. typically scale would equal [ 1 0; 0 acwt ] if we want to scale the acoustics by "acwt".

Definition at line 197 of file lattice-utils-inl.h.

References DefaultLatticeScale(), and ScaleTupleWeight().

Referenced by DiscriminativeSupervisionSplitter::CreateRangeLattice(), kaldi::DecodeUtterance(), kaldi::DecodeUtteranceLatticeFaster(), kaldi::DecodeUtteranceLatticeIncremental(), kaldi::DecodeUtteranceLatticeSimple(), LatticeScale(), main(), DeterminizeLatticeTask::operator()(), DecodeUtteranceLatticeFasterClass::operator()(), DiscriminativeSupervisionSplitter::PrepareLattice(), NnetBatchDecoder::ProcessOutputUtterance(), and TestScalePair().

                                      {
  assert(scale.size() == 2 && scale[0].size() == 2 && scale[1].size() == 2);
  if (scale == DefaultLatticeScale()) // nothing to do.
    return;
  typedef ArcTpl<Weight> Arc;
  typedef MutableFst<Arc> Fst;
  typedef typename Arc::StateId StateId;
  StateId num_states = fst->NumStates();
  for (StateId s = 0; s < num_states; s++) {
    for (MutableArcIterator<Fst> aiter(fst, s);
         !aiter.Done();
         aiter.Next()) {
      Arc arc = aiter.Value();
      arc.weight = Weight(ScaleTupleWeight(arc.weight, scale));
      aiter.SetValue(arc);
    }
    Weight final_weight = fst->Final(s);
    if (final_weight != Weight::Zero())
      fst->SetFinal(s, Weight(ScaleTupleWeight(final_weight, scale)));
  }
}

ScaleTupleWeight() [1/3]

LatticeWeightTpl<FloatType> fst::ScaleTupleWeight ( const LatticeWeightTpl< FloatType > &  w, const std::vector< std::vector< ScaleFloatType > > &  scale  )

inline

Definition at line 232 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by ScaleLattice(), and ScaleTupleWeight().

                                                        {
  // Without the next special case we'd get NaNs from infinity * 0
  if (w.Value1() == std::numeric_limits<FloatType>::infinity())
    return LatticeWeightTpl<FloatType>::Zero();
  return LatticeWeightTpl<FloatType>(scale[0][0] * w.Value1() + scale[0][1] * w.Value2(),
                                     scale[1][0] * w.Value1() + scale[1][1] * w.Value2());
}

ScaleTupleWeight() [2/3]

PairWeight<TropicalWeightTpl<FloatType>, TropicalWeightTpl<FloatType> > fst::ScaleTupleWeight ( const PairWeight< TropicalWeightTpl< FloatType >, TropicalWeightTpl< FloatType > > &  w, const std::vector< std::vector< ScaleFloatType > > &  scale  )

inline

Definition at line 249 of file lattice-weight.h.

                                                                          {
  typedef TropicalWeightTpl<FloatType> BaseType;
  typedef PairWeight<BaseType, BaseType> PairType;
  const BaseType zero = BaseType::Zero();
  // Without the next special case we'd get NaNs from infinity * 0
  if (w.Value1() == zero || w.Value2() == zero)
    return PairType(zero, zero);
  FloatType f1 = w.Value1().Value(), f2 = w.Value2().Value();
  return PairType(BaseType(scale[0][0] * f1 + scale[0][1] * f2),
                  BaseType(scale[1][0] * f1 + scale[1][1] * f2));
}

ScaleTupleWeight() [3/3]

CompactLatticeWeightTpl<Weight, IntType> fst::ScaleTupleWeight ( const CompactLatticeWeightTpl< Weight, IntType > &  w, const std::vector< std::vector< ScaleFloatType > > &  scale  )

inline

Scales the pair (a, b) of floating-point weights inside a CompactLatticeWeight by premultiplying it (viewed as a vector) by a 2x2 matrix "scale".

Assumes there is a ScaleTupleWeight function that applies to "Weight"; this currently only works if Weight equals LatticeWeightTpl<FloatType> for some FloatType.

Definition at line 808 of file lattice-weight.h.

References ScaleTupleWeight(), CompactLatticeWeightTpl< WeightType, IntType >::String(), and CompactLatticeWeightTpl< WeightType, IntType >::Weight().

                                                        {
  return CompactLatticeWeightTpl<Weight, IntType>(
      Weight(ScaleTupleWeight(w.Weight(), scale)), w.String());
}

StrToWeight()

bool fst::StrToWeight ( const std::string &  s, bool  allow_zero, W *  w  )

inline

Definition at line 63 of file kaldi-fst-io-inl.h.

Referenced by ReadFstKaldi().

                                                                   {
  std::istringstream strm(s);
  strm >> *w;
  if (strm.fail() || (!allow_zero && *w == W::Zero())) {
    return false;
  }
  return true;
}

TableCompose() [1/2]

void fst::TableCompose	(	const Fst< Arc > &	ifst1,
		const Fst< Arc > &	ifst2,
		MutableFst< Arc > *	ofst,
		const TableComposeOptions &	opts = TableComposeOptions()
	)

Definition at line 315 of file table-matcher.h.

Referenced by TrainingGraphCompiler::CompileGraph(), TrainingGraphCompiler::CompileGraphs(), main(), TestTableMatcher(), TestTableMatcherCacheLeft(), and TestTableMatcherCacheRight().

                                                                           {
  typedef Fst<Arc> F;
  CacheOptions nopts;
  nopts.gc_limit = 0;  // Cache only the last state for fastest copy.
  if (opts.table_match_type == MATCH_OUTPUT) {
    // ComposeFstImplOptions templated on matcher for fst1, matcher for fst2.
    ComposeFstImplOptions<TableMatcher<F>, SortedMatcher<F> > impl_opts(nopts);
    impl_opts.matcher1 = new TableMatcher<F>(ifst1, MATCH_OUTPUT, opts);
    *ofst = ComposeFst<Arc>(ifst1, ifst2, impl_opts);
  } else {
    assert(opts.table_match_type == MATCH_INPUT) ;
    // ComposeFstImplOptions templated on matcher for fst1, matcher for fst2.
    ComposeFstImplOptions<SortedMatcher<F>, TableMatcher<F> > impl_opts(nopts);
    impl_opts.matcher2 = new TableMatcher<F>(ifst2, MATCH_INPUT, opts);
    *ofst = ComposeFst<Arc>(ifst1, ifst2, impl_opts);
  }
  if (opts.connect) Connect(ofst);
}

TableCompose() [2/2]

void fst::TableCompose	(	const Fst< Arc > &	ifst1,
		const Fst< Arc > &	ifst2,
		MutableFst< Arc > *	ofst,
		TableComposeCache< Fst< Arc > > *	cache
	)

Definition at line 348 of file table-matcher.h.

References TableMatcher< F, BackoffMatcher >::Copy().

                                                       {
  typedef Fst<Arc> F;
  assert(cache != NULL);
  CacheOptions nopts;
  nopts.gc_limit = 0;  // Cache only the last state for fastest copy.
  if (cache->opts.table_match_type == MATCH_OUTPUT) {
    ComposeFstImplOptions<TableMatcher<F>, SortedMatcher<F> > impl_opts(nopts);
    if (cache->matcher == NULL)
      cache->matcher = new TableMatcher<F>(ifst1, MATCH_OUTPUT, cache->opts);
    impl_opts.matcher1 = cache->matcher->Copy();  // not passing "safe": may not
    // be thread-safe-- anway I don't understand this part.
    *ofst = ComposeFst<Arc>(ifst1, ifst2, impl_opts);
  } else {
    assert(cache->opts.table_match_type == MATCH_INPUT) ;
    ComposeFstImplOptions<SortedMatcher<F>, TableMatcher<F> > impl_opts(nopts);
    if (cache->matcher == NULL)
      cache->matcher = new TableMatcher<F>(ifst2, MATCH_INPUT, cache->opts);
    impl_opts.matcher2 = cache->matcher->Copy();
    *ofst = ComposeFst<Arc>(ifst1, ifst2, impl_opts);
  }
  if (cache->opts.connect) Connect(ofst);
}

TestAcceptorMinimize()

void fst::TestAcceptorMinimize

(

)

Definition at line 198 of file fstext-utils-test.cc.

References kaldi::Rand(), and RemoveWeights().

                                                 {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = RandFst<Arc>();

  Project(fst, PROJECT_INPUT);
  RemoveWeights(fst);

  VectorFst<Arc> fst2(*fst);
  internal::AcceptorMinimize(&fst2);

  assert(RandEquivalent(*fst, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
}

TestAddSelfLoops()

void fst::TestAddSelfLoops

(

)

Definition at line 143 of file pre-determinize-test.cc.

References AddSelfLoops(), CreateNewSymbols(), and kaldi::Rand().

                                             {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  SymbolTable *ilabels = new SymbolTable("my-symbol-table");
  SymbolTable *olabels = new SymbolTable("my-symbol-table-2");
  Label i0 = ilabels->AddSymbol("<eps>");
  Label i1 = ilabels->AddSymbol("1");
  Label i2 = ilabels->AddSymbol("2");

  Label o0 = olabels->AddSymbol("<eps>");
  Label o1 = olabels->AddSymbol("1");

  assert(i0 == 0 && o0 == 0);
  StateId s0 = fst->AddState(), s1 = fst->AddState(), s2 = fst->AddState();
  fst->SetStart(s0);
  assert(s0 == 0);

  fst->SetFinal(s2, (Weight)2);  // state 2 is final.
  {
    Arc arc;
    arc.ilabel = i1;
    arc.olabel = o0;
    arc.nextstate = 1;
    arc.weight = (Weight)1;
    fst->AddArc(s0, arc);  // arc from 0 to 1 with epsilon out.
  }
  {
    Arc arc;
    arc.ilabel = i2;
    arc.olabel = o1;
    arc.nextstate = 2;
    arc.weight = (Weight)2;
    fst->AddArc(s1, arc);  // arc from 1 to 2 with "1" out.
  }
  std::cout <<" printing before adding self-loops\n";
  {
    FstPrinter<Arc> fstprinter(*fst, ilabels, olabels, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  // So states 1 and 2 should have self-loops on.
  size_t num_extra = kaldi::Rand() % 5;
  vector<Label> extra_ilabels, extra_olabels;
  CreateNewSymbols(ilabels,  num_extra, "in#", &extra_ilabels);
  CreateNewSymbols(olabels,  num_extra, "out#", &extra_olabels);

  AddSelfLoops(fst, extra_ilabels, extra_olabels);

  assert(fst->NumArcs(0) == 1);
  assert(fst->NumArcs(1) == 1 + num_extra);
  assert(fst->NumArcs(2) == num_extra);

  std::cout <<" printing after adding self-loops\n";
  {
    FstPrinter<Arc> fstprinter(*fst, ilabels, olabels, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  delete fst;
  delete ilabels;
  delete olabels;
}

TestBackoffAndCache()

void fst::TestBackoffAndCache

(

)

Definition at line 148 of file deterministic-fst-test.cc.

References ApproxEqual(), CreateBackoffFst(), CreateResultFst(), CacheDeterministicOnDemandFst< Arc >::Final(), and CacheDeterministicOnDemandFst< Arc >::GetArc().

Referenced by main().

                           {
  // Build from existing fst
  cout << "Test with single generated backoff FST" << endl;
  StdVectorFst *nfst = CreateBackoffFst();
  StdVectorFst *rfst = CreateResultFst();

  // before using, make sure that it is input sorted
  ArcSort(nfst, StdILabelCompare());
  BackoffDeterministicOnDemandFst<StdArc> dfst1a(*nfst);
  CacheDeterministicOnDemandFst<StdArc> dfst1(&dfst1a);

  // Compare all arcs in dfst1 with expected result
  for (StateIterator<StdVectorFst> riter(*rfst); !riter.Done(); riter.Next()) {
    StateId rsrc = riter.Value();
    // verify that states have same weight (or final status)
    assert(ApproxEqual(rfst->Final(rsrc), dfst1.Final(rsrc)));
    for (ArcIterator<StdVectorFst> aiter(*rfst, rsrc); !aiter.Done(); aiter.Next()) {
      StdArc rarc = aiter.Value();
      StdArc darc;
      if (dfst1.GetArc(rsrc, rarc.ilabel, &darc)) {
        assert(ApproxEqual(rarc.weight, darc.weight, 0.001));
        assert(rarc.ilabel==darc.ilabel);
        assert(rarc.olabel==darc.olabel);
        assert(rarc.nextstate == darc.nextstate);
        cerr << "  Got same arc at state "<<rsrc<<": "<<rarc.ilabel<<" "<<darc.ilabel<<endl;
      } else {
        cerr << "Couldn't find arc "<<rarc.ilabel<<" for state "<<rsrc<<endl;
        exit(1);
      }
    }
  }
  delete nfst;
  delete rfst;
}

TestCompose()

void fst::TestCompose

(

)

Definition at line 183 of file deterministic-fst-test.cc.

References ApproxEqual(), CreateBackoffFst(), CreateResultFst(), LmExampleDeterministicOnDemandFst< Arc >::Final(), LmExampleDeterministicOnDemandFst< Arc >::GetArc(), KALDI_ASSERT, CacheDeterministicOnDemandFst< Arc >::Start(), LmExampleDeterministicOnDemandFst< Arc >::Start(), and WalkSinglePath().

Referenced by main().

                   {
  cout << "Test with single generated backoff FST" << endl;
  StdVectorFst *nfst = CreateBackoffFst();
  StdVectorFst *rfst = CreateResultFst();

  StdVectorFst composed_fst;
  Compose(*rfst, *rfst, &composed_fst);

  // before using, make sure that it is input sorted
  ArcSort(nfst, StdILabelCompare());
  BackoffDeterministicOnDemandFst<StdArc> dfst1a(*nfst);
  ComposeDeterministicOnDemandFst<StdArc> dfst1b(&dfst1a, &dfst1a);
  CacheDeterministicOnDemandFst<StdArc> dfst1(&dfst1b);

  typedef StdArc::StateId StateId;
  std::map<StateId, StateId> state_map;
  state_map[composed_fst.Start()] = dfst1.Start();

  VectorFst<StdArc> path_fst;
  ShortestPath(composed_fst, &path_fst);

  BackoffDeterministicOnDemandFst<StdArc> dfst2(composed_fst);

  Weight w1 = WalkSinglePath(&path_fst, &dfst1),
      w2 = WalkSinglePath(&path_fst, &dfst2);
  KALDI_ASSERT(ApproxEqual(w1, w2));

  delete rfst;
  delete nfst;

  { // Mostly checking for compilation errors here.
    LmExampleDeterministicOnDemandFst<StdArc> lm_eg(NULL, 2, 3);
    KALDI_ASSERT(lm_eg.Start() == 0);
    KALDI_ASSERT(lm_eg.Final(0).Value() == 0.5); // I made it this value.
    StdArc arc;
    bool b = lm_eg.GetArc(0, 100, &arc);
    KALDI_ASSERT(b && arc.nextstate == 1 && arc.ilabel == 100 && arc.olabel == 100
                 && arc.weight.Value() == 0.25);
  }
}

TestContextFst()

static void fst::TestContextFst ( bool  verbose, bool  use_matcher  )

static

Definition at line 158 of file context-fst-test.cc.

References kaldi::AssertEqual(), ComposeDeterministicOnDemandInverse(), kaldi::CopySetToVector(), rnnlm::i, InverseContextFst::IlabelInfo(), kaldi::Rand(), kaldi::RandUniform(), ReadILabelInfo(), Input::Stream(), and WriteILabelInfo().

Referenced by main().

                                                           {
  typedef StdArc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;
  typedef Arc::Weight Weight;

  // Generate a random set of phones.
  size_t num_phones = 1 + kaldi::Rand() % 10;
  std::set<int32> phones_set;
  while (phones_set.size() < num_phones) phones_set.insert(1 + kaldi::Rand() % (num_phones + 5));  // don't use 0 [== epsilon]
  vector<int32> phones;
  kaldi::CopySetToVector(phones_set, &phones);

  int N = 1 + kaldi::Rand() % 4;  // Context size, in range 1..4.
  int P = kaldi::Rand() % N;  // 1.. N-1.
  if (verbose) std::cout << "N = "<< N << ", P = "<<P<<'\n';

  Label subsequential_symbol = 1000;
  vector<int32> disambig_syms;
  for (size_t i =0; i < 5; i++) disambig_syms.push_back(500 + i);
  vector<int32> phone_syms;
  for (size_t i = 0; i < phones.size();i++) phone_syms.push_back(phones[i]);


  InverseContextFst inv_cfst(subsequential_symbol,
                             phones, disambig_syms,
                             N, P);


  /* Now create random phone-sequences and compose them with the context FST.
  */

  for (size_t p = 0; p < 10; p++) {
    vector<int32> phone_seq;
    int num_subseq = N - P - 1;  // zero if P == N-1, i.e. P is last element, i.e. left-context only.
    float tot_cost = 20.0 * kaldi::RandUniform();
    VectorFst<Arc> *f = GenRandPhoneSeq<Arc>(phone_syms, disambig_syms, subsequential_symbol, num_subseq, tot_cost, &phone_seq);
    if (verbose) {
      std::cout << "Sequence FST is:\n";
      {  // Try to print the fst.
        FstPrinter<Arc> fstprinter(*f, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
    }

    VectorFst<Arc> fst_composed;

    ComposeDeterministicOnDemandInverse(*f,  &inv_cfst, &fst_composed);


    // Testing WriteILabelInfo and ReadILabelInfo.
    {
      bool binary = (kaldi::Rand() % 2 == 0);
      WriteILabelInfo(kaldi::Output("tmpf", binary).Stream(),
                      binary, inv_cfst.IlabelInfo());

      bool binary_in;
      vector<vector<int32> > ilabel_info;
      kaldi::Input ki("tmpf", &binary_in);
      ReadILabelInfo(ki.Stream(),
                     binary_in, &ilabel_info);
      assert(ilabel_info == inv_cfst.IlabelInfo());
    }


    if (verbose) {
      std::cout << "Composed FST is:\n";
      {  // Try to print the fst.
        FstPrinter<Arc> fstprinter(fst_composed, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
    }

    // now check the composed FST.
    float tot_cost_check = CheckPhones<Arc>(fst_composed,
                                            phone_syms,
                                            disambig_syms,
                                            phone_seq,
                                            inv_cfst.IlabelInfo(),
                                            N, P);
    kaldi::AssertEqual(tot_cost, tot_cost_check);

    delete f;
  }

  unlink("tmpf");
}

TestConvert()

void fst::TestConvert

(

bool

invert

)

Definition at line 26 of file lattice-utils-test.cc.

References rnnlm::i, and kaldi::Rand().

                                                                {
  typedef ArcTpl<Weight> Arc;
  typedef ArcTpl<CompactLatticeWeightTpl<Weight, Int> > CompactArc;
  for(int i = 0; i < 5; i++) {
    VectorFst<Arc> *fst = RandFst<Arc>();
    std::cout << "FST before converting to compact-arc is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<CompactArc> ofst;
    ConvertLattice<Weight, Int>(*fst, &ofst, invert);

    std::cout << "FST after converting is:\n";
    {
      FstPrinter<CompactArc> fstprinter(ofst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<Arc> origfst;
    ConvertLattice<Weight, Int>(ofst, &origfst, invert);
    std::cout << "FST after back conversion is:\n";
    {
      FstPrinter<Arc> fstprinter(origfst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }

    assert(RandEquivalent(*fst, origfst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
    delete fst;
  }
}

TestConvert2()

void fst::TestConvert2

(

)

Definition at line 114 of file lattice-utils-test.cc.

References ConvertLattice(), rnnlm::i, and kaldi::Rand().

                                        {
  typedef ArcTpl<LatticeWeightTpl<float> > ArcF;
  typedef ArcTpl<LatticeWeightTpl<double> > ArcD;
  typedef ArcTpl<CompactLatticeWeightTpl<LatticeWeightTpl<float>, Int> > CArcF;
  typedef ArcTpl<CompactLatticeWeightTpl<LatticeWeightTpl<double>, Int> > CArcD;

  for(int i = 0; i < 2; i++) {
    {
      VectorFst<ArcF> *fst1 = RandPairFst<ArcF>();
      VectorFst<ArcD> fst2;
      VectorFst<ArcF> fst3;
      ConvertLattice(*fst1, &fst2);
      ConvertLattice(fst2, &fst3);

      assert(RandEquivalent(*fst1, fst3, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }

    {
      VectorFst<ArcF> *fst1 = RandPairFst<ArcF>();
      VectorFst<CArcF> cfst1, cfst3;
      ConvertLattice(*fst1, &cfst1);
      VectorFst<CArcD> cfst2;
      ConvertLattice(cfst1, &cfst2);
      ConvertLattice(cfst2, &cfst3);
      assert(RandEquivalent(cfst1, cfst3, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }

    {
      VectorFst<ArcF> *fst1 = RandPairFst<ArcF>();
      VectorFst<CArcD> cfst1, cfst3;
      ConvertLattice(*fst1, &cfst1);
      VectorFst<CArcF> cfst2;
      ConvertLattice(cfst1, &cfst2);
      ConvertLattice(cfst2, &cfst3);
      assert(RandEquivalent(cfst1, cfst3, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }

    {
      VectorFst<ArcD> *fst1 = RandPairFst<ArcD>();
      VectorFst<CArcD> cfst1, cfst3;
      ConvertLattice(*fst1, &cfst1);
      VectorFst<CArcF> cfst2;
      ConvertLattice(cfst1, &cfst2);
      ConvertLattice(cfst2, &cfst3);
      assert(RandEquivalent(cfst1, cfst3, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }

    {
      VectorFst<ArcD> *fst1 = RandPairFst<ArcD>();
      VectorFst<CArcF> cfst1;
      ConvertLattice(*fst1, &cfst1);
      VectorFst<ArcD> fst2;
      ConvertLattice(cfst1, &fst2);
      assert(RandEquivalent(*fst1, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }

    {
      VectorFst<ArcF> *fst1 = RandPairFst<ArcF>();
      VectorFst<CArcD> cfst1;
      ConvertLattice(*fst1, &cfst1);
      VectorFst<ArcF> fst2;
      ConvertLattice(cfst1, &fst2);
      assert(RandEquivalent(*fst1, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }

    {
      VectorFst<ArcD> *fst1 = RandPairFst<ArcD>();
      VectorFst<CArcF> cfst1;
      ConvertLattice(*fst1, &cfst1);
      VectorFst<ArcD> fst2;
      ConvertLattice(cfst1, &fst2);
      assert(RandEquivalent(*fst1, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
      delete fst1;
    }
  }
}

TestConvertPair()

void fst::TestConvertPair

(

bool

invert

)

Definition at line 200 of file lattice-utils-test.cc.

References rnnlm::i, and kaldi::Rand().

                                                                    {
  typedef ArcTpl<Weight> Arc;
  typedef ArcTpl<CompactLatticeWeightTpl<Weight, Int> > CompactArc;
  for(int i = 0; i < 2; i++) {
    VectorFst<Arc> *fst = RandPairFst<Arc>();
    /*std::cout << "FST before converting to compact-arc is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true);
      fstprinter.Print(&std::cout, "standard output");
      }*/
    VectorFst<CompactArc> ofst;
    ConvertLattice<Weight, Int>(*fst, &ofst, invert);

    /*std::cout << "FST after converting is:\n";
    {
      FstPrinter<CompactArc> fstprinter(ofst, NULL, NULL, NULL, false, true);
      fstprinter.Print(&std::cout, "standard output");
      }*/
    VectorFst<Arc> origfst;
    ConvertLattice<Weight, Int>(ofst, &origfst, invert);
    /*std::cout << "FST after back conversion is:\n";
    {
      FstPrinter<Arc> fstprinter(origfst, NULL, NULL, NULL, false, true);
      fstprinter.Print(&std::cout, "standard output");
      }*/

    assert(RandEquivalent(*fst, origfst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
    delete fst;
  }
}

TestDeterminize()

void fst::TestDeterminize

(

)

Definition at line 61 of file determinize-star-test.cc.

References DeleteISymbols(), DeterminizeStar(), rnnlm::i, rnnlm::j, PreDeterminize(), and kaldi::Rand().

                                            {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  int n_syms = 2 + kaldi::Rand() % 5, n_states = 3 + kaldi::Rand() % 10, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%3;  // Up to 2 unique symbols.
  std::cout << "Testing pre-determinize with "<<n_syms<<" symbols, "<<n_states<<" states and "<<n_arcs<<" arcs and "<<n_final<<" final states.\n";
  SymbolTable *sptr = NULL;

  std::vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++)
    all_syms.push_back(i);

  // Create states.
  std::vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)n_final;j++) {
    StateId id = all_states[kaldi::Rand() % n_states];
    Weight weight = (Weight)(0.33*(kaldi::Rand() % 5) );
    printf("calling SetFinal with %d and %f\n", id, weight.Value());
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)n_arcs;i++) {
    Arc a;
    a.nextstate = all_states[kaldi::Rand() % n_states];
    a.ilabel = all_syms[kaldi::Rand() % n_syms];
    a.olabel = all_syms[kaldi::Rand() % n_syms];  // same input+output vocab.
    a.weight = (Weight) (0.33*(kaldi::Rand() % 2));
    StateId start_state = all_states[kaldi::Rand() % n_states];
    fst->AddArc(start_state, a);
  }

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> *fst_copy_orig = new VectorFst<Arc>(*fst);

  std::vector<Label> extra_syms;
  if (fst->Start() != kNoStateId) {  // "Connect" did not make it empty....
    PreDeterminize(fst, 1000, &extra_syms);
  }

  std::cout <<" printing after predeterminization\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  {  // Remove epsilon.  All default args.
    bool connect = true;
    Weight weight_threshold = Weight::Zero();
    int64 nstate = -1;  // Relates to pruning.
    double delta = kDelta;  // I think a small weight value.  Relates to some kind of pruning,
    // I guess.  But with no epsilon cycles, probably doensn't matter.
    RmEpsilon(fst, connect,  weight_threshold, nstate, delta);
  }

  std::cout <<" printing after epsilon removal\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  VectorFst<Arc> ofst_orig;
  VectorFst<Arc> ofst_star;

  {
    printf("Determinizing with baseline\n");
    DeterminizeOptions<Arc> opts;  // Default options.
    Determinize(*fst, &ofst_orig, opts);
  }

  {
    printf("Determinizing with DeterminizeStar\n");
    DeterminizeStar(*fst, &ofst_star);
  }

  {
    std::cout <<" printing after determinization [baseline]\n";
    FstPrinter<Arc> fstprinter(ofst_orig, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
    assert(ofst_orig.Properties(kIDeterministic, true) == kIDeterministic);
  }

  {
    std::cout <<" printing after determinization [star]\n";
    FstPrinter<Arc> fstprinter(ofst_star, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
    assert(ofst_star.Properties(kIDeterministic, true) == kIDeterministic);
  }

  assert(RandEquivalent(ofst_orig, ofst_star, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  int64 num_removed = DeleteISymbols(&ofst_star, extra_syms);
  std::cout <<" printing after removing "<<num_removed<<" instances of extra symbols\n";
  {
    FstPrinter<Arc> fstprinter(ofst_star, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  std::cout <<" Checking equivalent to original FST.\n";
  // giving Rand() as a seed stops the random number generator from always being reset to
  // the same point each time, while maintaining determinism of the test.
  assert(RandEquivalent(ofst_star, *fst_copy_orig, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
  delete fst_copy_orig;
}

TestDeterminize2()

void fst::TestDeterminize2

(

)

Definition at line 190 of file determinize-star-test.cc.

References RandFstOptions::acyclic, rnnlm::i, and kaldi::Rand().

                                             {
  for(int i = 0; i < 10; i++) {
    RandFstOptions opts;
    opts.acyclic = true;
    VectorFst<Arc> *ifst = RandFst<Arc>(opts);
    VectorFst<Arc> ofst;
    Determinize(*ifst, &ofst);
    assert(RandEquivalent(*ifst, ofst, 5, 0.01, kaldi::Rand(), 100));
    delete ifst;
  }
}

TestDeterminizeGeneral()

void fst::TestDeterminizeGeneral

(

)

Definition at line 34 of file determinize-star-test.cc.

References rnnlm::i, and kaldi::Rand().

                                                  {
  int max_states = 100; // don't allow more det-states than this.
  for(int i = 0; i < 100; i++) {
    VectorFst<Arc> *fst = RandFst<Arc>();
    std::cout << "FST before determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<Arc> ofst;
    try {
      DeterminizeStar<Fst<Arc> >(*fst, &ofst, kDelta, NULL, max_states);
      std::cout << "FST after determinizing is:\n";
      {
        FstPrinter<Arc> fstprinter(ofst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
      assert(RandEquivalent(*fst, ofst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length, max*/));
    } catch (...) {
      std::cout << "Failed to determinize *this FST (probably not determinizable)\n";
    }
    delete fst;
  }
}

TestDeterminizeLattice()

void fst::TestDeterminizeLattice

(

)

Definition at line 76 of file determinize-lattice-test.cc.

References RandFstOptions::allow_empty, rnnlm::i, DeterminizeLatticeOptions::max_mem, RandFstOptions::n_arcs, RandFstOptions::n_final, RandFstOptions::n_states, kaldi::Rand(), and RandFstOptions::weight_multiplier.

                                                  {
  typedef typename Arc::Weight Weight;
  typedef int32 Int;
  typedef ArcTpl<CompactLatticeWeightTpl<Weight, Int> > CompactArc;

  for(int i = 0; i < 100; i++) {
    RandFstOptions opts;
    opts.n_states = 4;
    opts.n_arcs = 10;
    opts.n_final = 2;
    opts.allow_empty = false;
    opts.weight_multiplier = 0.5; // impt for the randomly generated weights
    // to be exactly representable in float,
    // or this test fails because numerical differences can cause symmetry in
    // weights to be broken, which causes the wrong path to be chosen as far
    // as the string part is concerned.

    VectorFst<Arc> *fst = RandFst<Arc>();
    std::cout << "FST before lattice-determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<Arc> det_fst;
    try {
      DeterminizeLatticeOptions lat_opts;
      lat_opts.max_mem = 100;

      if (!DeterminizeLattice<TropicalWeight, int32>(*fst, &det_fst, lat_opts, NULL))
        throw std::runtime_error("could not determinize");
      std::cout << "FST after lattice-determinizing is:\n";
      {
        FstPrinter<Arc> fstprinter(det_fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
      assert(det_fst.Properties(kIDeterministic, true) & kIDeterministic);
      // OK, now determinize it a different way and check equivalence.
      // [note: it's not normal determinization, it's taking the best path
      // for any input-symbol sequence....
      VectorFst<CompactArc> compact_fst, compact_det_fst;
      ConvertLattice<Weight, Int>(*fst, &compact_fst, false);
      std::cout << "Compact FST is:\n";
      {
        FstPrinter<CompactArc> fstprinter(compact_fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
      if (kaldi::Rand() % 2 == 1)
        ConvertLattice<Weight, Int>(det_fst, &compact_det_fst, false);
      else
        if (!DeterminizeLattice<TropicalWeight, int32>(*fst, &compact_det_fst, lat_opts, NULL))
          throw std::runtime_error("could not determinize");

      std::cout << "Compact version of determinized FST is:\n";
      {
        FstPrinter<CompactArc> fstprinter(compact_det_fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }

      assert(RandEquivalent(compact_det_fst, compact_fst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length, max*/));
    } catch (...) {
      std::cout << "Failed to lattice-determinize this FST (probably not determinizable)\n";
    }
    delete fst;
  }
}

TestDeterminizeLattice2()

void fst::TestDeterminizeLattice2

(

)

Definition at line 144 of file determinize-lattice-test.cc.

References RandFstOptions::acyclic, and rnnlm::i.

                                                   {
  RandFstOptions opts;
  opts.acyclic = true;
  for(int i = 0; i < 100; i++) {
    VectorFst<Arc> *fst = RandFst<Arc>(opts);
    std::cout << "FST before lattice-determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<Arc> ofst;
    DeterminizeLattice<TropicalWeight, int32>(*fst, &ofst);
    std::cout << "FST after lattice-determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(ofst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    delete fst;
  }
}

TestDeterminizeLatticePruned()

void fst::TestDeterminizeLatticePruned

(

)

Definition at line 36 of file determinize-lattice-pruned-test.cc.

References RandFstOptions::acyclic, RandFstOptions::allow_empty, rnnlm::i, KALDI_ASSERT, DeterminizeLatticePrunedOptions::max_arcs, DeterminizeLatticePrunedOptions::max_mem, DeterminizeLatticePrunedOptions::max_states, RandFstOptions::n_arcs, RandFstOptions::n_final, RandFstOptions::n_states, kaldi::PruneLattice(), kaldi::Rand(), and RandFstOptions::weight_multiplier.

                                                        {
  typedef kaldi::int32 Int;
  typedef typename Arc::Weight Weight;
  typedef ArcTpl<CompactLatticeWeightTpl<Weight, Int> > CompactArc;

  for(int i = 0; i < 100; i++) {
    RandFstOptions opts;
    opts.n_states = 4;
    opts.n_arcs = 10;
    opts.n_final = 2;
    opts.allow_empty = false;
    opts.weight_multiplier = 0.5; // impt for the randomly generated weights
    opts.acyclic = true;
    // to be exactly representable in float,
    // or this test fails because numerical differences can cause symmetry in
    // weights to be broken, which causes the wrong path to be chosen as far
    // as the string part is concerned.

    VectorFst<Arc> *fst = RandPairFst<Arc>(opts);

    bool sorted = TopSort(fst);
    KALDI_ASSERT(sorted);

    ILabelCompare<Arc> ilabel_comp;
    if (kaldi::Rand() % 2 == 0)
      ArcSort(fst, ilabel_comp);

    std::cout << "FST before lattice-determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<Arc> det_fst;
    try {
      DeterminizeLatticePrunedOptions lat_opts;
      lat_opts.max_mem = ((kaldi::Rand() % 2 == 0) ? 100 : 1000);
      lat_opts.max_states = ((kaldi::Rand() % 2 == 0) ? -1 : 20);
      lat_opts.max_arcs = ((kaldi::Rand() % 2 == 0) ? -1 : 30);
      bool ans = DeterminizeLatticePruned<Weight>(*fst, 10.0, &det_fst, lat_opts);

      std::cout << "FST after lattice-determinizing is:\n";
      {
        FstPrinter<Arc> fstprinter(det_fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
      KALDI_ASSERT(det_fst.Properties(kIDeterministic, true) & kIDeterministic);
      // OK, now determinize it a different way and check equivalence.
      // [note: it's not normal determinization, it's taking the best path
      // for any input-symbol sequence....


      VectorFst<Arc> pruned_fst(*fst);
      if (pruned_fst.NumStates() != 0)
        kaldi::PruneLattice(10.0, &pruned_fst);

      VectorFst<CompactArc> compact_pruned_fst, compact_pruned_det_fst;
      ConvertLattice<Weight, Int>(pruned_fst, &compact_pruned_fst, false);
      std::cout << "Compact pruned FST is:\n";
      {
        FstPrinter<CompactArc> fstprinter(compact_pruned_fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
      ConvertLattice<Weight, Int>(det_fst, &compact_pruned_det_fst, false);

      std::cout << "Compact version of determinized FST is:\n";
      {
        FstPrinter<CompactArc> fstprinter(compact_pruned_det_fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }

      if (ans)
        KALDI_ASSERT(RandEquivalent(compact_pruned_det_fst, compact_pruned_fst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length, max*/));
    } catch (...) {
      std::cout << "Failed to lattice-determinize this FST (probably not determinizable)\n";
    }
    delete fst;
  }
}

TestDeterminizeLatticePruned2()

void fst::TestDeterminizeLatticePruned2

(

)

Definition at line 117 of file determinize-lattice-pruned-test.cc.

References RandFstOptions::acyclic, and rnnlm::i.

                                                         {
  typedef typename Arc::Weight Weight;
  RandFstOptions opts;
  opts.acyclic = true;
  for(int i = 0; i < 100; i++) {
    VectorFst<Arc> *fst = RandPairFst<Arc>(opts);
    std::cout << "FST before lattice-determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    VectorFst<Arc> ofst;
    DeterminizeLatticePruned<Weight>(*fst, 10.0, &ofst);
    std::cout << "FST after lattice-determinizing is:\n";
    {
      FstPrinter<Arc> fstprinter(ofst, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }
    delete fst;
  }
}

TestDeterminizeStarInLog()

void fst::TestDeterminizeStarInLog

(

)

Definition at line 79 of file fstext-utils-test.cc.

References HighestNumberedInputSymbol(), and PreDeterminize().

                                                     {
  VectorFst<Arc> *fst = RandFst<Arc>();
  VectorFst<Arc> fst_copy(fst);
  typename Arc::Label next_sym = 1 + HighestNumberedInputSymbol(*fst);
  vector<typename Arc::Label> syms;
  PreDeterminize(fst, NULL, "#", next_sym, &syms);


}

TestEnsureEpsilonProperty()

void fst::TestEnsureEpsilonProperty

(

)

Definition at line 27 of file epsilon-property-test.cc.

References RandFstOptions::acyclic, ComputeStateInfo(), EnsureEpsilonProperty(), rnnlm::i, kStateHasEpsilonArcsEntering, kStateHasEpsilonArcsLeaving, kStateHasNonEpsilonArcsEntering, kStateHasNonEpsilonArcsLeaving, and kaldi::Rand().

Referenced by main().

                                 {
  
  for (int32 i = 0; i < 10; i++) {
    RandFstOptions opts;
    opts.acyclic = true;
    VectorFst<LogArc> *fst = RandFst<LogArc>(opts);
    VectorFst<LogArc> fst2(*fst); // copy it...
    EnsureEpsilonProperty(&fst2);

    std::vector<char> info;
    ComputeStateInfo(fst2, &info);
    for (size_t i = 0; i < info.size(); i++) {
      char c = info[i];
      assert(!((c & kStateHasEpsilonArcsEntering) != 0 &&
               (c & kStateHasNonEpsilonArcsEntering) != 0));
      assert(!((c & kStateHasEpsilonArcsLeaving) != 0 &&
               (c & kStateHasNonEpsilonArcsLeaving) != 0));
    }
    assert(RandEquivalent(fst2, *fst, 5, 0.01, kaldi::Rand(), 10));    
    delete fst;
  }
}

TestEqualAlign()

void fst::TestEqualAlign

(

)

Definition at line 336 of file fstext-utils-test.cc.

References RandFstOptions::allow_empty, EqualAlign(), GetLinearSymbolSequence(), rnnlm::i, and kaldi::Rand().

                      {
  for (size_t i = 0; i < 4; i++) {
    RandFstOptions opts;
    opts.allow_empty = false;
    VectorFst<Arc> *fst = RandFst<Arc>();
    int length = 10 + kaldi::Rand() % 20;

    VectorFst<Arc> fst_path;
    if (EqualAlign(*fst, length, kaldi::Rand(), &fst_path)) {
      std::cout << "EqualAlign succeeded\n";
      vector<int32> isymbol_seq, osymbol_seq;
      typename Arc::Weight weight;
      GetLinearSymbolSequence(fst_path, &isymbol_seq, &osymbol_seq, &weight);
      assert(isymbol_seq.size() == length);
      Invert(&fst_path);
      VectorFst<Arc> fst_composed;
      Compose(fst_path, *fst, &fst_composed);
      assert(fst_composed.Start() != kNoStateId);  // make sure nonempty.
    } else {
      std::cout << "EqualAlign did not generate alignment\n";
    }
    delete fst;
  }
}

TestFactor() [1/2]

static void fst::TestFactor ( )

static

Definition at line 32 of file factor-test.cc.

References CreateFactorFst(), ExpandInputSequences(), Factor(), rnnlm::i, MapInputSymbols(), rnnlm::n, kaldi::Rand(), and kaldi::RandUniform().

                                             {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> fst;
  int n_syms = 2 + kaldi::Rand() % 5, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%10;

  SymbolTable symtab("my-symbol-table"), *sptr = &symtab;

  vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++) {
    std::stringstream ss;
    if (i == 0) ss << "<eps>";
    else ss<<i;
    Label cur_lab = sptr->AddSymbol(ss.str());
    assert(cur_lab == (Label)i);
    all_syms.push_back(cur_lab);
  }
  assert(all_syms[0] == 0);

  fst.AddState();
  int cur_num_states = 1;
  for (int i = 0; i < n_arcs; i++) {
    StateId src_state = kaldi::Rand() % cur_num_states;
    StateId dst_state;
    if (kaldi::RandUniform() < 0.1) dst_state = kaldi::Rand() % cur_num_states;
    else {
      dst_state = cur_num_states++; fst.AddState();
    }
    Arc arc;
    if (kaldi::RandUniform() < 0.5) arc.ilabel = all_syms[kaldi::Rand()%all_syms.size()];
    else arc.ilabel = 0;
    if (kaldi::RandUniform() < 0.5) arc.olabel = all_syms[kaldi::Rand()%all_syms.size()];
    else arc.olabel = 0;
    arc.weight = (Weight) (0 + 0.1*(kaldi::Rand() % 5));
    arc.nextstate = dst_state;
    fst.AddArc(src_state, arc);
  }
  for (int i = 0; i < n_final; i++) {
    fst.SetFinal(kaldi::Rand() % cur_num_states,  (Weight) (0 + 0.1*(kaldi::Rand() % 5)));
  }

  if (kaldi::RandUniform() < 0.8)   fst.SetStart(0);  // usually leads to nicer examples.
  else fst.SetStart(kaldi::Rand() % cur_num_states);

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(&fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  if (fst.Start() == kNoStateId) return;  // "Connect" made it empty.

  VectorFst<Arc> fst_pushed;
  Push<Arc, REWEIGHT_TO_INITIAL>(fst, &fst_pushed, kPushLabels);

  VectorFst<Arc> fst_factored;
  vector<vector<typename Arc::Label> > symbols;

  Factor(fst, &fst_factored, &symbols);

  // Check no epsilons in "symbols".
  for (size_t i = 0; i < symbols.size(); i++)
    assert(symbols[i].size() == 0 || *(std::min(symbols[i].begin(), symbols[i].end())) > 0);

  VectorFst<Arc> fst_factored_pushed;
  vector<vector<typename Arc::Label> > symbols_pushed;
  Factor(fst_pushed, &fst_factored_pushed, &symbols_pushed);

  std::cout << "Unfactored has "<<fst.NumStates()<<" states, factored has "<<fst_factored.NumStates()<<", and pushed+factored has "<<fst_factored_pushed.NumStates()<<'\n';

  assert(fst_factored.NumStates() <= fst.NumStates());
  //  assert(fst_factored_pushed.NumStates() <= fst_factored.NumStates());  // pushing should only help. [ no, it doesn't]
  assert(fst_factored_pushed.NumStates() <= fst_pushed.NumStates());

  VectorFst<Arc> fst_factored_copy(fst_factored);

  VectorFst<Arc> fst_factored_unfactored(fst_factored);
  ExpandInputSequences(symbols, &fst_factored_unfactored);

  VectorFst<Arc> factor_fst;
  CreateFactorFst(symbols, &factor_fst);
  VectorFst<Arc> fst_factored_unfactored2;
  Compose(factor_fst, fst_factored, &fst_factored_unfactored2);

  ExpandInputSequences(symbols_pushed, &fst_factored_pushed);

  assert(RandEquivalent(fst, fst_factored_unfactored, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  assert(RandEquivalent(fst, fst_factored_unfactored2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  assert(RandEquivalent(fst, fst_factored_pushed, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  {  // Have tested for equivalence; now do another test: that FactorFst actually finds all
    // the factors.  Do this by inserting factors using ExpandInputSequences and making sure it gets
    // rid of them all.
    Label max_label = *(std::max_element(all_syms.begin(), all_syms.end()));
    vector<vector<Label> > new_labels(max_label+1);
    for (Label l = 1; l < static_cast<Label>(new_labels.size()); l++) {
      int n = kaldi::Rand() % 5;
      for (int i = 0; i < n; i++) new_labels[l].push_back(kaldi::Rand() % 100);
    }
    VectorFst<Arc> fst_expanded(fst);
    ExpandInputSequences(new_labels, &fst_expanded);

    vector<vector<Label> > factors;
    VectorFst<Arc> fst_reduced;
    Factor(fst_expanded, &fst_reduced, &factors);
    assert(fst_reduced.NumStates() <= fst.NumStates());  // Checking that it found all the factors.
  }

  {  // This block test MapInputSymbols [but relies on the correctness of Factor
    // and ExpandInputSequences to do so].

    std::map<Label, Label> symbols_reverse_map;  // from new->old.
    symbols_reverse_map[0] = 0;  // map eps to eps.
    for (Label i = 1; i < static_cast<Label>(symbols.size()); i++) {
      Label new_i;
      do {
        new_i = kaldi::Rand() % (symbols.size() + 20);
      } while (symbols_reverse_map.count(new_i) == 1);
      symbols_reverse_map[new_i] = i;
    }
    vector<vector<Label> > symbols_new;
    vector<Label> symbol_map(symbols.size());  // from old->new.
    typename std::map<Label, Label>::iterator iter = symbols_reverse_map.begin();
    for (; iter != symbols_reverse_map.end(); iter++) {
      Label new_label = iter->first, old_label = iter->second;
      if (new_label >= static_cast<Label>(symbols_new.size())) symbols_new.resize(new_label+1);
      symbols_new[new_label] = symbols[old_label];
      symbol_map[old_label] = new_label;
    }
    MapInputSymbols(symbol_map, &fst_factored_copy);
    ExpandInputSequences(symbols_new, &fst_factored_copy);
    assert(RandEquivalent(fst, fst_factored_copy,
                          5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/,
                          100/*path length-- max?*/));
  }

}

TestFactor() [2/2]

void fst::TestFactor

(

)

Definition at line 33 of file trivial-factor-weight-test.cc.

References DeterminizeStar(), rnnlm::i, StringRepository< Label, StringId >::IdOfEmpty(), StringRepository< Label, StringId >::IdOfLabel(), StringRepository< Label, StringId >::IdOfSeq(), rnnlm::j, PreDeterminize(), kaldi::Rand(), StringRepository< Label, StringId >::RemovePrefix(), StringRepository< Label, StringId >::SeqOfId(), and TestStringRepository().

                                       {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  int n_syms = 2 + kaldi::Rand() % 5, n_states = 3 + kaldi::Rand() % 10, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%3;  // Up to 2 unique symbols.
  cout << "Testing pre-determinize with "<<n_syms<<" symbols, "<<n_states<<" states and "<<n_arcs<<" arcs and "<<n_final<<" final states.\n";
  SymbolTable *sptr = NULL;

  vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++)
    all_syms.push_back(i);

  // Create states.
  vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)n_final;j++) {
    StateId id = all_states[kaldi::Rand() % n_states];
    Weight weight = (Weight)(0.33*(kaldi::Rand() % 5) );
    printf("calling SetFinal with %d and %f\n", id, weight.Value());
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)n_arcs;i++) {
    Arc a;
    a.nextstate = all_states[kaldi::Rand() % n_states];
    a.ilabel = all_syms[kaldi::Rand() % n_syms];
    a.olabel = all_syms[kaldi::Rand() % n_syms];  // same input+output vocab.
    a.weight = (Weight) (0.33*(kaldi::Rand() % 2));
    StateId start_state = all_states[kaldi::Rand() % n_states];
    fst->AddArc(start_state, a);
  }

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  vector<Label> extra_syms;
  if (fst->Start() != kNoStateId) {  // "Connect" did not make it empty....
    PreDeterminize(fst, 1000, &extra_syms);
  }

  std::cout <<" printing after predeterminization\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  {  // Remove epsilon.  All default args.
    bool connect = true;
    Weight weight_threshold = Weight::Zero();
    int64 nstate = -1;  // Relates to pruning.
    double delta = kDelta;  // I think a small weight value.  Relates to some kind of pruning,
    // I guess.  But with no epsilon cycles, probably doensn't matter.
    RmEpsilon(fst, connect,  weight_threshold, nstate, delta);
  }

  std::cout <<" printing after double-epsilon removal\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  VectorFst<Arc> ofst_star;

  {
    printf("Converting to Gallic semiring");
    VectorFst<GallicArc<Arc> > gallic_fst;
    VectorFst<GallicArc<Arc> > gallic_fst_noeps;
    VectorFst<GallicArc<Arc> > gallic_fst_det;


    {
      printf("Determinizing with DeterminizeStar, converting to Gallic\n");
      DeterminizeStar(*fst, &gallic_fst);
    }

    {
      std::cout <<" printing gallic FST\n";
      FstPrinter<GallicArc<Arc> >  fstprinter(gallic_fst, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }


    // Map(ofst_star, &gallic_fst, ToGallicMapper<Arc, STRING_LEFT>());

    printf("Converting gallic back to regular\n");
    TrivialFactorWeightFst< GallicArc<Arc, GALLIC_LEFT>, GallicFactor<typename Arc::Label,
        typename Arc::Weight, GALLIC_LEFT> > fwfst(gallic_fst);
    {
      std::cout <<" printing factor-weight FST\n";
      FstPrinter<GallicArc<Arc> >  fstprinter(fwfst, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }

    Map(fwfst, &ofst_star, FromGallicMapper<Arc, GALLIC_LEFT>());

    {
      std::cout <<" printing after converting back to regular FST\n";
      FstPrinter<Arc> fstprinter(ofst_star, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }


    VectorFst<GallicArc<Arc> > new_gallic_fst;
    Map(ofst_star, &new_gallic_fst, ToGallicMapper<Arc, GALLIC_LEFT>());

    assert(RandEquivalent(gallic_fst, new_gallic_fst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  }

  delete fst;
}

TestLatticeStringRepository()

void fst::TestLatticeStringRepository

(

)

Definition at line 29 of file determinize-lattice-test.cc.

References LatticeStringRepository< IntType >::CommonPrefix(), LatticeStringRepository< IntType >::ConvertToVector(), LatticeStringRepository< IntType >::EmptyString(), rnnlm::i, LatticeStringRepository< IntType >::IsPrefixOf(), kaldi::Rand(), LatticeStringRepository< IntType >::ReduceToCommonPrefix(), and LatticeStringRepository< IntType >::Successor().

Referenced by main().

                                   {
  typedef int32 IntType;

  LatticeStringRepository<IntType> sr;
  typedef LatticeStringRepository<IntType>::Entry Entry;

  for(int i = 0; i < 100; i++) {
    int len = kaldi::Rand() % 5;
    vector<IntType> str(len), str2(kaldi::Rand() % 4);
    const Entry *e = NULL;
    for(int i = 0; i < len; i++) {
      str[i] = kaldi::Rand() % 5;
      e = sr.Successor(e, str[i]);
    }
    sr.ConvertToVector(e, &str2);
    assert(str == str2);

    int len2 = kaldi::Rand() % 5;
    str2.resize(len2);
    const Entry *f = sr.EmptyString(); // NULL
    for(int i = 0; i < len2; i++) {
      str2[i] = kaldi::Rand() % 5;
      f = sr.Successor(f, str2[i]);
    }
    vector<IntType> prefix, prefix2(kaldi::Rand() % 10),
        prefix3;
    for(int i = 0; i < len && i < len2; i++) {
      if (str[i] == str2[i]) prefix.push_back(str[i]);
      else break;
    }
    const Entry *g = sr.CommonPrefix(e, f);
    sr.ConvertToVector(g, &prefix2);
    sr.ConvertToVector(e, &prefix3);
    sr.ReduceToCommonPrefix(f, &prefix3);
    assert(prefix == prefix2);
    assert(prefix == prefix3);
    assert(sr.IsPrefixOf(g, e));
    assert(sr.IsPrefixOf(g, f));
    if (str.size() > prefix.size())
      assert(!sr.IsPrefixOf(e, g));
  }
}

TestMakeLinearAcceptor()

void fst::TestMakeLinearAcceptor

(

)

Definition at line 32 of file fstext-utils-test.cc.

References GetInputSymbols(), GetLinearSymbolSequence(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MakeLinearAcceptor(), NbestAsFsts(), kaldi::Rand(), and kaldi::SortAndUniq().

                              {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  int len = kaldi::Rand() % 10;
  vector<I> vec;
  vector<I> vec_nozeros;
  for (int i = 0; i < len; i++) {
    int j = kaldi::Rand() % len;
    vec.push_back(j);
    if (j != 0) vec_nozeros.push_back(j);
  }


  VectorFst<Arc> vfst;
  MakeLinearAcceptor(vec, &vfst);
  vector<I> vec2;
  vector<I> vec3;
  Weight w;
  GetLinearSymbolSequence(vfst, &vec2, &vec3, &w);
  assert(w == Weight::One());
  assert(vec_nozeros == vec2);
  assert(vec_nozeros == vec3);

  if (vec2.size() != 0 || vec3.size() != 0) { // This test might not work
    // for empty sequences...
    {
      vector<VectorFst<Arc> > fstvec;
      NbestAsFsts(vfst, 1, &fstvec);
      KALDI_ASSERT(fstvec.size() == 1);
      assert(RandEquivalent(vfst, fstvec[0], 2/*paths*/, 0.01/*delta*/,
                            kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
    }
  }
  bool include_eps = (kaldi::Rand() % 2 == 0);
  if (!include_eps) vec = vec_nozeros;
  kaldi::SortAndUniq(&vec);

  vector<I> vec4;
  GetInputSymbols(vfst, include_eps, &vec4);
  assert(vec4 == vec);
  vector<I> vec5;
  GetInputSymbols(vfst, include_eps, &vec5);
}

TestMakeLoopFst()

void fst::TestMakeLoopFst

(

)

Definition at line 305 of file fstext-utils-test.cc.

References rnnlm::i, MakeLoopFst(), MakeLoopFstCompare(), and kaldi::Rand().

                                            {

  int num_fsts = kaldi::Rand() % 10;
  vector<const ExpandedFst<Arc>* > fsts(num_fsts, (const ExpandedFst<Arc>*)NULL);
  for (int i = 0; i < num_fsts; i++) {
    if (kaldi::Rand() % 2 == 0) {  // put an fst there.
      VectorFst<Arc> *fst = RandFst<Arc>();
      Project(fst, PROJECT_INPUT);  // make input & output labels the same.
      fsts[i] = fst;
    } else { // this is to test that it works with the caching.
      fsts[i] = fsts[i/2];
    }
  }

  VectorFst<Arc> *fst1 = MakeLoopFst(fsts),
      *fst2 = MakeLoopFstCompare(fsts);

  assert(fst1->Properties(kOLabelSorted, kOLabelSorted) != 0);

  assert(RandEquivalent(*fst1, *fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
  delete fst1;
  delete fst2;
  std::sort(fsts.begin(), fsts.end());
  fsts.erase(std::unique(fsts.begin(), fsts.end()), fsts.end());
  for (int i = 0; i < (int)fsts.size(); i++)
    delete fsts[i];
}

TestMakeSymbolsSame()

void fst::TestMakeSymbolsSame

(

)

Definition at line 217 of file fstext-utils-test.cc.

References FollowingInputSymbolsAreSame(), MakeFollowingInputSymbolsSame(), MakePrecedingInputSymbolsSame(), PrecedingInputSymbolsAreSame(), and kaldi::Rand().

                                                {

  VectorFst<Arc> *fst = RandFst<Arc>();
  bool foll = (kaldi::Rand() % 2 == 0);
  bool is_symbol = (kaldi::Rand() % 2 == 0);


  VectorFst<Arc> fst2(*fst);

  if (foll) {
    MakeFollowingInputSymbolsSame(is_symbol, &fst2);
    assert(FollowingInputSymbolsAreSame(is_symbol, fst2));
  } else {
    MakePrecedingInputSymbolsSame(is_symbol, &fst2);
    assert(PrecedingInputSymbolsAreSame(is_symbol, fst2));
  }


  assert(RandEquivalent(*fst, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
}

TestMakeSymbolsSameClass()

void fst::TestMakeSymbolsSameClass

(

)

Definition at line 254 of file fstext-utils-test.cc.

References FollowingInputSymbolsAreSameClass(), MakeFollowingInputSymbolsSameClass(), MakePrecedingInputSymbolsSameClass(), PrecedingInputSymbolsAreSameClass(), and kaldi::Rand().

                                                     {

  VectorFst<Arc> *fst = RandFst<Arc>();
  bool foll = (kaldi::Rand() % 2 == 0);
  bool is_symbol = (kaldi::Rand() % 2 == 0);


  VectorFst<Arc> fst2(*fst);

  TestFunctor<Arc> f;
  if (foll) {
    MakeFollowingInputSymbolsSameClass(is_symbol, &fst2, f);
    assert(FollowingInputSymbolsAreSameClass(is_symbol, fst2, f));
  } else {
    MakePrecedingInputSymbolsSameClass(is_symbol, &fst2, f);
    assert(PrecedingInputSymbolsAreSameClass(is_symbol, fst2, f));
  }

  assert(RandEquivalent(*fst, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
}

TestMinimize()

void fst::TestMinimize

(

)

Definition at line 280 of file determinize-star-test.cc.

References DeleteISymbols(), DeterminizeStar(), rnnlm::i, rnnlm::j, PreDeterminize(), and kaldi::Rand().

                                         {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  int n_syms = 2 + kaldi::Rand() % 5, n_states = 3 + kaldi::Rand() % 10, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%3;  // Up to 2 unique symbols.
  std::cout << "Testing pre-determinize with "<<n_syms<<" symbols, "<<n_states<<" states and "<<n_arcs<<" arcs and "<<n_final<<" final states.\n";
  SymbolTable *sptr =NULL;

  std::vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++)
    all_syms.push_back(i);

  // Create states.
  std::vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)n_final;j++) {
    StateId id = all_states[kaldi::Rand() % n_states];
    Weight weight = (Weight)(0.33*(kaldi::Rand() % 5) );
    printf("calling SetFinal with %d and %f\n", id, weight.Value());
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)n_arcs;i++) {
    Arc a;
    a.nextstate = all_states[kaldi::Rand() % n_states];
    a.ilabel = all_syms[kaldi::Rand() % n_syms];
    a.olabel = all_syms[kaldi::Rand() % n_syms];  // same input+output vocab.
    a.weight = (Weight) (0.33*(kaldi::Rand() % 2));
    StateId start_state = all_states[kaldi::Rand() % n_states];
    fst->AddArc(start_state, a);
  }

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> *fst_copy_orig = new VectorFst<Arc>(*fst);

  std::vector<Label> extra_syms;
  if (fst->Start() != kNoStateId) {  // "Connect" did not make it empty....
    PreDeterminize(fst, 1000, &extra_syms);
  }

  std::cout <<" printing after predeterminization\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  {  // Remove epsilon.  All default args.
    bool connect = true;
    Weight weight_threshold = Weight::Zero();
    int64 nstate = -1;  // Relates to pruning.
    double delta = kDelta;  // I think a small weight value.  Relates to some kind of pruning,
    // I guess.  But with no epsilon cycles, probably doensn't matter.
    RmEpsilon(fst, connect,  weight_threshold, nstate, delta);
  }

  std::cout <<" printing after epsilon removal\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  VectorFst<Arc> ofst_orig;
  VectorFst<Arc> ofst_star;

  {
    printf("Determinizing with baseline\n");
    DeterminizeOptions<Arc> opts;  // Default options.
    Determinize(*fst, &ofst_orig, opts);
  }
  {
    std::cout <<" printing after determinization [baseline]\n";
    FstPrinter<Arc> fstprinter(ofst_orig, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  {
    printf("Determinizing with DeterminizeStar to Gallic semiring\n");
    VectorFst<GallicArc<Arc> > gallic_fst;

    DeterminizeStar(*fst, &gallic_fst);
    {
      std::cout <<" printing after determinization by DeterminizeStar [in gallic]\n";
      FstPrinter<GallicArc< Arc> > fstprinter(gallic_fst, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }


    printf("Pushing weights\n");
    Push(&gallic_fst, REWEIGHT_TO_INITIAL, kDelta);

    {
      std::cout <<" printing after pushing weights [in gallic]\n";
      FstPrinter<GallicArc< Arc> > fstprinter(gallic_fst, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }


    printf("Minimizing [in Gallic]\n");
    Minimize(&gallic_fst);
    {
      std::cout <<" printing after  minimization [in gallic]\n";
      FstPrinter<GallicArc< Arc> > fstprinter(gallic_fst, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }

    printf("Converting gallic back to regular [my approach]\n");
    TrivialFactorWeightFst< GallicArc<Arc, GALLIC_LEFT>, GallicFactor<typename Arc::Label,
        typename Arc::Weight, GALLIC_LEFT> > fwfst(gallic_fst);
    {
      std::cout <<" printing factor-weight FST\n";
      FstPrinter<GallicArc< Arc> > fstprinter(fwfst, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }

    Map(fwfst, &ofst_star, FromGallicMapper<Arc, GALLIC_LEFT>());

    {
      std::cout <<" printing after converting back to regular FST\n";
      FstPrinter<Arc> fstprinter(ofst_star, sptr, sptr, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }

  }


  assert(RandEquivalent(ofst_orig, ofst_star, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));


  int64 num_removed = DeleteISymbols(&ofst_star, extra_syms);
  std::cout <<" printing after removing "<<num_removed<<" instances of extra symbols\n";
  {
    FstPrinter<Arc> fstprinter(ofst_star, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  std::cout <<" Checking equivalent to original FST.\n";
  // giving Rand() as a seed stops the random number generator from always being reset to
  // the same point each time, while maintaining determinism of the test.
  assert(RandEquivalent(ofst_star, *fst_copy_orig, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
  delete fst_copy_orig;
}

TestPreDeterminize()

void fst::TestPreDeterminize

(

)

Definition at line 33 of file pre-determinize-test.cc.

References DeleteISymbols(), HighestNumberedInputSymbol(), rnnlm::i, rnnlm::j, PreDeterminize(), and kaldi::Rand().

                                               {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  int n_syms = 2 + kaldi::Rand() % 5, n_states = 3 + kaldi::Rand() % 10, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%3;  // Up to 2 unique symbols.
  cout << "Testing pre-determinize with "<<n_syms<<" symbols, "<<n_states<<" states and "<<n_arcs<<" arcs and "<<n_final<<" final states.\n";
  SymbolTable *sptr = NULL;

  vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++)
    all_syms.push_back(i);

  // Create states.
  vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)n_final;j++) {
    StateId id = all_states[kaldi::Rand() % n_states];
    Weight weight = (Weight)(0.33*(kaldi::Rand() % 5) );
    printf("calling SetFinal with %d and %f\n", id, weight.Value());
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)n_arcs;i++) {
    Arc a;
    a.nextstate = all_states[kaldi::Rand() % n_states];
    a.ilabel = all_syms[kaldi::Rand() % n_syms];
    a.olabel = all_syms[kaldi::Rand() % n_syms];  // same input+output vocab.
    a.weight = (Weight) (0.33*(kaldi::Rand() % 2));
    StateId start_state = all_states[kaldi::Rand() % n_states];
    fst->AddArc(start_state, a);
  }

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> *fst_copy_orig = new VectorFst<Arc>(*fst);

  vector<Label> extra_syms;
  if (fst->Start() != kNoStateId) {  // "Connect" did not make it empty....
    typename Arc::Label highest_sym = HighestNumberedInputSymbol(*fst);
    PreDeterminize(fst, highest_sym+1, &extra_syms);
  }

  std::cout <<" printing after predeterminization\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  {  // Remove epsilon.  All default args.
    bool connect = true;
    Weight weight_threshold = Weight::Zero();
    int64 nstate = -1;  // Relates to pruning.
    double delta = kDelta;  // I think a small weight value.  Relates to some kind of pruning,
    // I guess.  But with no epsilon cycles, probably doensn't matter.
    RmEpsilon(fst, connect,  weight_threshold, nstate, delta);
  }

  std::cout <<" printing after epsilon removal\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  VectorFst<Arc> ofst;
  DeterminizeOptions<Arc> opts;  // Default options.
  Determinize(*fst, &ofst, opts);
  std::cout <<" printing after determinization\n";
  {
    FstPrinter<Arc> fstprinter(ofst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  int64 num_removed = DeleteISymbols(&ofst, extra_syms);
  std::cout <<" printing after removing "<<num_removed<<" instances of extra symbols\n";
  {
    FstPrinter<Arc> fstprinter(ofst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  std::cout <<" Checking equivalent to original FST.\n";
  // giving Rand() as a seed stops the random number generator from always being reset to
  // the same point each time, while maintaining determinism of the test.
  assert(RandEquivalent(ofst, *fst_copy_orig, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
  delete fst_copy_orig;
}

TestPruneSpecial()

static void fst::TestPruneSpecial ( )

static

Definition at line 27 of file prune-special-test.cc.

References RandFstOptions::acyclic, KALDI_ASSERT, and kaldi::Rand().

Referenced by main().

                               {
  typedef StdArc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;
  typedef Arc::Weight Weight;

  RandFstOptions opts;
  opts.acyclic = false;
  VectorFst<Arc> *ifst = RandFst<StdArc>(opts);

  float beam = 0.55;

  {
    FstPrinter<Arc> fstprinter(*ifst, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
    std::cout << std::endl;
  }

  // Do the special pruning.
  VectorFst<Arc> ofst1;
  PruneSpecial<StdArc>(*ifst, &ofst1, beam);
  {
    FstPrinter<Arc> fstprinter(ofst1, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
    std::cout << std::endl;
  }

  // Do the normal pruning.
  VectorFst<Arc> ofst2;
  Prune(*ifst, &ofst2, beam);
  {
    FstPrinter<Arc> fstprinter(ofst2, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
    std::cout << std::endl;
  }

  KALDI_ASSERT(RandEquivalent(ofst1, ofst2,
                              5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/,
                              100/*path length-- max?*/));

  delete ifst;
}

TestPush()

void fst::TestPush

(

)

Definition at line 202 of file determinize-star-test.cc.

References rnnlm::i, rnnlm::j, PreDeterminize(), and kaldi::Rand().

                                     {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  int n_syms = 2 + kaldi::Rand() % 5, n_states = 3 + kaldi::Rand() % 10, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%3;  // Up to 2 unique symbols.
  std::cout << "Testing pre-determinize with "<<n_syms<<" symbols, "<<n_states<<" states and "<<n_arcs<<" arcs and "<<n_final<<" final states.\n";
  SymbolTable *sptr = NULL;

  std::vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++)
    all_syms.push_back(i);

  // Create states.
  std::vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)n_final;j++) {
    StateId id = all_states[kaldi::Rand() % n_states];
    Weight weight = (Weight)(0.33*(kaldi::Rand() % 5) );
    printf("calling SetFinal with %d and %f\n", id, weight.Value());
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)n_arcs;i++) {
    Arc a;
    a.nextstate = all_states[kaldi::Rand() % n_states];
    a.ilabel = all_syms[kaldi::Rand() % n_syms];
    a.olabel = all_syms[kaldi::Rand() % n_syms];  // same input+output vocab.
    a.weight = (Weight) (0.33*(kaldi::Rand() % 2));
    StateId start_state = all_states[kaldi::Rand() % n_states];
    fst->AddArc(start_state, a);
  }

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> *fst_copy_orig = new VectorFst<Arc>(*fst);

  std::vector<Label> extra_syms;
  if (fst->Start() != kNoStateId) {  // "Connect" did not make it empty....
    PreDeterminize(fst, 1000, &extra_syms);
  }

  VectorFst<Arc> fst_pushed;
  std::cout << "Pushing FST\n";
  Push<Arc, REWEIGHT_TO_INITIAL>(*fst, &fst_pushed, kPushWeights|kPushLabels, kDelta);

  std::cout <<" printing after pushing\n";
  {
    FstPrinter<Arc> fstprinter(fst_pushed, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  assert(RandEquivalent(*fst, fst_pushed, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
  delete fst_copy_orig;
}

TestPushInLog()

void fst::TestPushInLog

(

)

Definition at line 182 of file fstext-utils-test.cc.

References kaldi::Rand().

                     {  // also tests SafeDeterminizeMinimizeWrapper().
  typedef StdArc Arc;
  typedef  Arc::Label Label;
  typedef  Arc::StateId StateId;
  typedef  Arc::Weight Weight;

  VectorFst<Arc> *fst = RandFst<Arc>();
  VectorFst<Arc> fst2(*fst);
  PushInLog<REWEIGHT_TO_INITIAL>(&fst2, kPushLabels|kPushWeights, 0.01);  // speed it up using large delta.
  assert(RandEquivalent(*fst, fst2, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));

  delete fst;
}

TestPushSpecial()

static void fst::TestPushSpecial ( )

static

Definition at line 31 of file push-special-test.cc.

References IsStochasticFstInLog(), KALDI_ASSERT, KALDI_LOG, PushSpecial(), and kaldi::Rand().

Referenced by main().

                              {
  typedef StdArc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;
  typedef Arc::Weight Weight;

  VectorFst<Arc> *fst = RandFst<StdArc>();

  {
    FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> fst_copy(*fst);

  float delta = kDelta;
  PushSpecial(&fst_copy, delta);

  Weight min, max;
  float delta_dontcare = 0.1;
  IsStochasticFstInLog(fst_copy, delta_dontcare, &min, &max);
  // the per-state normalizers are allowed to deviate from the average by delta
  // up and down, so the difference from the min to max weight should be 2*delta
  // or less.  We give it a bit of wiggle room (->2.5) due to numerical roundoff.


  {
    FstPrinter<Arc> fstprinter(fst_copy, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  KALDI_LOG << "Min value is " << min.Value() << ", max value is " << max.Value();

  // below, should be <= delta but different pieces of code compute this in this
  // part vs. push-special, so the roundoff may be different.
  KALDI_ASSERT(std::abs(min.Value() - max.Value()) <=  1.2 * delta);

  KALDI_ASSERT(RandEquivalent(*fst, fst_copy,
                              5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
  delete fst;
}

TestRemoveEpsLocal()

static void fst::TestRemoveEpsLocal ( )

static

Definition at line 33 of file remove-eps-local-test.cc.

References rnnlm::i, kaldi::Rand(), kaldi::RandUniform(), and RemoveEpsLocal().

                                                     {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> fst;
  int n_syms = 2 + kaldi::Rand() % 5, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%10;

  SymbolTable symtab("my-symbol-table"), *sptr = &symtab;

  vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++) {
    std::stringstream ss;
    if (i == 0) ss << "<eps>";
    else ss<<i;
    Label cur_lab = sptr->AddSymbol(ss.str());
    assert(cur_lab == (Label)i);
    all_syms.push_back(cur_lab);
  }
  assert(all_syms[0] == 0);

  fst.AddState();
  int cur_num_states = 1;
  for (int i = 0; i < n_arcs; i++) {
    StateId src_state = kaldi::Rand() % cur_num_states;
    StateId dst_state;
    if (kaldi::RandUniform() < 0.1) dst_state = kaldi::Rand() % cur_num_states;
    else {
      dst_state = cur_num_states++; fst.AddState();
    }
    Arc arc;
    if (kaldi::RandUniform() < 0.3) arc.ilabel = all_syms[kaldi::Rand()%all_syms.size()];
    else arc.ilabel = 0;
    if (kaldi::RandUniform() < 0.3) arc.olabel = all_syms[kaldi::Rand()%all_syms.size()];
    else arc.olabel = 0;
    arc.weight = (Weight) (0 + 0.1*(kaldi::Rand() % 5));
    arc.nextstate = dst_state;
    fst.AddArc(src_state, arc);
  }
  for (int i = 0; i < n_final; i++) {
    fst.SetFinal(kaldi::Rand() % cur_num_states,  (Weight) (0 + 0.1*(kaldi::Rand() % 5)));
  }

  if (kaldi::RandUniform() < 0.8)   fst.SetStart(0);  // usually leads to nicer examples.
  else fst.SetStart(kaldi::Rand() % cur_num_states);

  Connect(&fst);
  if (fst.Start() == kNoStateId) return;  // "Connect" made it empty.

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> fst_copy1(fst);


  RemoveEpsLocal(&fst_copy1);



  {
    std::cout << "copy1 = \n";
    FstPrinter<Arc> fstprinter(fst_copy1, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }


  int num_states_0 = fst.NumStates();
  int num_states_1 = fst_copy1.NumStates();


  std::cout << "Number of states 0 = "<<num_states_0<<", 1 = "<<num_states_1<<'\n';

  assert(RandEquivalent(fst, fst_copy1, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
}

TestRemoveEpsLocalSpecial()

static void fst::TestRemoveEpsLocalSpecial ( )

static

Definition at line 113 of file remove-eps-local-test.cc.

References ApproxEqual(), Divide(), IsStochasticFst(), Plus(), kaldi::Rand(), and RemoveEpsLocalSpecial().

Referenced by main().

                                        {
  // test that RemoveEpsLocalSpecial preserves equivalence in tropical while
  // maintaining stochasticity in log.
  typedef VectorFst<LogArc> Fst;
  typedef LogArc::Weight Weight;
  typedef LogArc::StateId StateId;
  typedef LogArc Arc;
  VectorFst<LogArc> *logfst = RandFst<LogArc>();

  { // Make the FST stochastic.
    for (StateId s = 0; s < logfst->NumStates(); s++) {
      Weight w = logfst->Final(s);
      for (ArcIterator<Fst> aiter(*logfst, s); !aiter.Done(); aiter.Next()) {
        w = Plus(w, aiter.Value().weight);
      }
      if (w != Weight::Zero()) {
        logfst->SetFinal(s, Divide(logfst->Final(s), w, DIVIDE_ANY));
        for (MutableArcIterator<Fst> aiter(logfst, s); !aiter.Done(); aiter.Next()) {
          Arc a = aiter.Value();
          a.weight = Divide(a.weight, w, DIVIDE_ANY);
          aiter.SetValue(a);
        }
      }
    }
  }
#ifndef _MSC_VER
  assert(IsStochasticFst(*logfst, kDelta*10));
#endif
  {
    std::cout << "logfst = \n";
    FstPrinter<LogArc> fstprinter(*logfst, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<StdArc> fst;
  Cast(*logfst, &fst);
  VectorFst<StdArc> fst_copy(fst);
  RemoveEpsLocalSpecial(&fst);  // removes eps in std-arc but keep stochastic in log-arc
  // make sure equivalent.
  assert(RandEquivalent(fst, fst_copy, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
  VectorFst<LogArc> logfst2;
  Cast(fst, &logfst2);

  {
    std::cout << "logfst2 = \n";
    FstPrinter<LogArc> fstprinter(logfst2, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  if (ApproxEqual(ShortestDistance(*logfst), ShortestDistance(logfst2))) {
    // make sure we preserved stochasticity in cases where doing so was
    // possible... if the log-semiring total weight changed, then it is
    // not possible so don't assert this.
    assert(IsStochasticFst(logfst2, kDelta*10));
  }
  delete logfst;
}

TestRemoveUselessArcs()

void fst::TestRemoveUselessArcs

(

)

Definition at line 370 of file fstext-utils-test.cc.

References RandFstOptions::allow_empty, ApproxEqual(), rnnlm::i, and RemoveUselessArcs().

                             {
  for (size_t i = 0; i < 4; i++) {
    RandFstOptions opts;
    opts.allow_empty = false;
    VectorFst<Arc> *fst = RandFst<Arc>();
    // Print(*fst, "[testremoveuselessarcs]:fst:");
    UniformArcSelector<Arc> selector;
    RandGenOptions<UniformArcSelector<Arc> > randgen_opts(selector);
    VectorFst<Arc> fst_path;
    RandGen(*fst, &fst_path, randgen_opts);
    Project(&fst_path, PROJECT_INPUT);
    // Print(fst_path, "[testremoveuselessarcs]:fstpath:");

    VectorFst<Arc> fst_nouseless(*fst);
    RemoveUselessArcs(&fst_nouseless);
    // Print(fst_nouseless, "[testremoveuselessarcs]:fst_nouseless:");

    VectorFst<Arc> orig_composed,
        nouseless_composed;
    Compose(fst_path, *fst, &orig_composed);
    Compose(fst_path, fst_nouseless, &nouseless_composed);

    // Print(orig_composed, "[testremoveuselessarcs]:orig_composed");
    // Print(nouseless_composed, "[testremoveuselessarcs]:nouseless_composed");

    VectorFst<Arc> orig_bestpath,
        nouseless_bestpath;
    ShortestPath(orig_composed, &orig_bestpath);
    ShortestPath(nouseless_composed, &nouseless_bestpath);
    // Print(orig_bestpath, "[testremoveuselessarcs]:orig_bestpath");
    // Print(nouseless_bestpath, "[testremoveuselessarcs]:nouseless_bestpath");

    typename Arc::Weight worig, wnouseless;
    GetLinearSymbolSequence<Arc, int>(orig_bestpath, NULL, NULL, &worig);
    GetLinearSymbolSequence<Arc, int>(nouseless_bestpath, NULL, NULL, &wnouseless);
    assert(ApproxEqual(worig, wnouseless, kDelta));

    // assert(RandEquivalent(orig_bestpath, nouseless_bestpath, 5/*paths*/, 0.01/*delta*/, Rand()/*seed*/, 100/*path length-- max?*/));
    delete fst;
  }
}

TestSafeDeterminizeWrapper()

void fst::TestSafeDeterminizeWrapper

(

)

Definition at line 90 of file fstext-utils-test.cc.

References rnnlm::i, rnnlm::j, KALDI_LOG, kaldi::Rand(), SafeDeterminizeMinimizeWrapper(), SafeDeterminizeMinimizeWrapperInLog(), and SafeDeterminizeWrapper().

                                                       {  // also tests SafeDeterminizeMinimizeWrapper().
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;

  VectorFst<Arc> *fst = new VectorFst<Arc>();
  int n_syms = 2 + kaldi::Rand() % 5, n_states = 3 + kaldi::Rand() % 10, n_arcs = 5 + kaldi::Rand() % 30, n_final = 1 + kaldi::Rand()%3;  // Up to 2 unique symbols.
  cout << "Testing pre-determinize with "<<n_syms<<" symbols, "<<n_states<<" states and "<<n_arcs<<" arcs and "<<n_final<<" final states.\n";
  SymbolTable *sptr = new SymbolTable("my-symbol-table");
  sptr->AddSymbol("<eps>");
  delete sptr;
  sptr = new SymbolTable("my-symbol-table");

  vector<Label> all_syms;  // including epsilon.
  // Put symbols in the symbol table from 1..n_syms-1.
  for (size_t i = 0;i < (size_t)n_syms;i++) {
    std::stringstream ss;
    if (i == 0) ss << "<eps>";
    else ss<<i;
    Label cur_lab = sptr->AddSymbol(ss.str());
    assert(cur_lab == (Label)i);
    all_syms.push_back(cur_lab);
  }
  assert(all_syms[0] == 0);

  // Create states.
  vector<StateId> all_states;
  for (size_t i = 0;i < (size_t)n_states;i++) {
    StateId this_state = fst->AddState();
    if (i == 0) fst->SetStart(i);
    all_states.push_back(this_state);
  }
  // Set final states.
  for (size_t j = 0;j < (size_t)n_final;j++) {
    StateId id = all_states[kaldi::Rand() % n_states];
    Weight weight = (Weight)(0.33*(kaldi::Rand() % 5) );
    printf("calling SetFinal with %d and %f\n", id, weight.Value());
    fst->SetFinal(id, weight);
  }
  // Create arcs.
  for (size_t i = 0;i < (size_t)n_arcs;i++) {
    Arc a;
    a.nextstate = all_states[kaldi::Rand() % n_states];
    a.ilabel = all_syms[kaldi::Rand() % n_syms];
    a.olabel = all_syms[kaldi::Rand() % n_syms];  // same input+output vocab.
    a.weight = (Weight) (0.33*(kaldi::Rand() % 2));
    StateId start_state = all_states[kaldi::Rand() % n_states];
    fst->AddArc(start_state, a);
  }

  std::cout <<" printing before trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }
  // Trim resulting FST.
  Connect(fst);

  std::cout <<" printing after trimming\n";
  {
    FstPrinter<Arc> fstprinter(*fst, sptr, sptr, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  VectorFst<Arc> *fst_copy_orig = new VectorFst<Arc>(*fst);

  VectorFst<Arc> *fst_det = new VectorFst<Arc>;

  vector<Label> extra_syms;
  if (fst->Start() != kNoStateId) {  // "Connect" did not make it empty....
    if (kaldi::Rand() % 2 == 0)
      SafeDeterminizeWrapper(fst_copy_orig, fst_det);
    else {
      if (kaldi::Rand() % 2 == 0)
        SafeDeterminizeMinimizeWrapper(fst_copy_orig, fst_det);
      else
        SafeDeterminizeMinimizeWrapperInLog(fst_copy_orig, fst_det);
    }

    // no because does shortest-dist on weights even if not pushing on them.
    // PushInLog<REWEIGHT_TO_INITIAL>(fst_det, kPushLabels);  // will always succeed.
    KALDI_LOG << "Num states [orig]: " << fst->NumStates() << "[det]" << fst_det->NumStates();
    assert(RandEquivalent(*fst, *fst_det, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/));
  }
  delete fst;
  delete fst_copy_orig;
  delete fst_det;
  delete sptr;
}

TestScalePair()

void fst::TestScalePair

(

bool

invert

)

Definition at line 234 of file lattice-utils-test.cc.

References DefaultLatticeScale(), rnnlm::i, kaldi::Rand(), and ScaleLattice().

                                                                  {
  std::vector<std::vector<double> > scale1 = DefaultLatticeScale(),
      scale2 = DefaultLatticeScale();
  // important that all these numbers exactly representable as floats..
  // exact floating-point comparisons are used in LatticeWeight, and
  // this exactness is being tested here.. this test will fail for
  // other types of number.
  if (kaldi::Rand() % 4 == 0) {
    scale1[0][0] = 2.0;
    scale2[0][0] = 0.5;
    scale1[1][1] = 4.0;
    scale2[1][1] = 0.25;
  } else if (kaldi::Rand() % 3 == 0) {
    // use that [1 0.25; 0 1] [ 1 -0.25; 0 1] is the unit matrix.
    scale1[0][1] = 0.25;
    scale2[0][1] = -0.25;
  } else if (kaldi::Rand() % 2 == 0) {
    scale1[1][0] = 0.25;
    scale2[1][0] = -0.25;
  }


  typedef ArcTpl<Weight> Arc;
  typedef ArcTpl<CompactLatticeWeightTpl<Weight, Int> > CompactArc;
  for(int i = 0; i < 2; i++) {
    VectorFst<Arc> *fst = RandPairFst<Arc>();
    /*std::cout << "FST before converting to compact-arc is:\n";
    {
      FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true);
      fstprinter.Print(&std::cout, "standard output");
      }*/
    VectorFst<CompactArc> ofst;
    ConvertLattice<Weight, Int>(*fst, &ofst, invert);
    ScaleLattice(scale1, &ofst);
    /*std::cout << "FST after converting and scaling is:\n";
    {
      FstPrinter<CompactArc> fstprinter(ofst, NULL, NULL, NULL, false, true);
      fstprinter.Print(&std::cout, "standard output");
      }*/
    VectorFst<Arc> origfst;
    ConvertLattice<Weight, Int>(ofst, &origfst, invert);
    ScaleLattice(scale2, &origfst);
    /*std::cout << "FST after back conversion and scaling is:\n";
    {
      FstPrinter<Arc> fstprinter(origfst, NULL, NULL, NULL, false, true);
      fstprinter.Print(&std::cout, "standard output");
      }*/
    // If RandEquivalent doesn't work, it could be due to a nasty issue related to the use
    // of exact floating-point comparisons in the Plus function of LatticeWeight.
    if (!RandEquivalent(*fst, origfst, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/)) {
      std::cerr << "Warn, randequivalent returned false.  Checking equivalence another way.\n";
      assert(Equal(*fst, origfst));
    }
    delete fst;
  }
}

TestShortestPath()

void fst::TestShortestPath

(

)

Definition at line 60 of file lattice-utils-test.cc.

References ApproxEqual(), and rnnlm::i.

                                                          {
  for (int p = 0; p < 10; p++) {
    typedef ArcTpl<Weight> Arc;
    typedef ArcTpl<CompactLatticeWeightTpl<Weight, Int> > CompactArc;
    for(int i = 0; i < 5; i++) {
      VectorFst<Arc> *fst = RandPairFst<Arc>();
      std::cout << "Testing shortest path\n";
      std::cout << "FST before converting to compact-arc is:\n";
      {
        FstPrinter<Arc> fstprinter(*fst, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }
      VectorFst<CompactArc> cfst;
      ConvertLattice<Weight, Int>(*fst, &cfst, false); // invert == false


      {
        VectorFst<Arc> nbest_fst_1;
        ShortestPath(*fst, &nbest_fst_1, 1);
        VectorFst<Arc> nbest_fst_2;
        ShortestPath(*fst, &nbest_fst_2, 3);
        VectorFst<Arc> nbest_fst_1b;
        ShortestPath(nbest_fst_2, &nbest_fst_1b, 1);


        assert(ApproxEqual(ShortestDistance(nbest_fst_1),
                           ShortestDistance(nbest_fst_1b)));

        // since semiring is idempotent, this should succeed too.
        assert(ApproxEqual(ShortestDistance(*fst),
                           ShortestDistance(nbest_fst_1b)));
      }
      {
        VectorFst<CompactArc> nbest_fst_1;
        ShortestPath(cfst, &nbest_fst_1, 1);
        VectorFst<CompactArc> nbest_fst_2;
        ShortestPath(cfst, &nbest_fst_2, 3);
        VectorFst<CompactArc> nbest_fst_1b;
        ShortestPath(nbest_fst_2, &nbest_fst_1b, 1);

        assert(ApproxEqual(ShortestDistance(nbest_fst_1),
                           ShortestDistance(nbest_fst_1b)));
        // since semiring is idempotent, this should succeed too.
        assert(ApproxEqual(ShortestDistance(cfst),
                           ShortestDistance(nbest_fst_1b)));
      }

      delete fst;
    }
  }
}

TestStringRepository()

void TestStringRepository

(

)

Definition at line 447 of file determinize-star-test.cc.

References rnnlm::i, StringRepository< Label, StringId >::IdOfEmpty(), StringRepository< Label, StringId >::IdOfLabel(), StringRepository< Label, StringId >::IdOfSeq(), rnnlm::j, kaldi::Rand(), StringRepository< Label, StringId >::RemovePrefix(), and StringRepository< Label, StringId >::SeqOfId().

Referenced by TestFactor().

                                                               {
  typedef typename Arc::Label Label;

  StringRepository<Label, inttype> sr;

  int N = 100;
  if (sizeof(inttype) == 1) N = 64;
  std::vector<std::vector<Label> > strings(N);
  std::vector<inttype> ids(N);

  for (int i = 0;i < N;i++) {
    size_t len = kaldi::Rand() % 4;
    std::vector<Label> vec;
    for (size_t j = 0;j < len;j++) vec.push_back( (kaldi::Rand()%10) + 150*(kaldi::Rand()%2));  // make it have reasonable range.
    if (i < 500 && vec.size() == 0) ids[i] = sr.IdOfEmpty();
    else if (i < 500 && vec.size() == 1) ids[i] = sr.IdOfLabel(vec[0]);
    else ids[i] = sr.IdOfSeq(vec);

    strings[i] = vec;
  }

  for (int i = 0;i < N;i++) {
    std::vector<Label> tmpv;
    tmpv.push_back(10);  // just put in garbage.
    sr.SeqOfId(ids[i], &tmpv);
    assert(tmpv == strings[i]);
    assert(sr.IdOfSeq(strings[i]) == ids[i]);
    if (strings[i].size() == 0) assert(ids[i] == sr.IdOfEmpty());
    if (strings[i].size() == 1) assert(ids[i] == sr.IdOfLabel(strings[i][0]));

    if (sizeof(inttype) != 1) {
      size_t prefix_len = kaldi::Rand() % (strings[i].size() + 1);
      inttype s2 = sr.RemovePrefix(ids[i], prefix_len);
      std::vector<Label> vec2;
      sr.SeqOfId(s2, &vec2);
      for (size_t j = 0;j < strings[i].size()-prefix_len;j++) {
        assert(vec2[j] == strings[i][j+prefix_len]);
      }
    }

  }
}

TestTableMatcher()

void fst::TestTableMatcher	(	bool	connect,
		bool	left
	)

Definition at line 28 of file table-matcher-test.cc.

References TableComposeOptions::connect, TableMatcherOptions::min_table_size, kaldi::Rand(), TableComposeOptions::table_match_type, TableMatcherOptions::table_ratio, and TableCompose().

                                                                    {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;


  VectorFst<Arc> *fst1 = RandFst<Arc>();

  VectorFst<Arc> *fst2 = RandFst<Arc>();

  ILabelCompare<Arc> ilabel_comp;
  OLabelCompare<Arc> olabel_comp;

  TableComposeOptions opts;
  if (left) opts.table_match_type = MATCH_OUTPUT;
  else opts.table_match_type = MATCH_INPUT;
  opts.min_table_size = 1 + kaldi::Rand() % 5;
  opts.table_ratio = 0.25 * (kaldi::Rand() % 5);
  opts.connect = connect;

  ArcSort(fst1, olabel_comp);
  ArcSort(fst2, ilabel_comp);

  VectorFst<Arc> composed;

  TableCompose(*fst1, *fst2, &composed, opts);

  if (!connect) Connect(&composed);

  VectorFst<Arc> composed_baseline;

  Compose(*fst1, *fst2, &composed_baseline);


  std::cout << "Connect = "<< (connect?"True\n":"False\n");

  std::cout <<"Table-Composed FST\n";
  {
    FstPrinter<Arc> fstprinter(composed, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  std::cout <<" Baseline-Composed FST\n";
  {
    FstPrinter<Arc> fstprinter(composed_baseline, NULL, NULL, NULL, false, true, "\t");
    fstprinter.Print(&std::cout, "standard output");
  }

  if ( !RandEquivalent(composed, composed_baseline, 3/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 20/*path length-- max?*/)) {
    VectorFst<Arc> diff1;
    Difference(composed, composed_baseline, &diff1);
    std::cout <<" Diff1 (composed - baseline) \n";
    {
      FstPrinter<Arc> fstprinter(diff1, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }


    VectorFst<Arc> diff2;
    Difference(composed_baseline, composed, &diff2);
    std::cout <<" Diff2 (baseline - composed) \n";
    {
      FstPrinter<Arc> fstprinter(diff2, NULL, NULL, NULL, false, true, "\t");
      fstprinter.Print(&std::cout, "standard output");
    }

    assert(0);
  }

  delete fst1;
  delete fst2;
}

TestTableMatcherCacheLeft()

void fst::TestTableMatcherCacheLeft

(

bool

connect

)

Definition at line 104 of file table-matcher-test.cc.

References rnnlm::i, kaldi::Rand(), TableComposeOptions::table_match_type, and TableCompose().

                                                                  {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;


  VectorFst<Arc> *fst1 = RandFst<Arc>();


  TableComposeOptions opts;
  opts.table_match_type = MATCH_OUTPUT;
  opts.min_table_size = 1 + kaldi::Rand() % 5;
  opts.table_ratio = 0.25 * (kaldi::Rand() % 5);
  opts.connect = connect;

  TableComposeCache<Fst<Arc> > cache(opts);

  for (size_t i = 0; i < 3; i++) {

    VectorFst<Arc> *fst2 = RandFst<Arc>();

    ILabelCompare<Arc> ilabel_comp;
    OLabelCompare<Arc> olabel_comp;


    ArcSort(fst1, olabel_comp);
    ArcSort(fst2, ilabel_comp);

    VectorFst<Arc> composed;

    TableCompose(*fst1, *fst2, &composed, &cache);

    if (!connect) Connect(&composed);

    VectorFst<Arc> composed_baseline;

    Compose(*fst1, *fst2, &composed_baseline);


    std::cout << "Connect = "<< (connect?"True\n":"False\n");


    if ( !RandEquivalent(composed, composed_baseline, 3/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 100/*path length-- max?*/)) {
      VectorFst<Arc> diff1;
      Difference(composed, composed_baseline, &diff1);
      std::cout <<" Diff1 (composed - baseline) \n";
      {
        FstPrinter<Arc> fstprinter(diff1, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }


      VectorFst<Arc> diff2;
      Difference(composed_baseline, composed, &diff2);
      std::cout <<" Diff2 (baseline - composed) \n";
      {
        FstPrinter<Arc> fstprinter(diff2, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }

      assert(0);
    }
    delete fst2;
  }

  delete fst1;
}

TestTableMatcherCacheRight()

void fst::TestTableMatcherCacheRight

(

bool

connect

)

Definition at line 173 of file table-matcher-test.cc.

References TableComposeOptions::connect, rnnlm::i, TableMatcherOptions::min_table_size, kaldi::Rand(), TableComposeOptions::table_match_type, TableMatcherOptions::table_ratio, and TableCompose().

                                                                   {
  typedef typename Arc::Label Label;
  typedef typename Arc::StateId StateId;
  typedef typename Arc::Weight Weight;


  VectorFst<Arc> *fst2 = RandFst<Arc>();
  ILabelCompare<Arc> ilabel_comp;
  ArcSort(fst2, ilabel_comp);


  TableComposeOptions opts;
  opts.table_match_type = MATCH_INPUT;
  opts.min_table_size = 1 + kaldi::Rand() % 5;
  opts.table_ratio = 0.25 * (kaldi::Rand() % 5);
  opts.connect = connect;

  TableComposeCache<Fst<Arc> > cache(opts);

  for (size_t i = 0; i < 2; i++) {

    VectorFst<Arc> *fst1 = RandFst<Arc>();


    OLabelCompare<Arc> olabel_comp;


    ArcSort(fst1, olabel_comp);

    VectorFst<Arc> composed;

    TableCompose(*fst1, *fst2, &composed, &cache);

    if (!connect) Connect(&composed);

    VectorFst<Arc> composed_baseline;

    Compose(*fst1, *fst2, &composed_baseline);


    std::cout << "Connect = "<< (connect?"True\n":"False\n");


    if ( !RandEquivalent(composed, composed_baseline, 5/*paths*/, 0.01/*delta*/, kaldi::Rand()/*seed*/, 20/*path length-- max?*/)) {
      VectorFst<Arc> diff1;
      Difference(composed, composed_baseline, &diff1);
      std::cout <<" Diff1 (composed - baseline) \n";
      {
        FstPrinter<Arc> fstprinter(diff1, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }


      VectorFst<Arc> diff2;
      Difference(composed_baseline, composed, &diff2);
      std::cout <<" Diff2 (baseline - composed) \n";
      {
        FstPrinter<Arc> fstprinter(diff2, NULL, NULL, NULL, false, true, "\t");
        fstprinter.Print(&std::cout, "standard output");
      }

      assert(0);
    }
    delete fst1;
  }

  delete fst2;
}

Times() [1/5]

ArcticWeightTpl<T> fst::Times ( const ArcticWeightTpl< T > &  w1, const ArcticWeightTpl< T > &  w2  )

inline

Definition at line 103 of file arctic-weight.h.

                                                                {
  T f1 = w1.Value(), f2 = w2.Value();
  if (f1 == -std::numeric_limits<T>::infinity())
    return w1;
  else if (f2 == -std::numeric_limits<T>::infinity())
    return w2;
  else
    return ArcticWeightTpl<T>(f1 + f2);
}

Times() [2/5]

ArcticWeightTpl<float> fst::Times ( const ArcticWeightTpl< float > &  w1, const ArcticWeightTpl< float > &  w2  )

inline

Definition at line 114 of file arctic-weight.h.

                                                                        {
  return Times<float>(w1, w2);
}

Times() [3/5]

ArcticWeightTpl<double> fst::Times ( const ArcticWeightTpl< double > &  w1, const ArcticWeightTpl< double > &  w2  )

inline

Definition at line 119 of file arctic-weight.h.

                                                                          {
  return Times<double>(w1, w2);
}

Times() [4/5]

LatticeWeightTpl<FloatType> fst::Times ( const LatticeWeightTpl< FloatType > &  w1, const LatticeWeightTpl< FloatType > &  w2  )

inline

Definition at line 362 of file lattice-weight.h.

References LatticeWeightTpl< FloatType >::Value1(), and LatticeWeightTpl< FloatType >::Value2().

Referenced by kaldi::AddSelfLoopsNoReorder(), kaldi::AddSelfLoopsReorder(), kaldi::AddTransitionProbs(), LatticeWordAligner::ComputationState::Advance(), LatticePhoneAligner::ComputationState::Advance(), LatticeLexiconWordAligner::ComputationState::Advance(), RemoveEpsLocalClass< Arc, ReweightPlus >::CanCombineArcs(), RemoveEpsLocalClass< Arc, ReweightPlus >::CanCombineFinal(), CompactLatticeWeightTest(), ComposeDeterministicOnDemand(), ComposeDeterministicOnDemandInverse(), ConvertLatticeWeight(), PruneSpecialClass< Arc >::Done(), LatticeDeterminizerPruned< Weight, IntType >::EpsilonClosure(), LatticeDeterminizer< Weight, IntType >::EpsilonClosure(), DeterminizerStar< F >::EpsilonClosure::ExpandOneElement(), Factor(), BackoffDeterministicOnDemandFst< Arc >::Final(), ComposeDeterministicOnDemandFst< Arc >::Final(), GrammarFstPreparer::FixArcsToFinalStates(), kaldi::GenerateActivePaths(), BackoffDeterministicOnDemandFst< Arc >::GetArc(), ComposeDeterministicOnDemandFst< Arc >::GetArc(), BiglmFasterDecoder::GetBestPath(), GetLinearSymbolSequence(), LatticeWeightTest(), main(), PushSpecialClass::ModifyFst(), PenalizeArcsWithSomeInputSymbols(), PrintProxyFstPath(), LatticeIncrementalDeterminizer::ProcessArcsFromChunkStartState(), LatticeBiglmFasterDecoder::ProcessEmitting(), DeterminizerStar< F >::ProcessFinal(), LatticeDeterminizerPruned< Weight, IntType >::ProcessFinal(), LatticeDeterminizer< Weight, IntType >::ProcessFinal(), PruneSpecialClass< Arc >::ProcessState(), PrunedCompactLatticeComposer::ProcessTransition(), LatticeDeterminizerPruned< Weight, IntType >::ProcessTransition(), LatticeDeterminizer< Weight, IntType >::ProcessTransition(), DeterminizerStar< F >::ProcessTransitions(), LatticeDeterminizerPruned< Weight, IntType >::ProcessTransitions(), LatticeDeterminizer< Weight, IntType >::ProcessTransitions(), PropagateFinalInternal(), BiglmFasterDecoder::PropagateLm(), LatticeBiglmFasterDecoder::PropagateLm(), PushCompactLatticeWeights(), BiglmFasterDecoder::ReachedFinal(), RemoveEpsLocalClass< Arc, ReweightPlus >::Reweight(), LatticeIncrementalDeterminizer::SetFinalCosts(), Times(), BiglmFasterDecoder::Token::Token(), LatticeIncrementalDeterminizer::TransferArcsToClat(), and WalkSinglePath().

                                                                                {
  return LatticeWeightTpl<FloatType>(w1.Value1()+w2.Value1(), w1.Value2()+w2.Value2());
}

Times() [5/5]

CompactLatticeWeightTpl<WeightType, IntType> fst::Times ( const CompactLatticeWeightTpl< WeightType, IntType > &  w1, const CompactLatticeWeightTpl< WeightType, IntType > &  w2  )

inline

Definition at line 671 of file lattice-weight.h.

References CompactLatticeWeightTpl< WeightType, IntType >::String(), Times(), CompactLatticeWeightTpl< WeightType, IntType >::Weight(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

                                                            {
  WeightType w = Times(w1.Weight(), w2.Weight());
  if (w == WeightType::Zero()) {
    return CompactLatticeWeightTpl<WeightType, IntType>::Zero();
    // special case to ensure zero is unique
  } else {
    std::vector<IntType> v;
    v.resize(w1.String().size() + w2.String().size());
    typename std::vector<IntType>::iterator iter = v.begin();
    iter = std::copy(w1.String().begin(), w1.String().end(), iter); // returns end of first range.
    std::copy(w2.String().begin(), w2.String().end(), iter);
    return CompactLatticeWeightTpl<WeightType, IntType>(w, v);
  }
}

WalkSinglePath()

Weight fst::WalkSinglePath	(	StdVectorFst *	ifst,
		DeterministicOnDemandFst< StdArc > *	dfst
	)

Definition at line 120 of file deterministic-fst-test.cc.

References DeterministicOnDemandFst< Arc >::Final(), DeterministicOnDemandFst< Arc >::GetArc(), KALDI_LOG, DeterministicOnDemandFst< Arc >::Start(), and Times().

Referenced by TestCompose().

                                                                                  {
  StdArc oarc; // =  new StdArc();
  StateId isrc=ifst->Start();
  StateId dsrc=dfst->Start();
  Weight totalCost = Weight::One();

  while (ifst->Final(isrc) == Weight::Zero()) { // while not final
    fst::ArcIterator<StdVectorFst> aiter(*ifst, isrc);
    const StdArc &iarc = aiter.Value();
    if (dfst->GetArc(dsrc, iarc.olabel, &oarc)) {
      Weight cost = Times(iarc.weight, oarc.weight);
      // cout << "  Matched label "<<iarc.olabel<<" at summed cost "<<cost<<endl;
      totalCost = Times(totalCost, cost);
    } else {
      cout << "  Can't match arc ["<<iarc.ilabel<<","<<iarc.olabel<<","<<iarc.weight<<"] from "<<isrc<<endl;
      exit(1);
    }
    isrc = iarc.nextstate;
    KALDI_LOG << "Setting dsrc = " << oarc.nextstate;
    dsrc = oarc.nextstate;
  }
  totalCost = Times(totalCost, dfst->Final(dsrc));

  cout << "  Total cost: " << totalCost << endl;
  return totalCost;
}

WriteFstKaldi() [1/2]

void WriteFstKaldi	(	std::ostream &	os,
		bool	binary,
		const VectorFst< Arc > &	t
	)

Definition at line 31 of file kaldi-fst-io-inl.h.

References KALDI_ERR.

Referenced by main(), and VectorFstTplHolder< Arc >::Write().

                                            {
  bool ok;
  if (binary) {
    // Binary-mode writing.
    ok = t.Write(os, FstWriteOptions());
  } else {
    // Text-mode output.  Note: we expect that t.InputSymbols() and
    // t.OutputSymbols() would always return NULL.  The corresponding input
    // routine would not work if the FST actually had symbols attached.  Write a
    // newline to start the FST; in a table, the first line of the FST will
    // appear on its own line.
    os << '\n';
    bool acceptor = false, write_one = false;
    FstPrinter<Arc> printer(t, t.InputSymbols(), t.OutputSymbols(),
                            NULL, acceptor, write_one, "\t");
    printer.Print(&os, "<unknown>");
    if (os.fail())
      KALDI_ERR << "Stream failure detected writing FST to stream";
    // Write another newline as a terminating character.  The read routine will
    // detect this [this is a Kaldi mechanism, not something in the original
    // OpenFst code].
    os << '\n';
    ok = os.good();
  }
  if (!ok) {
    KALDI_ERR << "Error writing FST to stream";
  }
}

WriteFstKaldi() [2/2]

void WriteFstKaldi	(	const VectorFst< StdArc > &	fst,
		std::string	wxfilename
	)

Definition at line 115 of file kaldi-fst-io.cc.

References kaldi::PrintableWxfilename(), and Output::Stream().

                                         {
  if (wxfilename == "") wxfilename = "-"; // interpret "" as stdout,
  // for compatibility with OpenFst conventions.
  bool write_binary = true, write_header = false;
  kaldi::Output ko(wxfilename, write_binary, write_header);
  FstWriteOptions wopts(kaldi::PrintableWxfilename(wxfilename));
  fst.Write(ko.Stream(), wopts);
}

WriteILabelInfo() [1/2]

void fst::WriteILabelInfo	(	std::ostream &	os,
		bool	binary,
		const std::vector< std::vector< int32 > > &	ilabel_info
	)

Utility function for writing ilabel-info vectors to disk.

Definition at line 325 of file context-fst.cc.

References rnnlm::i, kaldi::WriteBasicType(), and kaldi::WriteIntegerVector().

Referenced by main(), and TestContextFst().

                                                         {
  int32 size = info.size();
  kaldi::WriteBasicType(os, binary, size);
  for (int32 i = 0; i < size; i++) {
    kaldi::WriteIntegerVector(os, binary, info[i]);
  }
}

WriteILabelInfo() [2/2]

void fst::WriteILabelInfo	(	std::ostream &	os,
		bool	binary,
		const vector< vector< int32 > > &	info
	)

Utility function for writing ilabel-info vectors to disk.

Definition at line 325 of file context-fst.cc.

References rnnlm::i, kaldi::WriteBasicType(), and kaldi::WriteIntegerVector().

Referenced by main(), and TestContextFst().

                                                         {
  int32 size = info.size();
  kaldi::WriteBasicType(os, binary, size);
  for (int32 i = 0; i < size; i++) {
    kaldi::WriteIntegerVector(os, binary, info[i]);
  }
}