kaldi Namespace Reference

This code computes Goodness of Pronunciation (GOP) and extracts phone-level pronunciation feature for mispronunciations detection tasks, the reference: More...

Namespaces
	cu
	decoder
	differentiable_transform
	discriminative
	internal
	kws_internal
	nnet1
	nnet2
	nnet3
	sparse_vector_utils
	unittest

Classes
class	AccumAmDiagGmm
class	AccumDiagGmm
class	AccumFullGmm
	Class for computing the maximum-likelihood estimates of the parameters of a Gaussian mixture model. More...
class	AccumulateMultiThreadedClass
struct	AccumulateTreeStatsInfo
struct	AccumulateTreeStatsOptions
struct	ActivePath
class	AffineXformStats
class	AgglomerativeClusterer
	The AgglomerativeClusterer class contains the necessary mechanisms for the actual clustering algorithm. More...
struct	AhcCluster
	AhcCluster is the cluster object for the agglomerative clustering. More...
struct	AlignConfig
struct	AlignedTermsPair
class	AmDiagGmm
class	AmSgmm2
	Class for definition of the subspace Gmm acoustic model. More...
class	ArbitraryResample
	Class ArbitraryResample allows you to resample a signal (assumed zero outside the sample region, not periodic) at arbitrary specified time values, which don't have to be linearly spaced. More...
class	ArcPosteriorComputer
class	ArpaFileParser
	ArpaFileParser is an abstract base class for ARPA LM file conversion. More...
struct	ArpaLine
class	ArpaLmCompiler
class	ArpaLmCompilerImpl
class	ArpaLmCompilerImplInterface
struct	ArpaParseOptions
	Options that control ArpaFileParser. More...
class	basic_filebuf
class	basic_pipebuf
class	BasicHolder
	BasicHolder is valid for float, double, bool, and integer types. More...
class	BasicPairVectorHolder
	BasicPairVectorHolder is a Holder for a vector of pairs of a basic type, e.g. More...
class	BasicVectorHolder
	A Holder for a vector of basic types, e.g. More...
class	BasicVectorVectorHolder
	BasicVectorVectorHolder is a Holder for a vector of vector of a basic type, e.g. More...
class	BasisFmllrAccus
	Stats for fMLLR subspace estimation. More...
class	BasisFmllrEstimate
	Estimation functions for basis fMLLR. More...
struct	BasisFmllrOptions
class	BiglmFasterDecoder
	This is as FasterDecoder, but does online composition between HCLG and the "difference language model", which is a deterministic FST that represents the difference between the language model you want and the language model you compiled HCLG with. More...
struct	BiglmFasterDecoderOptions
class	BottomUpClusterer
struct	ClatRescoreTuple
class	Clusterable
struct	ClusterKMeansOptions
class	CompactLatticeHolder
class	CompactLatticeToKwsProductFstMapper
struct	CompareFirstMemberOfPair
	Comparator object for pairs that compares only the first pair. More...
struct	ComparePosteriorByPdfs
struct	CompareReverseSecond
class	CompartmentalizedBottomUpClusterer
struct	CompBotClustElem
struct	ComposeLatticePrunedOptions
class	CompressedAffineXformStats
class	CompressedMatrix
class	ComputeNormalizersClass
class	ConfigLine
	This class is responsible for parsing input like hi-there xx=yyy a=b c empty= f-oo=Append(bar, sss) ba_z=123 bing='a b c' baz="a b c d='a b' e" and giving you access to the fields, in this case. More...
class	ConstantEventMap
class	ConstArpaLm
class	ConstArpaLmBuilder
class	ConstArpaLmDeterministicFst
	This class wraps a ConstArpaLm format language model with the interface defined in DeterministicOnDemandFst. More...
class	ConstIntegerSet
class	ContextDependency
class	ContextDependencyInterface
	context-dep-itf.h provides a link between the tree-building code in ../tree/, and the FST code in ../fstext/ (particularly, ../fstext/context-dep.h). More...
struct	CountStats
class	CovarianceStats
struct	CuAllocatorOptions
class	CuArray
	Class CuArray represents a vector of an integer or struct of type T. More...
class	CuArrayBase
	Class CuArrayBase, CuSubArray and CuArray are analogues of classes CuVectorBase, CuSubVector and CuVector, except that they are intended to store things other than float/double: they are intended to store integers or small structs. More...
class	CuBlockMatrix
	The class CuBlockMatrix holds a vector of objects of type CuMatrix, say, M_1, M_2, . More...
class	CuCompressedMatrix
	Class CuCompressedMatrix, templated on an integer type (expected to be one of: int8, uint8, int16, uint16), this provides a way to approximate a CuMatrix in a more memory-efficient format. More...
class	CuCompressedMatrixBase
	Class CuCompressedMatrixBase is an abstract base class that allows you to compress a matrix of type CuMatrix<BaseFloat>. More...
class	CuMatrix
	This class represents a matrix that's stored on the GPU if we have one, and in memory if not. More...
class	CuMatrixBase
	Matrix for CUDA computing. More...
class	CuPackedMatrix
	Matrix for CUDA computing. More...
class	CuRand
class	CuSparseMatrix
class	CuSpMatrix
class	CuSubArray
class	CuSubMatrix
	This class is used for a piece of a CuMatrix. More...
class	CuSubVector
class	CuTpMatrix
class	CuValue
	The following class is used to simulate non-const references to Real, e.g. More...
class	CuVector
class	CuVectorBase
	Vector for CUDA computing. More...
class	DecisionTreeSplitter
class	DecodableAmDiagGmm
class	DecodableAmDiagGmmRegtreeFmllr
class	DecodableAmDiagGmmRegtreeMllr
class	DecodableAmDiagGmmScaled
class	DecodableAmDiagGmmUnmapped
	DecodableAmDiagGmmUnmapped is a decodable object that takes indices that correspond to pdf-id's plus one. More...
class	DecodableAmSgmm2
class	DecodableAmSgmm2Scaled
class	DecodableDiagGmmScaledOnline
class	DecodableInterface
	DecodableInterface provides a link between the (acoustic-modeling and feature-processing) code and the decoder. More...
class	DecodableMapped
class	DecodableMatrixMapped
	This is like DecodableMatrixScaledMapped, but it doesn't support an acoustic scale, and it does support a frame offset, whereby you can state that the first row of 'likes' is actually the n'th row of the matrix of available log-likelihoods. More...
class	DecodableMatrixMappedOffset
	This decodable class returns log-likes stored in a matrix; it supports repeatedly writing to the matrix and setting a time-offset representing the frame-index of the first row of the matrix. More...
class	DecodableMatrixScaled
class	DecodableMatrixScaledMapped
class	DecodableSum
class	DecodableSumScaled
class	DecodeUtteranceLatticeFasterClass
	This class basically does the same job as the function DecodeUtteranceLatticeFaster, but in a way that allows us to build a multi-threaded command line program more easily. More...
class	DeltaFeatures
struct	DeltaFeaturesOptions
class	DeterminizeLatticeTask
class	DiagGmm
	Definition for Gaussian Mixture Model with diagonal covariances. More...
class	DiagGmmNormal
	Definition for Gaussian Mixture Model with diagonal covariances in normal mode: where the parameters are stored as means and variances (instead of the exponential form that the DiagGmm class is stored as). More...
struct	DummyOptions
struct	EbwAmSgmm2Options
	This header implements a form of Extended Baum-Welch training for SGMMs. More...
class	EbwAmSgmm2Updater
struct	EbwOptions
class	EbwUpdatePhoneVectorsClass
struct	EbwWeightOptions
class	EigenvalueDecomposition
struct	error_stats
class	EventMap
	A class that is capable of representing a generic mapping from EventType (which is a vector of (key, value) pairs) to EventAnswerType which is just an integer. More...
struct	EventMapVectorEqual
struct	EventMapVectorHash
class	ExampleClass
class	ExampleFeatureComputer
	This class is only added for documentation, it is not intended to ever be used. More...
struct	ExampleFeatureComputerOptions
	This class is only added for documentation, it is not intended to ever be used. More...
class	FasterDecoder
struct	FasterDecoderOptions
class	FbankComputer
	Class for computing mel-filterbank features; see Computing MFCC features for more information. More...
struct	FbankOptions
	FbankOptions contains basic options for computing filterbank features. More...
class	FeatureTransformEstimate
	Class for computing a feature transform used for preconditioning of the training data in neural-networks. More...
class	FeatureTransformEstimateMulti
struct	FeatureTransformEstimateOptions
struct	FeatureWindowFunction
class	FileInputImpl
class	FileOutputImpl
class	FmllrDiagGmmAccs
	This does not work with multiple feature transforms. More...
struct	FmllrOptions
class	FmllrRawAccs
struct	FmllrRawOptions
class	FmllrSgmm2Accs
	Class for computing the accumulators needed for the maximum-likelihood estimate of FMLLR transforms for a subspace GMM acoustic model. More...
class	Fmpe
struct	FmpeOptions
struct	FmpeStats
struct	FmpeUpdateOptions
struct	FrameExtractionOptions
class	FullGmm
	Definition for Gaussian Mixture Model with full covariances. More...
class	FullGmmNormal
	Definition for Gaussian Mixture Model with full covariances in normal mode: where the parameters are stored as means and variances (instead of the exponential form that the FullGmm class is stored as). More...
class	GaussClusterable
	GaussClusterable wraps Gaussian statistics in a form accessible to generic clustering algorithms. More...
struct	GaussInfo
class	GaussPostHolder
class	GeneralMatrix
	This class is a wrapper that enables you to store a matrix in one of three forms: either as a Matrix<BaseFloat>, or a CompressedMatrix, or a SparseMatrix<BaseFloat>. More...
class	GenericHolder
	GenericHolder serves to document the requirements of the Holder interface; it's not intended to be used. More...
class	HashList
struct	HmmCacheHash
class	HmmTopology
	A class for storing topology information for phones. More...
struct	HtkHeader
	A structure containing the HTK header. More...
class	HtkMatrixHolder
struct	HTransducerConfig
	Configuration class for the GetHTransducer() function; see The HTransducerConfig configuration class for context. More...
class	Input
class	InputImplBase
union	Int32AndFloat
struct	Int32IsZero
class	Interval
struct	IvectorEstimationOptions
class	IvectorExtractor
class	IvectorExtractorComputeDerivedVarsClass
struct	IvectorExtractorEstimationOptions
	Options for training the IvectorExtractor, e.g. variance flooring. More...
struct	IvectorExtractorOptions
class	IvectorExtractorStats
	IvectorExtractorStats is a class used to update the parameters of the ivector extractor. More...
struct	IvectorExtractorStatsOptions
	Options for IvectorExtractorStats, which is used to update the parameters of IvectorExtractor. More...
class	IvectorExtractorUpdateProjectionClass
class	IvectorExtractorUpdateWeightClass
class	IvectorExtractorUtteranceStats
	These are the stats for a particular utterance, i.e. More...
class	IvectorExtractTask
class	IvectorTask
class	KaldiFatalError
	Kaldi fatal runtime error exception. More...
class	KaldiObjectHolder
	KaldiObjectHolder works for Kaldi objects that have the "standard" Read and Write functions, and a copy constructor. More...
class	KaldiRnnlmWrapper
struct	KaldiRnnlmWrapperOpts
class	KwsAlignment
class	KwsProductFstToKwsLexicographicFstMapper
class	KwsTerm
class	KwsTermsAligner
struct	KwsTermsAlignerOptions
struct	LatticeArcRecord
	This is used in CompactLatticeLimitDepth. More...
class	LatticeBiglmFasterDecoder
	This is as LatticeFasterDecoder, but does online composition between HCLG and the "difference language model", which is a deterministic FST that represents the difference between the language model you want and the language model you compiled HCLG with. More...
struct	LatticeFasterDecoderConfig
class	LatticeFasterDecoderTpl
	This is the "normal" lattice-generating decoder. More...
class	LatticeFasterOnlineDecoderTpl
	LatticeFasterOnlineDecoderTpl is as LatticeFasterDecoderTpl but also supports an efficient way to get the best path (see the function BestPathEnd()), which is useful in endpointing and in situations where you might want to frequently access the best path. More...
class	LatticeHolder
struct	LatticeIncrementalDecoderConfig
	The normal decoder, lattice-faster-decoder.h, sometimes has an issue when doing real-time applications with long utterances, that each time you get the lattice the lattice determinization can take a considerable amount of time; this introduces latency. More...
class	LatticeIncrementalDecoderTpl
	This is an extention to the "normal" lattice-generating decoder. More...
class	LatticeIncrementalDeterminizer
	This class is used inside LatticeIncrementalDecoderTpl; it handles some of the details of incremental determinization. More...
class	LatticeIncrementalOnlineDecoderTpl
	LatticeIncrementalOnlineDecoderTpl is as LatticeIncrementalDecoderTpl but also supports an efficient way to get the best path (see the function BestPathEnd()), which is useful in endpointing and in situations where you might want to frequently access the best path. More...
class	LatticeLexiconWordAligner
class	LatticePhoneAligner
class	LatticeReader
	LatticeReader provides (static) functions for reading both Lattice and CompactLattice, in text form. More...
class	LatticeSimpleDecoder
	Simplest possible decoder, included largely for didactic purposes and as a means to debug more highly optimized decoders. More...
struct	LatticeSimpleDecoderConfig
class	LatticeWordAligner
struct	LbfgsOptions
	This is an implementation of L-BFGS. More...
class	LdaEstimate
	Class for computing linear discriminant analysis (LDA) transform. More...
struct	LdaEstimateOptions
struct	LinearCgdOptions
class	LinearResample
	LinearResample is a special case of ArbitraryResample, where we want to resample a signal at linearly spaced intervals (this means we want to upsample or downsample the signal). More...
class	LinearVtln
class	LmState
class	LogisticRegression
struct	LogisticRegressionConfig
struct	LogMessageEnvelope
	Log message severity and source location info. More...
struct	MapDiagGmmOptions
	Configuration variables for Maximum A Posteriori (MAP) update. More...
struct	MapTransitionUpdateConfig
class	Matrix
	A class for storing matrices. More...
class	MatrixBase
	Base class which provides matrix operations not involving resizing or allocation. More...
class	MelBanks
struct	MelBanksOptions
class	MessageLogger
class	MfccComputer
struct	MfccOptions
	MfccOptions contains basic options for computing MFCC features. More...
class	MinimumBayesRisk
	This class does the word-level Minimum Bayes Risk computation, and gives you either the 1-best MBR output together with the expected Bayes Risk, or a sausage-like structure. More...
struct	MinimumBayesRiskOptions
	The implementation of the Minimum Bayes Risk decoding method described in "Minimum Bayes Risk decoding and system combination based on a recursion for edit distance", Haihua Xu, Daniel Povey, Lidia Mangu and Jie Zhu, Computer Speech and Language, 2011 This is a slightly more principled way to do Minimum Bayes Risk (MBR) decoding than the standard "Confusion Network" method. More...
class	MleAmSgmm2Accs
	Class for the accumulators associated with the phonetic-subspace model parameters. More...
struct	MleAmSgmm2Options
	Configuration variables needed in the SGMM estimation process. More...
class	MleAmSgmm2Updater
struct	MleDiagGmmOptions
	Configuration variables like variance floor, minimum occupancy, etc. More...
struct	MleFullGmmOptions
	Configuration variables like variance floor, minimum occupancy, etc. More...
class	MleSgmm2SpeakerAccs
	Class for the accumulators required to update the speaker vectors v_s. More...
struct	MleTransitionUpdateConfig
class	MlltAccs
	A class for estimating Maximum Likelihood Linear Transform, also known as global Semi-tied Covariance (STC), for GMMs. More...
class	MultiThreadable
class	MultiThreader
class	MyTaskClass
class	MyThreadClass
struct	NccfInfo
struct	NGram
	A parsed n-gram from ARPA LM file. More...
class	NumberIstream
class	OfflineFeatureTpl
	This templated class is intended for offline feature extraction, i.e. More...
class	OffsetFileInputImpl
class	OnlineAppendFeature
	This online-feature class implements combination of two feature streams (such as pitch, plp) into one stream. More...
class	OnlineAudioSourceItf
class	OnlineBaseFeature
	Add a virtual class for "source" features such as MFCC or PLP or pitch features. More...
class	OnlineCacheFeature
	This feature type can be used to cache its input, to avoid repetition of computation in a multi-pass decoding context. More...
class	OnlineCacheInput
class	OnlineCmnInput
class	OnlineCmvn
	This class does an online version of the cepstral mean and [optionally] variance, but note that this is not equivalent to the offline version. More...
struct	OnlineCmvnOptions
struct	OnlineCmvnState
	Struct OnlineCmvnState stores the state of CMVN adaptation between utterances (but not the state of the computation within an utterance). More...
class	OnlineDecodableDiagGmmScaled
class	OnlineDeltaFeature
class	OnlineDeltaInput
struct	OnlineEndpointConfig
struct	OnlineEndpointRule
	This header contains a simple facility for endpointing, that should be used in conjunction with the "online2" online decoding code; see ../online2bin/online2-wav-gmm-latgen-faster-endpoint.cc. More...
class	OnlineFasterDecoder
struct	OnlineFasterDecoderOpts
class	OnlineFeatInputItf
class	OnlineFeatureInterface
	OnlineFeatureInterface is an interface for online feature processing (it is also usable in the offline setting, but currently we're not using it for that). More...
class	OnlineFeatureMatrix
struct	OnlineFeatureMatrixOptions
class	OnlineFeaturePipeline
	OnlineFeaturePipeline is a class that's responsible for putting together the various stages of the feature-processing pipeline, in an online setting. More...
struct	OnlineFeaturePipelineCommandLineConfig
	This configuration class is to set up OnlineFeaturePipelineConfig, which in turn is the configuration class for OnlineFeaturePipeline. More...
struct	OnlineFeaturePipelineConfig
	This configuration class is responsible for storing the configuration options for OnlineFeaturePipeline, but it does not set them. More...
class	OnlineFeInput
class	OnlineGenericBaseFeature
	This is a templated class for online feature extraction; it's templated on a class like MfccComputer or PlpComputer that does the basic feature extraction. More...
struct	OnlineGmmAdaptationState
struct	OnlineGmmDecodingAdaptationPolicyConfig
	This configuration class controls when to re-estimate the basis-fMLLR during online decoding. More...
struct	OnlineGmmDecodingConfig
class	OnlineGmmDecodingModels
	This class is used to read, store and give access to the models used for 3 phases of decoding (first-pass with online-CMN features; the ML models used for estimating transforms; and the discriminatively trained models). More...
class	OnlineIvectorEstimationStats
	This class helps us to efficiently estimate iVectors in situations where the data is coming in frame by frame. More...
struct	OnlineIvectorExtractionConfig
	This class includes configuration variables relating to the online iVector extraction, but not including configuration for the "base feature", i.e. More...
struct	OnlineIvectorExtractionInfo
	This struct contains various things that are needed (as const references) by class OnlineIvectorExtractor. More...
struct	OnlineIvectorExtractorAdaptationState
	This class stores the adaptation state from the online iVector extractor, which can help you to initialize the adaptation state for the next utterance of the same speaker in a more informed way. More...
class	OnlineIvectorFeature
	OnlineIvectorFeature is an online feature-extraction class that's responsible for extracting iVectors from raw features such as MFCC, PLP or filterbank. More...
class	OnlineLdaInput
class	OnlineMatrixFeature
	This class takes a Matrix<BaseFloat> and wraps it as an OnlineFeatureInterface: this can be useful where some earlier stage of feature processing has been done offline but you want to use part of the online pipeline. More...
class	OnlineMatrixInput
struct	OnlineNnet2DecodingConfig
struct	OnlineNnet2DecodingThreadedConfig
class	OnlineNnet2FeaturePipeline
	OnlineNnet2FeaturePipeline is a class that's responsible for putting together the various parts of the feature-processing pipeline for neural networks, in an online setting. More...
struct	OnlineNnet2FeaturePipelineConfig
	This configuration class is to set up OnlineNnet2FeaturePipelineInfo, which in turn is the configuration class for OnlineNnet2FeaturePipeline. More...
struct	OnlineNnet2FeaturePipelineInfo
	This class is responsible for storing configuration variables, objects and options for OnlineNnet2FeaturePipeline (including the actual LDA and CMVN-stats matrices, and the iVector extractor, which is a member of ivector_extractor_info. More...
class	OnlinePaSource
class	OnlinePitchFeature
class	OnlinePitchFeatureImpl
class	OnlineProcessPitch
	This online-feature class implements post processing of pitch features. More...
class	OnlineSilenceWeighting
struct	OnlineSilenceWeightingConfig
class	OnlineSpeexDecoder
class	OnlineSpeexEncoder
class	OnlineSpliceFrames
struct	OnlineSpliceOptions
class	OnlineTcpVectorSource
class	OnlineTimer
	class OnlineTimer is used to test real-time decoding algorithms and evaluate how long the decoding of a particular utterance would take. More...
class	OnlineTimingStats
	class OnlineTimingStats stores statistics from timing of online decoding, which will enable the Print() function to print out the average real-time factor and average delay per utterance. More...
class	OnlineTransform
	This online-feature class implements any affine or linear transform. More...
class	OnlineUdpInput
class	OnlineVectorSource
class	OptimizableInterface
	OptimizableInterface provides a virtual class for optimizable objects. More...
class	OptimizeLbfgs
class	OptionsItf
class	OtherReal
	This class provides a way for switching between double and float types. More...
class	OtherReal< double >
	A specialized class for switching from double to float. More...
class	OtherReal< float >
	A specialized class for switching from float to double. More...
class	Output
class	OutputImplBase
class	PackedMatrix
	Packed matrix: base class for triangular and symmetric matrices. More...
struct	PairHasher
	A hashing function-object for pairs of ints. More...
class	ParseOptions
	The class ParseOptions is for parsing command-line options; see Parsing command-line options for more documentation. More...
struct	PhoneAlignLatticeOptions
class	PipeInputImpl
class	PipeOutputImpl
struct	PitchExtractionOptions
class	PitchFrameInfo
class	PitchInterpolator
struct	PitchInterpolatorOptions
struct	PitchInterpolatorStats
class	Plda
struct	PldaConfig
struct	PldaEstimationConfig
class	PldaEstimator
class	PldaStats
class	PldaUnsupervisedAdaptor
	This class takes unlabeled iVectors from the domain of interest and uses their mean and variance to adapt your PLDA matrices to a new domain. More...
struct	PldaUnsupervisedAdaptorConfig
class	PlpComputer
	This is the new-style interface to the PLP computation. More...
struct	PlpOptions
	PlpOptions contains basic options for computing PLP features. More...
class	PosteriorHolder
struct	ProcessPitchOptions
class	Profiler
class	ProfileStats
class	PrunedCompactLatticeComposer
	PrunedCompactLatticeComposer implements an algorithm for pruned composition. More...
class	Questions
	This class defines, for each EventKeyType, a set of initial questions that it tries and also a number of iterations for which to refine the questions to increase likelihood. More...
struct	QuestionsForKey
	QuestionsForKey is a class used to define the questions for a key, and also options that allow us to refine the question during tree-building (i.e. More...
class	RandomAccessTableReader
	Allows random access to a collection of objects in an archive or script file; see The Table concept. More...
class	RandomAccessTableReaderArchiveImplBase
class	RandomAccessTableReaderDSortedArchiveImpl
class	RandomAccessTableReaderImplBase
class	RandomAccessTableReaderMapped
	This class is for when you are reading something in random access, but it may actually be stored per-speaker (or something similar) but the keys you're using are per utterance. More...
class	RandomAccessTableReaderScriptImpl
class	RandomAccessTableReaderSortedArchiveImpl
class	RandomAccessTableReaderUnsortedArchiveImpl
struct	RandomState
struct	RecognizedWord
class	RecyclingVector
	This class serves as a storage for feature vectors with an option to limit the memory usage by removing old elements. More...
class	RefineClusterer
struct	RefineClustersOptions
class	RegressionTree
	A regression tree is a clustering of Gaussian densities in an acoustic model, such that the group of Gaussians at each node of the tree are transformed by the same transform. More...
class	RegtreeFmllrDiagGmm
	An FMLLR (feature-space MLLR) transformation, also called CMLLR (constrained MLLR) is an affine transformation of the feature vectors. More...
class	RegtreeFmllrDiagGmmAccs
	Class for computing the accumulators needed for the maximum-likelihood estimate of FMLLR transforms for an acoustic model that uses diagonal Gaussian mixture models as emission densities. More...
struct	RegtreeFmllrOptions
	Configuration variables for FMLLR transforms. More...
class	RegtreeMllrDiagGmm
	An MLLR mean transformation is an affine transformation of Gaussian means. More...
class	RegtreeMllrDiagGmmAccs
	Class for computing the maximum-likelihood estimates of the parameters of an acoustic model that uses diagonal Gaussian mixture models as emission densities. More...
struct	RegtreeMllrOptions
	Configuration variables for FMLLR transforms. More...
class	RnnlmDeterministicFst
struct	RspecifierOptions
class	ScalarClusterable
	ScalarClusterable clusters scalars with x^2 loss. More...
class	Semaphore
class	SequentialTableReader
	A templated class for reading objects sequentially from an archive or script file; see The Table concept. More...
class	SequentialTableReaderArchiveImpl
class	SequentialTableReaderBackgroundImpl
class	SequentialTableReaderImplBase
class	SequentialTableReaderScriptImpl
struct	Sgmm2FmllrConfig
	Configuration variables needed in the estimation of FMLLR for SGMMs. More...
class	Sgmm2FmllrGlobalParams
	Global adaptation parameters. More...
class	Sgmm2GauPost
	indexed by time. More...
struct	Sgmm2GauPostElement
	This is the entry for a single time. More...
struct	Sgmm2GselectConfig
struct	Sgmm2LikelihoodCache
	Sgmm2LikelihoodCache caches SGMM likelihoods at two levels: the final pdf likelihoods, and the sub-state level likelihoods, which means that with the SCTM system we can avoid redundant computation. More...
struct	Sgmm2PerFrameDerivedVars
	Holds the per-frame precomputed quantities x(t), x_{i}(t), z_{i}(t), and n_{i}(t) (cf. More...
class	Sgmm2PerSpkDerivedVars
class	Sgmm2Project
struct	Sgmm2SplitSubstatesConfig
class	ShiftedDeltaFeatures
struct	ShiftedDeltaFeaturesOptions
class	SimpleDecoder
	Simplest possible decoder, included largely for didactic purposes and as a means to debug more highly optimized decoders. More...
class	SimpleOptions
	The class SimpleOptions is an implementation of OptionsItf that allows setting and getting option values programmatically, i.e., via getter and setter methods. More...
class	SingleUtteranceGmmDecoder
	You will instantiate this class when you want to decode a single utterance using the online-decoding setup. More...
class	SingleUtteranceNnet2Decoder
	You will instantiate this class when you want to decode a single utterance using the online-decoding setup for neural nets. More...
class	SingleUtteranceNnet2DecoderThreaded
	You will instantiate this class when you want to decode a single utterance using the online-decoding setup for neural nets. More...
class	SingleUtteranceNnet3DecoderTpl
	You will instantiate this class when you want to decode a single utterance using the online-decoding setup for neural nets. More...
class	SingleUtteranceNnet3IncrementalDecoderTpl
	You will instantiate this class when you want to decode a single utterance using the online-decoding setup for neural nets. More...
struct	SlidingWindowCmnOptions
struct	SolverOptions
	This class describes the options for maximizing various quadratic objective functions. More...
class	SparseMatrix
class	SparseVector
class	SpectrogramComputer
	Class for computing spectrogram features. More...
struct	SpectrogramOptions
	SpectrogramOptions contains basic options for computing spectrogram features. More...
struct	SpeexOptions
class	SphinxMatrixHolder
	A class for reading/writing Sphinx format matrices. More...
class	SplitEventMap
class	SplitRadixComplexFft
class	SplitRadixRealFft
class	SpMatrix
	Packed symetric matrix class. More...
class	StandardInputImpl
class	StandardOutputImpl
struct	StringHasher
	A hashing function object for strings. More...
class	SubMatrix
	Sub-matrix representation. More...
class	SubVector
	Represents a non-allocating general vector which can be defined as a sub-vector of higher-level vector [or as the row of a matrix]. More...
class	TableEventMap
class	TableWriter
	A templated class for writing objects to an archive or script file; see The Table concept. More...
class	TableWriterArchiveImpl
class	TableWriterBothImpl
class	TableWriterImplBase
class	TableWriterScriptImpl
class	TaskSequencer
struct	TaskSequencerConfig
class	TcpServer
class	ThreadSynchronizer
	class ThreadSynchronizer acts to guard an arbitrary type of buffer between a producing and a consuming thread (note: it's all symmetric between the two thread types). More...
class	TidToTstateMapper
class	Timer
class	TokenHolder
class	TokenVectorHolder
class	TpMatrix
	Packed symetric matrix class. More...
class	TrainingGraphCompiler
struct	TrainingGraphCompilerOptions
class	TransitionModel
class	TreeClusterer
struct	TreeClusterOptions
class	TreeRenderer
class	TwvMetrics
struct	TwvMetricsOptions
class	TwvMetricsStats
struct	UbmClusteringOptions
class	UpdatePhoneVectorsClass
class	UpdateWClass
struct	VadEnergyOptions
class	Vector
	A class representing a vector. More...
class	VectorBase
	Provides a vector abstraction class. More...
class	VectorClusterable
	VectorClusterable wraps vectors in a form accessible to generic clustering algorithms. More...
class	VectorFstToKwsLexicographicFstMapper
struct	VectorHasher
	A hashing function-object for vectors. More...
class	WaveData
	This class's purpose is to read in Wave files. More...
struct	WaveHeaderReadGofer
class	WaveHolder
class	WaveInfo
	This class reads and hold wave file header information. More...
class	WaveInfoHolder
class	WordAlignedLatticeTester
class	WordAlignLatticeLexiconInfo
	This class extracts some information from the lexicon and stores it in a suitable form for the word-alignment code to use. More...
struct	WordAlignLatticeLexiconOpts
struct	WordBoundaryInfo
struct	WordBoundaryInfoNewOpts
struct	WordBoundaryInfoOpts
struct	WspecifierOptions

Typedefs
typedef void(*	LogHandler) (const LogMessageEnvelope &envelope, const char *message)
	Type of third-party logging function. More...
typedef float	BaseFloat
typedef float	float32
typedef double	double64
typedef int32	MatrixIndexT
typedef int32	SignedMatrixIndexT
typedef uint32	UnsignedMatrixIndexT
typedef basic_pipebuf< char >	PipebufType
typedef std::vector< std::string >	KeyList
typedef TableWriter< KaldiObjectHolder< MatrixBase< BaseFloat > > >	BaseFloatMatrixWriter
typedef SequentialTableReader< KaldiObjectHolder< Matrix< BaseFloat > > >	SequentialBaseFloatMatrixReader
typedef RandomAccessTableReader< KaldiObjectHolder< Matrix< BaseFloat > > >	RandomAccessBaseFloatMatrixReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< Matrix< BaseFloat > > >	RandomAccessBaseFloatMatrixReaderMapped
typedef TableWriter< KaldiObjectHolder< MatrixBase< double > > >	DoubleMatrixWriter
typedef SequentialTableReader< KaldiObjectHolder< Matrix< double > > >	SequentialDoubleMatrixReader
typedef RandomAccessTableReader< KaldiObjectHolder< Matrix< double > > >	RandomAccessDoubleMatrixReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< Matrix< double > > >	RandomAccessDoubleMatrixReaderMapped
typedef TableWriter< KaldiObjectHolder< CompressedMatrix > >	CompressedMatrixWriter
typedef TableWriter< KaldiObjectHolder< VectorBase< BaseFloat > > >	BaseFloatVectorWriter
typedef SequentialTableReader< KaldiObjectHolder< Vector< BaseFloat > > >	SequentialBaseFloatVectorReader
typedef RandomAccessTableReader< KaldiObjectHolder< Vector< BaseFloat > > >	RandomAccessBaseFloatVectorReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< Vector< BaseFloat > > >	RandomAccessBaseFloatVectorReaderMapped
typedef TableWriter< KaldiObjectHolder< VectorBase< double > > >	DoubleVectorWriter
typedef SequentialTableReader< KaldiObjectHolder< Vector< double > > >	SequentialDoubleVectorReader
typedef RandomAccessTableReader< KaldiObjectHolder< Vector< double > > >	RandomAccessDoubleVectorReader
typedef TableWriter< KaldiObjectHolder< CuMatrix< BaseFloat > > >	BaseFloatCuMatrixWriter
typedef SequentialTableReader< KaldiObjectHolder< CuMatrix< BaseFloat > > >	SequentialBaseFloatCuMatrixReader
typedef RandomAccessTableReader< KaldiObjectHolder< CuMatrix< BaseFloat > > >	RandomAccessBaseFloatCuMatrixReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< CuMatrix< BaseFloat > > >	RandomAccessBaseFloatCuMatrixReaderMapped
typedef TableWriter< KaldiObjectHolder< CuMatrix< double > > >	DoubleCuMatrixWriter
typedef SequentialTableReader< KaldiObjectHolder< CuMatrix< double > > >	SequentialDoubleCuMatrixReader
typedef RandomAccessTableReader< KaldiObjectHolder< CuMatrix< double > > >	RandomAccessDoubleCuMatrixReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< CuMatrix< double > > >	RandomAccessDoubleCuMatrixReaderMapped
typedef TableWriter< KaldiObjectHolder< CuVector< BaseFloat > > >	BaseFloatCuVectorWriter
typedef SequentialTableReader< KaldiObjectHolder< CuVector< BaseFloat > > >	SequentialBaseFloatCuVectorReader
typedef RandomAccessTableReader< KaldiObjectHolder< CuVector< BaseFloat > > >	RandomAccessBaseFloatCuVectorReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< CuVector< BaseFloat > > >	RandomAccessBaseFloatCuVectorReaderMapped
typedef TableWriter< KaldiObjectHolder< CuVector< double > > >	DoubleCuVectorWriter
typedef SequentialTableReader< KaldiObjectHolder< CuVector< double > > >	SequentialDoubleCuVectorReader
typedef RandomAccessTableReader< KaldiObjectHolder< CuVector< double > > >	RandomAccessDoubleCuVectorReader
typedef TableWriter< BasicHolder< int32 > >	Int32Writer
typedef SequentialTableReader< BasicHolder< int32 > >	SequentialInt32Reader
typedef RandomAccessTableReader< BasicHolder< int32 > >	RandomAccessInt32Reader
typedef TableWriter< BasicVectorHolder< int32 > >	Int32VectorWriter
typedef SequentialTableReader< BasicVectorHolder< int32 > >	SequentialInt32VectorReader
typedef RandomAccessTableReader< BasicVectorHolder< int32 > >	RandomAccessInt32VectorReader
typedef TableWriter< BasicVectorVectorHolder< int32 > >	Int32VectorVectorWriter
typedef SequentialTableReader< BasicVectorVectorHolder< int32 > >	SequentialInt32VectorVectorReader
typedef RandomAccessTableReader< BasicVectorVectorHolder< int32 > >	RandomAccessInt32VectorVectorReader
typedef TableWriter< BasicPairVectorHolder< int32 > >	Int32PairVectorWriter
typedef SequentialTableReader< BasicPairVectorHolder< int32 > >	SequentialInt32PairVectorReader
typedef RandomAccessTableReader< BasicPairVectorHolder< int32 > >	RandomAccessInt32PairVectorReader
typedef TableWriter< BasicPairVectorHolder< BaseFloat > >	BaseFloatPairVectorWriter
typedef SequentialTableReader< BasicPairVectorHolder< BaseFloat > >	SequentialBaseFloatPairVectorReader
typedef RandomAccessTableReader< BasicPairVectorHolder< BaseFloat > >	RandomAccessBaseFloatPairVectorReader
typedef TableWriter< BasicHolder< BaseFloat > >	BaseFloatWriter
typedef SequentialTableReader< BasicHolder< BaseFloat > >	SequentialBaseFloatReader
typedef RandomAccessTableReader< BasicHolder< BaseFloat > >	RandomAccessBaseFloatReader
typedef RandomAccessTableReaderMapped< BasicHolder< BaseFloat > >	RandomAccessBaseFloatReaderMapped
typedef TableWriter< BasicHolder< double > >	DoubleWriter
typedef SequentialTableReader< BasicHolder< double > >	SequentialDoubleReader
typedef RandomAccessTableReader< BasicHolder< double > >	RandomAccessDoubleReader
typedef TableWriter< BasicHolder< bool > >	BoolWriter
typedef SequentialTableReader< BasicHolder< bool > >	SequentialBoolReader
typedef RandomAccessTableReader< BasicHolder< bool > >	RandomAccessBoolReader
typedef TableWriter< TokenHolder >	TokenWriter
	TokenWriter is a writer specialized for std::string where the strings are nonempty and whitespace-free. More...
typedef SequentialTableReader< TokenHolder >	SequentialTokenReader
typedef RandomAccessTableReader< TokenHolder >	RandomAccessTokenReader
typedef TableWriter< TokenVectorHolder >	TokenVectorWriter
	TokenVectorWriter is a writer specialized for sequences of std::string where the strings are nonempty and whitespace-free. More...
typedef SequentialTableReader< TokenVectorHolder >	SequentialTokenVectorReader
typedef RandomAccessTableReader< TokenVectorHolder >	RandomAccessTokenVectorReader
typedef TableWriter< KaldiObjectHolder< GeneralMatrix > >	GeneralMatrixWriter
typedef SequentialTableReader< KaldiObjectHolder< GeneralMatrix > >	SequentialGeneralMatrixReader
typedef RandomAccessTableReader< KaldiObjectHolder< GeneralMatrix > >	RandomAccessGeneralMatrixReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< GeneralMatrix > >	RandomAccessGeneralMatrixReaderMapped
typedef OfflineFeatureTpl< FbankComputer >	Fbank
typedef OfflineFeatureTpl< MfccComputer >	Mfcc
typedef OfflineFeatureTpl< PlpComputer >	Plp
typedef OfflineFeatureTpl< SpectrogramComputer >	Spectrogram
typedef OnlineGenericBaseFeature< MfccComputer >	OnlineMfcc
typedef OnlineGenericBaseFeature< PlpComputer >	OnlinePlp
typedef OnlineGenericBaseFeature< FbankComputer >	OnlineFbank
typedef std::vector< std::pair< EventType, Clusterable * > >	BuildTreeStatsType
typedef uint16	uint_smaller
typedef int16	int_smaller
typedef int32	EventKeyType
	Things of type EventKeyType can take any value. More...
typedef int32	EventValueType
	Given current code, things of type EventValueType should generally be nonnegative and in a reasonably small range (e.g. More...
typedef int32	EventAnswerType
	As far as the event-map code itself is concerned, things of type EventAnswerType may take any value except kNoAnswer (== -1). More...
typedef std::vector< std::pair< EventKeyType, EventValueType > >	EventType
typedef TableWriter< KaldiObjectHolder< AmDiagGmm > >	MapAmDiagGmmWriter
typedef RandomAccessTableReader< KaldiObjectHolder< AmDiagGmm > >	RandomAccessMapAmDiagGmmReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< AmDiagGmm > >	RandomAccessMapAmDiagGmmReaderMapped
typedef SequentialTableReader< KaldiObjectHolder< AmDiagGmm > >	MapAmDiagGmmSeqReader
typedef uint16	GmmFlagsType
	Bitwise OR of the above flags. More...
typedef uint16	SgmmUpdateFlagsType
	Bitwise OR of the above flags. More...
typedef uint16	SgmmWriteFlagsType
	Bitwise OR of the above flags. More...
typedef TableWriter< KaldiObjectHolder< RegtreeFmllrDiagGmm > >	RegtreeFmllrDiagGmmWriter
typedef RandomAccessTableReader< KaldiObjectHolder< RegtreeFmllrDiagGmm > >	RandomAccessRegtreeFmllrDiagGmmReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< RegtreeFmllrDiagGmm > >	RandomAccessRegtreeFmllrDiagGmmReaderMapped
typedef SequentialTableReader< KaldiObjectHolder< RegtreeFmllrDiagGmm > >	RegtreeFmllrDiagGmmSeqReader
typedef TableWriter< KaldiObjectHolder< RegtreeMllrDiagGmm > >	RegtreeMllrDiagGmmWriter
typedef RandomAccessTableReader< KaldiObjectHolder< RegtreeMllrDiagGmm > >	RandomAccessRegtreeMllrDiagGmmReader
typedef RandomAccessTableReaderMapped< KaldiObjectHolder< RegtreeMllrDiagGmm > >	RandomAccessRegtreeMllrDiagGmmReaderMapped
typedef SequentialTableReader< KaldiObjectHolder< RegtreeMllrDiagGmm > >	RegtreeMllrDiagGmmSeqReader
typedef unordered_map< std::pair< int32, std::vector< int32 > >, fst::VectorFst< fst::StdArc > *, HmmCacheHash >	HmmCacheType
	HmmCacheType is a map from (central-phone, sequence of pdf-ids) to FST, used as cache in GetHmmAsFsa, as an optimization. More...
typedef std::vector< std::vector< std::pair< int32, BaseFloat > > >	Posterior
	Posterior is a typedef for storing acoustic-state (actually, transition-id) posteriors over an utterance. More...
typedef std::vector< std::vector< std::pair< int32, Vector< BaseFloat > > > >	GaussPost
	GaussPost is a typedef for storing Gaussian-level posteriors for an utterance. More...
typedef TableWriter< PosteriorHolder >	PosteriorWriter
typedef SequentialTableReader< PosteriorHolder >	SequentialPosteriorReader
typedef RandomAccessTableReader< PosteriorHolder >	RandomAccessPosteriorReader
typedef TableWriter< GaussPostHolder >	GaussPostWriter
typedef SequentialTableReader< GaussPostHolder >	SequentialGaussPostReader
typedef RandomAccessTableReader< GaussPostHolder >	RandomAccessGaussPostReader
typedef LatticeFasterDecoderConfig	LatticeBiglmFasterDecoderConfig
typedef LatticeFasterDecoderTpl< fst::StdFst, decoder::StdToken >	LatticeFasterDecoder
typedef LatticeFasterOnlineDecoderTpl< fst::StdFst >	LatticeFasterOnlineDecoder
typedef LatticeIncrementalDecoderTpl< fst::StdFst, decoder::StdToken >	LatticeIncrementalDecoder
typedef LatticeIncrementalOnlineDecoderTpl< fst::StdFst >	LatticeIncrementalOnlineDecoder
typedef fst::LatticeWeightTpl< BaseFloat >	LatticeWeight
typedef fst::CompactLatticeWeightTpl< LatticeWeight, int32 >	CompactLatticeWeight
typedef fst::CompactLatticeWeightCommonDivisorTpl< LatticeWeight, int32 >	CompactLatticeWeightCommonDivisor
typedef fst::ArcTpl< LatticeWeight >	LatticeArc
typedef fst::ArcTpl< CompactLatticeWeight >	CompactLatticeArc
typedef fst::VectorFst< LatticeArc >	Lattice
typedef fst::VectorFst< CompactLatticeArc >	CompactLattice
typedef TableWriter< LatticeHolder >	LatticeWriter
typedef SequentialTableReader< LatticeHolder >	SequentialLatticeReader
typedef RandomAccessTableReader< LatticeHolder >	RandomAccessLatticeReader
typedef TableWriter< CompactLatticeHolder >	CompactLatticeWriter
typedef SequentialTableReader< CompactLatticeHolder >	SequentialCompactLatticeReader
typedef RandomAccessTableReader< CompactLatticeHolder >	RandomAccessCompactLatticeReader
typedef Lattice::StateId	StateId
typedef Lattice::Arc	Arc
typedef fst::StdArc::Label	Label
typedef std::vector< std::pair< Label, Label > >	LabelPairVector
typedef KaldiObjectHolder< Sgmm2GauPost >	Sgmm2GauPostHolder
typedef RandomAccessTableReader< Sgmm2GauPostHolder >	RandomAccessSgmm2GauPostReader
typedef SequentialTableReader< Sgmm2GauPostHolder >	SequentialSgmm2GauPostReader
typedef TableWriter< Sgmm2GauPostHolder >	Sgmm2GauPostWriter
typedef fst::LexicographicWeight< TropicalWeight, TropicalWeight >	StdLStdWeight
typedef fst::LexicographicWeight< TropicalWeight, StdLStdWeight >	StdLStdLStdWeight
typedef fst::ArcTpl< StdLStdLStdWeight >	StdLStdLStdArc
typedef fst::ProductWeight< TropicalWeight, ArcticWeight >	StdXStdprimeWeight
typedef fst::ProductWeight< LogWeight, StdXStdprimeWeight >	LogXStdXStdprimeWeight
typedef fst::ArcTpl< LogXStdXStdprimeWeight >	LogXStdXStdprimeArc
typedef StdLStdLStdWeight	KwsLexicographicWeight
typedef StdLStdLStdArc	KwsLexicographicArc
typedef fst::VectorFst< KwsLexicographicArc >	KwsLexicographicFst
typedef LogXStdXStdprimeWeight	KwsProductWeight
typedef LogXStdXStdprimeArc	KwsProductArc
typedef fst::VectorFst< KwsProductArc >	KwsProductFst
typedef Arc::Weight	Weight
typedef kaldi::int32	int32
typedef SingleUtteranceNnet3DecoderTpl< fst::Fst< fst::StdArc > >	SingleUtteranceNnet3Decoder
typedef SingleUtteranceNnet3IncrementalDecoderTpl< fst::Fst< fst::StdArc > >	SingleUtteranceNnet3IncrementalDecoder

Enumerations
enum	CompressionMethod {   kAutomaticMethod = 1, kSpeechFeature = 2, kTwoByteAuto = 3, kTwoByteSignedInteger = 4,   kOneByteAuto = 5, kOneByteUnsignedInteger = 6, kOneByteZeroOne = 7 }
enum	MatrixTransposeType { kTrans = 112, kNoTrans = 111 }
enum	MatrixResizeType { kSetZero, kUndefined, kCopyData }
enum	MatrixStrideType { kDefaultStride, kStrideEqualNumCols }
enum	SpCopyType { kTakeLower, kTakeUpper, kTakeMean, kTakeMeanAndCheck }
enum	GeneralMatrixType { kFullMatrix, kCompressedMatrix, kSparseMatrix }
enum	OutputType { kNoOutput, kFileOutput, kStandardOutput, kPipeOutput }
enum	InputType {   kNoInput, kFileInput, kStandardInput, kOffsetFileInput,   kPipeInput }
enum	WspecifierType { kNoWspecifier, kArchiveWspecifier, kScriptWspecifier, kBothWspecifier }
enum	RspecifierType { kNoRspecifier, kArchiveRspecifier, kScriptRspecifier }
enum	ShellType { kBash = 0 }
enum	AllKeysType { kAllKeysInsistIdentical, kAllKeysIntersection, kAllKeysUnion }
	Typedef used when we get "all keys" from a set of stats– used in specifying which kinds of questions to ask. More...
enum	GmmUpdateFlags {   kGmmMeans = 0x001, kGmmVariances = 0x002, kGmmWeights = 0x004, kGmmTransitions = 0x008,   kGmmAll = 0x00F }
enum	SgmmUpdateFlags {   kSgmmPhoneVectors = 0x001, kSgmmPhoneProjections = 0x002, kSgmmPhoneWeightProjections = 0x004, kSgmmCovarianceMatrix = 0x008,   kSgmmSubstateWeights = 0x010, kSgmmSpeakerProjections = 0x020, kSgmmTransitions = 0x040, kSgmmSpeakerWeightProjections = 0x080,   kSgmmAll = 0x0FF }
enum	SgmmWriteFlags {   kSgmmGlobalParams = 0x001, kSgmmStateParams = 0x002, kSgmmNormalizers = 0x004, kSgmmBackgroundGmms = 0x008,   kSgmmWriteAll = 0x00F }
enum	cova_type { full, diag }
	Generate features for a certain covariance type covariance_type == 0: full covariance covariance_type == 1: diagonal covariance. More...
enum	{ kEps = 0, kDisambig, kBos, kEos }
enum	CuCompressedMatrixType { kCompressedMatrixInt8 = 1, kCompressedMatrixUint8 = 2, kCompressedMatrixInt16 = 3, kCompressedMatrixUint16 = 4 }
enum	DetectionDecision {   kKwsFalseAlarm, kKwsMiss, kKwsCorr, kKwsCorrUndetected,   kKwsUnseen }

Functions
template<class T >
void	WriteBasicType (std::ostream &os, bool binary, T t)
	WriteBasicType is the name of the write function for bool, integer types, and floating-point types. More...
template<class T >
void	ReadBasicType (std::istream &is, bool binary, T *t)
	ReadBasicType is the name of the read function for bool, integer types, and floating-point types. More...
template<class T >
void	WriteIntegerPairVector (std::ostream &os, bool binary, const std::vector< std::pair< T, T > > &v)
	Function for writing STL vectors of pairs of integer types. More...
template<class T >
void	ReadIntegerPairVector (std::istream &is, bool binary, std::vector< std::pair< T, T > > *v)
	Function for reading STL vector of pairs of integer types. More...
template<class T >
void	WriteIntegerVector (std::ostream &os, bool binary, const std::vector< T > &v)
	Function for writing STL vectors of integer types. More...
template<class T >
void	ReadIntegerVector (std::istream &is, bool binary, std::vector< T > *v)
	Function for reading STL vector of integer types. More...
void	InitKaldiOutputStream (std::ostream &os, bool binary)
	InitKaldiOutputStream initializes an opened stream for writing by writing an optional binary header and modifying the floating-point precision; it will typically not be called by users directly. More...
bool	InitKaldiInputStream (std::istream &is, bool *binary)
	Initialize an opened stream for reading by detecting the binary header and. More...
void	UnitTestIo (bool binary)
template<>
void	WriteBasicType< bool > (std::ostream &os, bool binary, bool b)
template<>
void	ReadBasicType< bool > (std::istream &is, bool binary, bool *b)
template<>
void	WriteBasicType< float > (std::ostream &os, bool binary, float f)
template<>
void	WriteBasicType< double > (std::ostream &os, bool binary, double f)
template<>
void	ReadBasicType< float > (std::istream &is, bool binary, float *f)
template<>
void	ReadBasicType< double > (std::istream &is, bool binary, double *d)
void	CheckToken (const char *token)
void	WriteToken (std::ostream &os, bool binary, const char *token)
	The WriteToken functions are for writing nonempty sequences of non-space characters. More...
int	Peek (std::istream &is, bool binary)
	Peek consumes whitespace (if binary == false) and then returns the peek() value of the stream. More...
void	WriteToken (std::ostream &os, bool binary, const std::string &token)
void	ReadToken (std::istream &is, bool binary, std::string *token)
	ReadToken gets the next token and puts it in str (exception on failure). More...
int	PeekToken (std::istream &is, bool binary)
	PeekToken will return the first character of the next token, or -1 if end of file. More...
void	ExpectToken (std::istream &is, bool binary, const char *token)
	ExpectToken tries to read in the given token, and throws an exception on failure. More...
void	ExpectToken (std::istream &is, bool binary, const std::string &token)
template<class T >
void	ReadBasicType (std::istream &is, bool binary, T *t, bool add)
void	ExpectPretty (std::istream &is, bool binary, const char *token)
	ExpectPretty attempts to read the text in "token", but only in non-binary mode. More...
void	ExpectPretty (std::istream &is, bool binary, const std::string &token)
void	MyFunction2 ()
void	MyFunction1 ()
void	UnitTestError ()
void	VerifySymbolRange (const std::string &trace, const bool want_found, const std::string &want_symbol)
void	TestLocateSymbolRange ()
void	SetProgramName (const char *basename)
	Called by ParseOptions to set base name (no directory) of the executing program. More...
static const char *	GetShortFileName (const char *path)
static std::string	KaldiGetStackTrace ()
void	KaldiAssertFailure_ (const char *func, const char *file, int32 line, const char *cond_str)
LogHandler	SetLogHandler (LogHandler)
	Set logging handler. More...
int32	GetVerboseLevel ()
	Get verbosity level, usually set via command line '–verbose=' switch. More...
void	SetVerboseLevel (int32 i)
	This should be rarely used, except by programs using Kaldi as library; command-line programs set the verbose level automatically from ParseOptions. More...
template<class I >
void	UnitTestGcdLcmTpl ()
void	UnitTestRoundUpToNearestPowerOfTwo ()
void	UnitTestDivideRoundingDown ()
void	UnitTestGcdLcm ()
void	UnitTestRand ()
void	UnitTestLogAddSub ()
void	UnitTestDefines ()
void	UnitTestAssertFunc ()
template<class I >
void	UnitTestFactorizeTpl ()
void	UnitTestFactorize ()
void	UnitTestApproxEqual ()
template<class Real >
void	UnitTestExpSpeed ()
template<class Real >
void	UnitTestLogSpeed ()
int32	RoundUpToNearestPowerOfTwo (int32 n)
int	Rand (struct RandomState *state)
bool	WithProb (BaseFloat prob, struct RandomState *state)
int32	RandInt (int32 min_val, int32 max_val, struct RandomState *state)
int32	RandPoisson (float lambda, struct RandomState *state)
void	RandGauss2 (float *a, float *b, RandomState *state)
void	RandGauss2 (double *a, double *b, RandomState *state)
double	Exp (double x)
float	Exp (float x)
double	Log (double x)
float	Log (float x)
double	Log1p (double x)
float	Log1p (float x)
float	RandUniform (struct RandomState *state=NULL)
	Returns a random number strictly between 0 and 1. More...
float	RandGauss (struct RandomState *state=NULL)
template<class Float >
Float	RandPrune (Float post, BaseFloat prune_thresh, struct RandomState *state=NULL)
double	LogAdd (double x, double y)
float	LogAdd (float x, float y)
double	LogSub (double x, double y)
float	LogSub (float x, float y)
static bool	ApproxEqual (float a, float b, float relative_tolerance=0.001)
	return abs(a - b) <= relative_tolerance * (abs(a)+abs(b)). More...
static void	AssertEqual (float a, float b, float relative_tolerance=0.001)
	assert abs(a - b) <= relative_tolerance * (abs(a)+abs(b)) More...
static int32	DivideRoundingDown (int32 a, int32 b)
	Returns a / b, rounding towards negative infinity in all cases. More...
template<class I >
I	Gcd (I m, I n)
template<class I >
I	Lcm (I m, I n)
	Returns the least common multiple of two integers. More...
template<class I >
void	Factorize (I m, std::vector< I > *factors)
double	Hypot (double x, double y)
float	Hypot (float x, float y)
std::string	CharToString (const char &c)
void	Sleep (float seconds)
int	MachineIsLittleEndian ()
void	TimerTest ()
void	cblas_Xcopy (const int N, const float *X, const int incX, float *Y, const int incY)
void	cblas_Xcopy (const int N, const double *X, const int incX, double *Y, const int incY)
float	cblas_Xasum (const int N, const float *X, const int incX)
double	cblas_Xasum (const int N, const double *X, const int incX)
void	cblas_Xrot (const int N, float *X, const int incX, float *Y, const int incY, const float c, const float s)
void	cblas_Xrot (const int N, double *X, const int incX, double *Y, const int incY, const double c, const double s)
float	cblas_Xdot (const int N, const float *const X, const int incX, const float *const Y, const int incY)
double	cblas_Xdot (const int N, const double *const X, const int incX, const double *const Y, const int incY)
void	cblas_Xaxpy (const int N, const float alpha, const float *X, const int incX, float *Y, const int incY)
void	cblas_Xaxpy (const int N, const double alpha, const double *X, const int incX, double *Y, const int incY)
void	cblas_Xscal (const int N, const float alpha, float *data, const int inc)
void	cblas_Xscal (const int N, const double alpha, double *data, const int inc)
void	cblas_Xspmv (const float alpha, const int num_rows, const float *Mdata, const float *v, const int v_inc, const float beta, float *y, const int y_inc)
void	cblas_Xspmv (const double alpha, const int num_rows, const double *Mdata, const double *v, const int v_inc, const double beta, double *y, const int y_inc)
void	cblas_Xtpmv (MatrixTransposeType trans, const float *Mdata, const int num_rows, float *y, const int y_inc)
void	cblas_Xtpmv (MatrixTransposeType trans, const double *Mdata, const int num_rows, double *y, const int y_inc)
void	cblas_Xtpsv (MatrixTransposeType trans, const float *Mdata, const int num_rows, float *y, const int y_inc)
void	cblas_Xtpsv (MatrixTransposeType trans, const double *Mdata, const int num_rows, double *y, const int y_inc)
void	cblas_Xspmv (MatrixIndexT dim, float alpha, const float *Mdata, const float *ydata, MatrixIndexT ystride, float beta, float *xdata, MatrixIndexT xstride)
void	cblas_Xspmv (MatrixIndexT dim, double alpha, const double *Mdata, const double *ydata, MatrixIndexT ystride, double beta, double *xdata, MatrixIndexT xstride)
void	cblas_Xspr2 (MatrixIndexT dim, float alpha, const float *Xdata, MatrixIndexT incX, const float *Ydata, MatrixIndexT incY, float *Adata)
void	cblas_Xspr2 (MatrixIndexT dim, double alpha, const double *Xdata, MatrixIndexT incX, const double *Ydata, MatrixIndexT incY, double *Adata)
void	cblas_Xspr (MatrixIndexT dim, float alpha, const float *Xdata, MatrixIndexT incX, float *Adata)
void	cblas_Xspr (MatrixIndexT dim, double alpha, const double *Xdata, MatrixIndexT incX, double *Adata)
void	cblas_Xgemv (MatrixTransposeType trans, MatrixIndexT num_rows, MatrixIndexT num_cols, float alpha, const float *Mdata, MatrixIndexT stride, const float *xdata, MatrixIndexT incX, float beta, float *ydata, MatrixIndexT incY)
void	cblas_Xgemv (MatrixTransposeType trans, MatrixIndexT num_rows, MatrixIndexT num_cols, double alpha, const double *Mdata, MatrixIndexT stride, const double *xdata, MatrixIndexT incX, double beta, double *ydata, MatrixIndexT incY)
void	cblas_Xgbmv (MatrixTransposeType trans, MatrixIndexT num_rows, MatrixIndexT num_cols, MatrixIndexT num_below, MatrixIndexT num_above, float alpha, const float *Mdata, MatrixIndexT stride, const float *xdata, MatrixIndexT incX, float beta, float *ydata, MatrixIndexT incY)
void	cblas_Xgbmv (MatrixTransposeType trans, MatrixIndexT num_rows, MatrixIndexT num_cols, MatrixIndexT num_below, MatrixIndexT num_above, double alpha, const double *Mdata, MatrixIndexT stride, const double *xdata, MatrixIndexT incX, double beta, double *ydata, MatrixIndexT incY)
template<typename Real >
void	Xgemv_sparsevec (MatrixTransposeType trans, MatrixIndexT num_rows, MatrixIndexT num_cols, Real alpha, const Real *Mdata, MatrixIndexT stride, const Real *xdata, MatrixIndexT incX, Real beta, Real *ydata, MatrixIndexT incY)
void	cblas_Xgemm (const float alpha, MatrixTransposeType transA, const float *Adata, MatrixIndexT a_num_rows, MatrixIndexT a_num_cols, MatrixIndexT a_stride, MatrixTransposeType transB, const float *Bdata, MatrixIndexT b_stride, const float beta, float *Mdata, MatrixIndexT num_rows, MatrixIndexT num_cols, MatrixIndexT stride)
void	cblas_Xgemm (const double alpha, MatrixTransposeType transA, const double *Adata, MatrixIndexT a_num_rows, MatrixIndexT a_num_cols, MatrixIndexT a_stride, MatrixTransposeType transB, const double *Bdata, MatrixIndexT b_stride, const double beta, double *Mdata, MatrixIndexT num_rows, MatrixIndexT num_cols, MatrixIndexT stride)
void	cblas_Xsymm (const float alpha, MatrixIndexT sz, const float *Adata, MatrixIndexT a_stride, const float *Bdata, MatrixIndexT b_stride, const float beta, float *Mdata, MatrixIndexT stride)
void	cblas_Xsymm (const double alpha, MatrixIndexT sz, const double *Adata, MatrixIndexT a_stride, const double *Bdata, MatrixIndexT b_stride, const double beta, double *Mdata, MatrixIndexT stride)
void	cblas_Xger (MatrixIndexT num_rows, MatrixIndexT num_cols, float alpha, const float *xdata, MatrixIndexT incX, const float *ydata, MatrixIndexT incY, float *Mdata, MatrixIndexT stride)
void	cblas_Xger (MatrixIndexT num_rows, MatrixIndexT num_cols, double alpha, const double *xdata, MatrixIndexT incX, const double *ydata, MatrixIndexT incY, double *Mdata, MatrixIndexT stride)
void	cblas_Xsyrk (const MatrixTransposeType trans, const MatrixIndexT dim_c, const MatrixIndexT other_dim_a, const float alpha, const float *A, const MatrixIndexT a_stride, const float beta, float *C, const MatrixIndexT c_stride)
void	cblas_Xsyrk (const MatrixTransposeType trans, const MatrixIndexT dim_c, const MatrixIndexT other_dim_a, const double alpha, const double *A, const MatrixIndexT a_stride, const double beta, double *C, const MatrixIndexT c_stride)
void	cblas_Xsbmv1 (const MatrixIndexT dim, const double *A, const double alpha, const double *x, const double beta, double *y)
	matrix-vector multiply using a banded matrix; we always call this with b = 1 meaning we're multiplying by a diagonal matrix. More...
void	cblas_Xsbmv1 (const MatrixIndexT dim, const float *A, const float alpha, const float *x, const float beta, float *y)
void	mul_elements (const MatrixIndexT dim, const double *a, double *b)
	This is not really a wrapper for CBLAS as CBLAS does not have this; in future we could extend this somehow. More...
void	mul_elements (const MatrixIndexT dim, const float *a, float *b)
void	clapack_Xtptri (KaldiBlasInt *num_rows, float *Mdata, KaldiBlasInt *result)
void	clapack_Xtptri (KaldiBlasInt *num_rows, double *Mdata, KaldiBlasInt *result)
void	clapack_Xgetrf2 (KaldiBlasInt *num_rows, KaldiBlasInt *num_cols, float *Mdata, KaldiBlasInt *stride, KaldiBlasInt *pivot, KaldiBlasInt *result)
void	clapack_Xgetrf2 (KaldiBlasInt *num_rows, KaldiBlasInt *num_cols, double *Mdata, KaldiBlasInt *stride, KaldiBlasInt *pivot, KaldiBlasInt *result)
void	clapack_Xgetri2 (KaldiBlasInt *num_rows, float *Mdata, KaldiBlasInt *stride, KaldiBlasInt *pivot, float *p_work, KaldiBlasInt *l_work, KaldiBlasInt *result)
void	clapack_Xgetri2 (KaldiBlasInt *num_rows, double *Mdata, KaldiBlasInt *stride, KaldiBlasInt *pivot, double *p_work, KaldiBlasInt *l_work, KaldiBlasInt *result)
void	clapack_Xgesvd (char *v, char *u, KaldiBlasInt *num_cols, KaldiBlasInt *num_rows, float *Mdata, KaldiBlasInt *stride, float *sv, float *Vdata, KaldiBlasInt *vstride, float *Udata, KaldiBlasInt *ustride, float *p_work, KaldiBlasInt *l_work, KaldiBlasInt *result)
void	clapack_Xgesvd (char *v, char *u, KaldiBlasInt *num_cols, KaldiBlasInt *num_rows, double *Mdata, KaldiBlasInt *stride, double *sv, double *Vdata, KaldiBlasInt *vstride, double *Udata, KaldiBlasInt *ustride, double *p_work, KaldiBlasInt *l_work, KaldiBlasInt *result)
void	clapack_Xsptri (KaldiBlasInt *num_rows, float *Mdata, KaldiBlasInt *ipiv, float *work, KaldiBlasInt *result)
void	clapack_Xsptri (KaldiBlasInt *num_rows, double *Mdata, KaldiBlasInt *ipiv, double *work, KaldiBlasInt *result)
void	clapack_Xsptrf (KaldiBlasInt *num_rows, float *Mdata, KaldiBlasInt *ipiv, KaldiBlasInt *result)
void	clapack_Xsptrf (KaldiBlasInt *num_rows, double *Mdata, KaldiBlasInt *ipiv, KaldiBlasInt *result)
template<typename Real >
std::ostream &	operator<< (std::ostream &os, const MatrixBase< Real > &M)
template<typename Real >
std::istream &	operator>> (std::istream &is, Matrix< Real > &M)
template<typename Real >
std::istream &	operator>> (std::istream &is, MatrixBase< Real > &M)
template<typename Real >
bool	ReadHtk (std::istream &is, Matrix< Real > *M_ptr, HtkHeader *header_ptr)
	Extension of the HTK header. More...
template bool	ReadHtk (std::istream &is, Matrix< float > *M, HtkHeader *header_ptr)
template bool	ReadHtk (std::istream &is, Matrix< double > *M, HtkHeader *header_ptr)
template<typename Real >
bool	WriteHtk (std::ostream &os, const MatrixBase< Real > &M, HtkHeader htk_hdr)
template bool	WriteHtk (std::ostream &os, const MatrixBase< float > &M, HtkHeader htk_hdr)
template bool	WriteHtk (std::ostream &os, const MatrixBase< double > &M, HtkHeader htk_hdr)
template<class Real >
bool	WriteSphinx (std::ostream &os, const MatrixBase< Real > &M)
template bool	WriteSphinx (std::ostream &os, const MatrixBase< float > &M)
template bool	WriteSphinx (std::ostream &os, const MatrixBase< double > &M)
template<typename Real >
Real	TraceMatMatMat (const MatrixBase< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const MatrixBase< Real > &C, MatrixTransposeType transC)
	Returns tr(A B C) More...
template float	TraceMatMatMat (const MatrixBase< float > &A, MatrixTransposeType transA, const MatrixBase< float > &B, MatrixTransposeType transB, const MatrixBase< float > &C, MatrixTransposeType transC)
template double	TraceMatMatMat (const MatrixBase< double > &A, MatrixTransposeType transA, const MatrixBase< double > &B, MatrixTransposeType transB, const MatrixBase< double > &C, MatrixTransposeType transC)
template<typename Real >
Real	TraceMatMatMatMat (const MatrixBase< Real > &A, MatrixTransposeType transA, const MatrixBase< Real > &B, MatrixTransposeType transB, const MatrixBase< Real > &C, MatrixTransposeType transC, const MatrixBase< Real > &D, MatrixTransposeType transD)
	Returns tr(A B C D) More...
template float	TraceMatMatMatMat (const MatrixBase< float > &A, MatrixTransposeType transA, const MatrixBase< float > &B, MatrixTransposeType transB, const MatrixBase< float > &C, MatrixTransposeType transC, const MatrixBase< float > &D, MatrixTransposeType transD)
template double	TraceMatMatMatMat (const MatrixBase< double > &A, MatrixTransposeType transA, const MatrixBase< double > &B, MatrixTransposeType transB, const MatrixBase< double > &C, MatrixTransposeType transC, const MatrixBase< double > &D, MatrixTransposeType transD)
template<typename Real >
void	SortSvd (VectorBase< Real > *s, MatrixBase< Real > *U, MatrixBase< Real > *Vt=NULL, bool sort_on_absolute_value=true)
	Function to ensure that SVD is sorted. More...
template void	SortSvd (VectorBase< float > *s, MatrixBase< float > *U, MatrixBase< float > *Vt, bool)
template void	SortSvd (VectorBase< double > *s, MatrixBase< double > *U, MatrixBase< double > *Vt, bool)
template<typename Real >
void	CreateEigenvalueMatrix (const VectorBase< Real > &real, const VectorBase< Real > &imag, MatrixBase< Real > *D)
	Creates the eigenvalue matrix D that is part of the decomposition used Matrix::Eig. More...
template void	CreateEigenvalueMatrix (const VectorBase< float > &re, const VectorBase< float > &im, MatrixBase< float > *D)
template void	CreateEigenvalueMatrix (const VectorBase< double > &re, const VectorBase< double > &im, MatrixBase< double > *D)
template<typename Real >
bool	AttemptComplexPower (Real *x_re, Real *x_im, Real power)
	The following function is used in Matrix::Power, and separately tested, so we declare it here mainly for the testing code to see. More...
template bool	AttemptComplexPower (float *x_re, float *x_im, float power)
template bool	AttemptComplexPower (double *x_re, double *x_im, double power)
template float	TraceMatMat (const MatrixBase< float > &A, const MatrixBase< float > &B, MatrixTransposeType trans)
template double	TraceMatMat (const MatrixBase< double > &A, const MatrixBase< double > &B, MatrixTransposeType trans)
template<typename Real >
bool	ApproxEqual (const MatrixBase< Real > &A, const MatrixBase< Real > &B, Real tol=0.01)
template<typename Real >
void	AssertEqual (const MatrixBase< Real > &A, const MatrixBase< Real > &B, float tol=0.01)
template<typename Real >
double	TraceMat (const MatrixBase< Real > &A)
	Returns trace of matrix. More...
template<typename Real >
bool	SameDim (const MatrixBase< Real > &M, const MatrixBase< Real > &N)
template<typename Real >
std::ostream &	operator<< (std::ostream &os, const VectorBase< Real > &rv)
template<typename Real >
std::istream &	operator>> (std::istream &in, VectorBase< Real > &v)
	Input from a C++ stream. More...
template<typename Real >
std::istream &	operator>> (std::istream &in, Vector< Real > &v)
	Input from a C++ stream. More...
template<typename Real >
Real	VecVec (const VectorBase< Real > &v1, const VectorBase< Real > &v2)
	Returns dot product between v1 and v2. More...
template float	VecVec (const VectorBase< float > &a, const VectorBase< float > &b)
template double	VecVec (const VectorBase< double > &a, const VectorBase< double > &b)
template<typename Real , typename OtherReal >
Real	VecVec (const VectorBase< Real > &ra, const VectorBase< OtherReal > &rb)
template float	VecVec (const VectorBase< float > &ra, const VectorBase< double > &rb)
template double	VecVec (const VectorBase< double > &ra, const VectorBase< float > &rb)
template<typename Real >
Real	VecMatVec (const VectorBase< Real > &v1, const MatrixBase< Real > &M, const VectorBase< Real > &v2)
	Returns . More...
template float	VecMatVec (const VectorBase< float > &v1, const MatrixBase< float > &M, const VectorBase< float > &v2)
template double	VecMatVec (const VectorBase< double > &v1, const MatrixBase< double > &M, const VectorBase< double > &v2)
template<typename Real >
bool	ApproxEqual (const VectorBase< Real > &a, const VectorBase< Real > &b, Real tol=0.01)
template<typename Real >
void	AssertEqual (VectorBase< Real > &a, VectorBase< Real > &b, float tol=0.01)
template<typename Real >
void	ComplexMul (const Real &a_re, const Real &a_im, Real *b_re, Real *b_im)
	ComplexMul implements, inline, the complex multiplication b *= a. More...
template<typename Real >
void	ComplexAddProduct (const Real &a_re, const Real &a_im, const Real &b_re, const Real &b_im, Real *c_re, Real *c_im)
	ComplexMul implements, inline, the complex operation c += (a * b). More...
template<typename Real >
void	ComplexImExp (Real x, Real *a_re, Real *a_im)
	ComplexImExp implements a <– exp(i x), inline. More...
template<typename Real >
void	ComplexFt (const VectorBase< Real > &in, VectorBase< Real > *out, bool forward)
	ComplexFt is the same as ComplexFft but it implements the Fourier transform in an inefficient way. More...
template void	ComplexFt (const VectorBase< float > &in, VectorBase< float > *out, bool forward)
template void	ComplexFt (const VectorBase< double > &in, VectorBase< double > *out, bool forward)
template<typename Real >
void	ComplexFftRecursive (Real *data, int nffts, int N, const int *factor_begin, const int *factor_end, bool forward, Vector< Real > *tmp_vec)
	ComplexFftRecursive is a recursive function that computes the complex FFT of size N. More...
template<typename Real >
void	ComplexFft (VectorBase< Real > *v, bool forward, Vector< Real > *tmp_work=NULL)
	The function ComplexFft does an Fft on the vector argument v. More...
template<typename Real >
void	RealFftInefficient (VectorBase< Real > *v, bool forward)
	Inefficient version of Fourier transform, for testing purposes. More...
template void	RealFftInefficient (VectorBase< float > *v, bool forward)
template void	RealFftInefficient (VectorBase< double > *v, bool forward)
template void	ComplexFft (VectorBase< float > *v, bool forward, Vector< float > *tmp_in)
template void	ComplexFft (VectorBase< double > *v, bool forward, Vector< double > *tmp_in)
template<typename Real >
void	RealFft (VectorBase< Real > *v, bool forward)
	RealFft is a fourier transform of real inputs. More...
template void	RealFft (VectorBase< float > *v, bool forward)
template void	RealFft (VectorBase< double > *v, bool forward)
template<typename Real >
void	ComputeDctMatrix (Matrix< Real > *M)
	ComputeDctMatrix computes a matrix corresponding to the DCT, such that M * v equals the DCT of vector v. More...
template void	ComputeDctMatrix (Matrix< float > *M)
template void	ComputeDctMatrix (Matrix< double > *M)
template<typename Real >
void	ComputePca (const MatrixBase< Real > &X, MatrixBase< Real > *U, MatrixBase< Real > *A, bool print_eigs=false, bool exact=true)
	ComputePCA does a PCA computation, using either outer products or inner products, whichever is more efficient. More...
template void	ComputePca (const MatrixBase< float > &X, MatrixBase< float > *U, MatrixBase< float > *A, bool print_eigs, bool exact)
template void	ComputePca (const MatrixBase< double > &X, MatrixBase< double > *U, MatrixBase< double > *A, bool print_eigs, bool exact)
template<typename Real >
void	AddOuterProductPlusMinus (Real alpha, const VectorBase< Real > &a, const VectorBase< Real > &b, MatrixBase< Real > *plus, MatrixBase< Real > *minus)
template void	AddOuterProductPlusMinus< float > (float alpha, const VectorBase< float > &a, const VectorBase< float > &b, MatrixBase< float > *plus, MatrixBase< float > *minus)
template void	AddOuterProductPlusMinus< double > (double alpha, const VectorBase< double > &a, const VectorBase< double > &b, MatrixBase< double > *plus, MatrixBase< double > *minus)
template<typename Real1 , typename Real2 >
void	AssertSameDim (const MatrixBase< Real1 > &mat1, const MatrixBase< Real2 > &mat2)
template<typename Real >
std::string	NameOf ()
template<typename Real >
static void	CsvResult (std::string test, int dim, BaseFloat measure, std::string units)
template<typename Real >
static void	UnitTestRealFftSpeed ()
template<typename Real >
static void	UnitTestSplitRadixRealFftSpeed ()
template<typename Real >
static void	UnitTestSvdSpeed ()
template<typename Real >
static void	UnitTestAddMatMatSpeed ()
template<typename Real >
static void	UnitTestAddRowSumMatSpeed ()
template<typename Real >
static void	UnitTestAddColSumMatSpeed ()
template<typename Real >
static void	UnitTestAddVecToRowsSpeed ()
template<typename Real >
static void	UnitTestAddVecToColsSpeed ()
template<typename Real >
static void	MatrixUnitSpeedTest ()
template<typename Real >
void	RandPosdefSpMatrix (MatrixIndexT dim, SpMatrix< Real > *matrix)
template<typename Real >
static void	InitRandNonsingular (MatrixBase< Real > *M)
template<typename Real >
static void	InitRandNonsingular (SpMatrix< Real > *M)
template<typename Real >
static void	CholeskyUnitTestTr ()
template<typename Real >
static void	SlowMatMul ()
template<typename Real >
static void	UnitTestAddToDiagMatrix ()
template<typename Real >
static void	UnitTestAddDiagVecMat ()
template<typename Real >
static void	UnitTestAddMatDiagVec ()
template<typename Real >
static void	UnitTestAddMatMatElements ()
template<typename Real >
static void	UnitTestAddSp ()
template<typename Real , typename OtherReal >
static void	UnitTestSpAddDiagVec ()
template<typename Real >
static void	UnitTestSpAddVecVec ()
template<typename Real >
static void	UnitTestCopyRowsAndCols ()
template<typename Real >
static void	UnitTestSpliceRows ()
template<typename Real >
static void	UnitTestRemoveRow ()
template<typename Real >
static void	UnitTestSubvector ()
static int32	DoubleFactorial (int32 i)
template<typename Real >
static void	UnitTestSetRandn ()
template<typename Real >
static void	UnitTestSetRandUniform ()
template<typename Real >
static void	UnitTestSimpleForVec ()
template<typename Real >
static void	UnitTestVectorMax ()
template<typename Real >
static void	UnitTestVectorMin ()
template<typename Real >
static void	UnitTestReplaceValue ()
template<typename Real >
static void	UnitTestNorm ()
template<typename Real >
static void	UnitTestCopyRows ()
template<typename Real >
static void	UnitTestCopyToRows ()
template<typename Real >
static void	UnitTestAddRows ()
template<typename Real >
static void	UnitTestAddToRows ()
template<typename Real >
static void	UnitTestCopyCols ()
template<typename Real >
static void	UnitTestSimpleForMat ()
template<typename Real >
static void	UnitTestRow ()
template<typename Real >
static void	UnitTestAxpy ()
template<typename Real >
static void	UnitTestCopySp ()
template<typename Real >
static void	UnitTestPower ()
template<typename Real >
static void	UnitTestPowerAbs ()
template<typename Real >
static void	UnitTestHeaviside ()
template<typename Real >
static void	UnitTestAddOuterProductPlusMinus ()
template<typename Real >
static void	UnitTestSger ()
template<typename Real >
static void	UnitTestDeterminant ()
template<typename Real >
static void	UnitTestDeterminantSign ()
template<typename Real >
static void	UnitTestSpVec ()
template<typename Real >
static void	UnitTestTraceProduct ()
template<typename Real >
static void	UnitTestSvd ()
template<typename Real >
static void	UnitTestSvdBad ()
template<typename Real >
static void	UnitTestSvdZero ()
template<typename Real >
static void	UnitTestSvdNodestroy ()
template<typename Real >
static void	UnitTestSvdJustvec ()
template<typename Real >
static void	UnitTestEigSymmetric ()
template<typename Real >
static void	UnitTestEig ()
template<typename Real >
static void	UnitTestEigSp ()
template<typename Real >
static Real	NonOrthogonality (const MatrixBase< Real > &M, MatrixTransposeType transM)
template<typename Real >
static Real	NonDiagonalness (const SpMatrix< Real > &S)
template<typename Real >
static Real	NonUnitness (const SpMatrix< Real > &S)
template<typename Real >
static void	UnitTestTridiagonalize ()
template<typename Real >
static void	UnitTestTridiagonalizeAndQr ()
template<typename Real >
static void	UnitTestMmul ()
template<typename Real >
static void	UnitTestMmulSym ()
template<typename Real >
static void	UnitTestAddVecVec ()
template<typename Real >
static void	UnitTestVecmul ()
template<typename Real >
static void	UnitTestInverse ()
template<typename Real >
static void	UnitTestMulElements ()
template<typename Real >
static void	UnitTestDotprod ()
template<class Real >
void	PlaceNansInGaps (Matrix< Real > *mat)
template<typename Real >
static void	UnitTestResizeCopyDataDifferentStrideType ()
	Make sure that when Resize() is called with resize_type = kCopyData and a stride_type different from this's stride_type, the resized matrix is equivalent to the original matrix (modulo the stride). More...
template<typename Real >
static void	UnitTestResize ()
template<typename Real >
static void	UnitTestTp2Sp ()
template<typename Real >
static void	UnitTestTp2 ()
template<typename Real >
static void	UnitTestAddDiagMat2 ()
template<typename Real >
static void	UnitTestAddDiagMatMat ()
template<typename Real >
static void	UnitTestOrthogonalizeRows ()
template<typename Real >
static void	UnitTestTransposeScatter ()
template<typename Real >
static void	UnitTestRankNUpdate ()
template<typename Real >
static void	UnitTestSpInvert ()
template<typename Real >
static void	UnitTestTpInvert ()
template<typename Real >
static void	UnitTestLimitCondInvert ()
template<typename Real >
static void	UnitTestFloorChol ()
template<typename Real >
static void	UnitTestFloorUnit ()
template<typename Real >
static void	UnitTestFloorCeiling ()
template<typename Real >
static void	UnitTestMat2Vec ()
template<typename Real >
static void	UnitTestLimitCond ()
template<typename Real >
static void	UnitTestTanh ()
template<typename Real >
static void	UnitTestSigmoid ()
template<typename Real >
static void	UnitTestSoftHinge ()
template<typename Real >
static void	UnitTestSimple ()
template<typename Real >
static void	UnitTestIo ()
template<typename Real >
static void	UnitTestIoCross ()
template<typename Real >
static void	UnitTestHtkIo ()
template<typename Real >
static void	UnitTestRange ()
template<typename Real >
static void	UnitTestScale ()
template<typename Real >
static void	UnitTestMul ()
template<typename Real >
static void	UnitTestApplyExpSpecial ()
template<typename Real >
static void	UnitTestInnerProd ()
template<typename Real >
static void	UnitTestAddToDiag ()
template<typename Real >
static void	UnitTestScaleDiag ()
template<typename Real >
static void	UnitTestSetDiag ()
template<typename Real >
static void	UnitTestTraceSpSpLower ()
template<typename Real >
static void	UnitTestAddMatSmat ()
template<typename Real >
static void	UnitTestAddMat2Sp ()
template<typename Real >
static void	UnitTestAddMatSelf ()
template<typename Real >
static void	UnitTestAddMat2 ()
template<typename Real >
static void	UnitTestSymAddMat2 ()
template<typename Real >
static void	UnitTestSolve ()
template<typename Real >
static void	UnitTestMax2 ()
template<typename Real >
static void	UnitTestMaxAbsEig ()
template<typename Real >
static void	UnitTestLbfgs ()
template<typename Real >
static void	UnitTestLinearCgd ()
template<typename Real >
static void	UnitTestMaxMin ()
template<typename Real >
static bool	approx_equal (Real a, Real b)
template<typename Real >
static void	UnitTestTrace ()
template<typename Real >
static void	UnitTestComplexFt ()
template<typename Real >
static void	UnitTestDct ()
template<typename Real >
static void	UnitTestComplexFft ()
template<typename Real >
static void	UnitTestSplitRadixComplexFft ()
template<typename Real >
static void	UnitTestTranspose ()
template<typename Real >
static void	UnitTestAddVecToRows ()
template<typename Real >
static void	UnitTestAddVec2Sp ()
template<typename Real >
static void	UnitTestAddVecToCols ()
template<typename Real >
static void	UnitTestComplexFft2 ()
template<typename Real >
static void	UnitTestSplitRadixComplexFft2 ()
template<typename Real >
static void	UnitTestRealFft ()
template<typename Real >
static void	UnitTestSplitRadixRealFft ()
template<typename Real >
static void	UnitTestRealFftSpeed ()
template<typename Real >
static void	UnitTestSplitRadixRealFftSpeed ()
template<typename Real >
void	UnitTestComplexPower ()
template<typename Real >
void	UnitTestNonsymmetricPower ()
void	UnitTestAddVecCross ()
template<typename Real >
static void	UnitTestPca (bool full_test)
template<typename Real >
static void	UnitTestPca2 (bool full_test)
template<typename Real >
static void	UnitTestSvdSpeed ()
template<typename Real >
static void	UnitTestCompressedMatrix2 ()
template<typename Real >
static void	UnitTestCompressedMatrix ()
template<typename Real >
static void	UnitTestGeneralMatrix ()
template<typename Real >
static void	UnitTestExtractCompressedMatrix ()
template<typename Real >
static void	UnitTestTridiag ()
template<typename Real >
static void	UnitTestRandCategorical ()
template<class Real >
static void	UnitTestAddMatMatNans ()
template<class Real >
static void	UnitTestTopEigs ()
template<typename Real >
static void	UnitTestTriVecSolver ()
template<typename Real >
static void	MatrixUnitTest (bool full_test)
template<class Real >
int32	LinearCgd (const LinearCgdOptions &opts, const SpMatrix< Real > &A, const VectorBase< Real > &b, VectorBase< Real > *x)
template int32	LinearCgd< float > (const LinearCgdOptions &opts, const SpMatrix< float > &A, const VectorBase< float > &b, VectorBase< float > *x)
template int32	LinearCgd< double > (const LinearCgdOptions &opts, const SpMatrix< double > &A, const VectorBase< double > &b, VectorBase< double > *x)
template<typename Real >
std::ostream &	operator<< (std::ostream &out, const PackedMatrix< Real > &M)
template<typename Real >
std::istream &	operator>> (std::istream &is, PackedMatrix< Real > &M)
template<typename Real >
void	HouseBackward (MatrixIndexT dim, const Real *x, Real *v, Real *beta)
template<typename Real >
void	Givens (Real a, Real b, Real *c, Real *s)
	Create Givens rotations, as in Golub and Van Loan 3rd ed., page 216. More...
template<typename Real >
void	QrStep (MatrixIndexT n, Real *diag, Real *off_diag, MatrixBase< Real > *Q)
template<typename Real >
void	QrInternal (MatrixIndexT n, Real *diag, Real *off_diag, MatrixBase< Real > *Q)
template<>
double	SolveQuadraticProblem (const SpMatrix< double > &H, const VectorBase< double > &g, const SolverOptions &opts, VectorBase< double > *x)
template<>
float	SolveQuadraticProblem (const SpMatrix< float > &H, const VectorBase< float > &g, const SolverOptions &opts, VectorBase< float > *x)
double	TraceSpSp (const SpMatrix< double > &A, const SpMatrix< double > &B)
float	TraceSpSp (const SpMatrix< float > &A, const SpMatrix< float > &B)
	Returns tr(A B). More...
template<typename Real , typename OtherReal >
Real	TraceSpSp (const SpMatrix< Real > &A, const SpMatrix< OtherReal > &B)
	Returns tr(A B). More...
template float	TraceSpSp< float, double > (const SpMatrix< float > &A, const SpMatrix< double > &B)
template double	TraceSpSp< double, float > (const SpMatrix< double > &A, const SpMatrix< float > &B)
template<typename Real >
Real	TraceSpMat (const SpMatrix< Real > &A, const MatrixBase< Real > &B)
	Returns tr(A B). More...
template float	TraceSpMat (const SpMatrix< float > &A, const MatrixBase< float > &B)
template double	TraceSpMat (const SpMatrix< double > &A, const MatrixBase< double > &B)
template<typename Real >
Real	TraceMatSpMat (const MatrixBase< Real > &A, MatrixTransposeType transA, const SpMatrix< Real > &B, const MatrixBase< Real > &C, MatrixTransposeType transC)
	Returns tr(A B C) (A and C may be transposed as specified by transA and transC). More...
template float	TraceMatSpMat (const MatrixBase< float > &A, MatrixTransposeType transA, const SpMatrix< float > &B, const MatrixBase< float > &C, MatrixTransposeType transC)
template double	TraceMatSpMat (const MatrixBase< double > &A, MatrixTransposeType transA, const SpMatrix< double > &B, const MatrixBase< double > &C, MatrixTransposeType transC)
template<typename Real >
Real	TraceMatSpMatSp (const MatrixBase< Real > &A, MatrixTransposeType transA, const SpMatrix< Real > &B, const MatrixBase< Real > &C, MatrixTransposeType transC, const SpMatrix< Real > &D)
	Returns tr (A B C D) (A and C may be transposed as specified by transA and transB). More...
template float	TraceMatSpMatSp (const MatrixBase< float > &A, MatrixTransposeType transA, const SpMatrix< float > &B, const MatrixBase< float > &C, MatrixTransposeType transC, const SpMatrix< float > &D)
template double	TraceMatSpMatSp (const MatrixBase< double > &A, MatrixTransposeType transA, const SpMatrix< double > &B, const MatrixBase< double > &C, MatrixTransposeType transC, const SpMatrix< double > &D)
template<typename Real >
Real	SolveQuadraticMatrixProblem (const SpMatrix< Real > &Q, const MatrixBase< Real > &Y, const SpMatrix< Real > &P, const SolverOptions &opts, MatrixBase< Real > *M)
	Maximizes the auxiliary function : Like a numerically stable version of . More...
template<typename Real >
Real	SolveDoubleQuadraticMatrixProblem (const MatrixBase< Real > &G, const SpMatrix< Real > &P1, const SpMatrix< Real > &P2, const SpMatrix< Real > &Q1, const SpMatrix< Real > &Q2, const SolverOptions &opts, MatrixBase< Real > *M)
	Maximizes the auxiliary function : Encountered in matrix update with a prior. More...
template<typename Real >
Real	VecSpVec (const VectorBase< Real > &v1, const SpMatrix< Real > &M, const VectorBase< Real > &v2)
	Computes v1^T * M * v2. More...
template float	VecSpVec (const VectorBase< float > &v1, const SpMatrix< float > &M, const VectorBase< float > &v2)
template double	VecSpVec (const VectorBase< double > &v1, const SpMatrix< double > &M, const VectorBase< double > &v2)
template<typename Real >
Real	TraceSpSpLower (const SpMatrix< Real > &A, const SpMatrix< Real > &B)
template double	TraceSpSpLower (const SpMatrix< double > &A, const SpMatrix< double > &B)
template float	TraceSpSpLower (const SpMatrix< float > &A, const SpMatrix< float > &B)
template float	SolveQuadraticMatrixProblem (const SpMatrix< float > &Q, const MatrixBase< float > &Y, const SpMatrix< float > &SigmaInv, const SolverOptions &opts, MatrixBase< float > *M)
template double	SolveQuadraticMatrixProblem (const SpMatrix< double > &Q, const MatrixBase< double > &Y, const SpMatrix< double > &SigmaInv, const SolverOptions &opts, MatrixBase< double > *M)
template float	SolveDoubleQuadraticMatrixProblem (const MatrixBase< float > &G, const SpMatrix< float > &P1, const SpMatrix< float > &P2, const SpMatrix< float > &Q1, const SpMatrix< float > &Q2, const SolverOptions &opts, MatrixBase< float > *M)
template double	SolveDoubleQuadraticMatrixProblem (const MatrixBase< double > &G, const SpMatrix< double > &P1, const SpMatrix< double > &P2, const SpMatrix< double > &Q1, const SpMatrix< double > &Q2, const SolverOptions &opts, MatrixBase< double > *M)
template<typename Real >
bool	ApproxEqual (const SpMatrix< Real > &A, const SpMatrix< Real > &B, Real tol=0.01)
template<typename Real >
void	AssertEqual (const SpMatrix< Real > &A, const SpMatrix< Real > &B, Real tol=0.01)
template<typename Real >
Real	SolveQuadraticProblem (const SpMatrix< Real > &H, const VectorBase< Real > &g, const SolverOptions &opts, VectorBase< Real > *x)
	Maximizes the auxiliary function using a numerically stable method. More...
template<typename Real >
void	UnitTestSparseVectorSum ()
template<typename Real >
void	UnitTestSparseVectorAddToVec ()
template<typename Real >
void	UnitTestSparseVectorMax ()
template<typename Real >
void	UnitTestSparseVectorVecSvec ()
template<typename Real >
void	UnitTestSparseMatrixSum ()
template<typename Real >
void	UnitTestSparseMatrixFrobeniusNorm ()
template<typename Real >
void	UnitTestSparseMatrixAddToMat ()
template<typename Real >
void	UnitTestSparseMatrixConstructor ()
template<typename Real >
void	UnitTestSparseMatrixTraceMatSmat ()
template<typename Real >
void	UnitTestMatrixAddMatSmat ()
template<typename Real >
void	UnitTestMatrixAddSmatMat ()
template<typename Real >
void	SparseMatrixUnitTest ()
template<typename Real >
Real	VecSvec (const VectorBase< Real > &vec, const SparseVector< Real > &svec)
template float	VecSvec (const VectorBase< float > &vec, const SparseVector< float > &svec)
template double	VecSvec (const VectorBase< double > &vec, const SparseVector< double > &svec)
template<typename Real >
Real	TraceMatSmat (const MatrixBase< Real > &A, const SparseMatrix< Real > &B, MatrixTransposeType trans)
template float	TraceMatSmat (const MatrixBase< float > &A, const SparseMatrix< float > &B, MatrixTransposeType trans)
template double	TraceMatSmat (const MatrixBase< double > &A, const SparseMatrix< double > &B, MatrixTransposeType trans)
void	AppendGeneralMatrixRows (const std::vector< const GeneralMatrix * > &src, GeneralMatrix *mat)
	Appends all the matrix rows of a list of GeneralMatrixes, to get a single GeneralMatrix. More...
void	FilterCompressedMatrixRows (const CompressedMatrix &in, const std::vector< bool > &keep_rows, Matrix< BaseFloat > *out)
	Outputs a Matrix<Real> containing only the rows r of "in" such that keep_rows[r] == true. More...
template<typename Real >
void	FilterMatrixRows (const Matrix< Real > &in, const std::vector< bool > &keep_rows, Matrix< Real > *out)
	Outputs a Matrix<Real> containing only the rows r of "in" such that keep_keep_rows[r] == true. More...
template void	FilterMatrixRows (const Matrix< float > &in, const std::vector< bool > &keep_rows, Matrix< float > *out)
template void	FilterMatrixRows (const Matrix< double > &in, const std::vector< bool > &keep_rows, Matrix< double > *out)
template<typename Real >
void	FilterSparseMatrixRows (const SparseMatrix< Real > &in, const std::vector< bool > &keep_rows, SparseMatrix< Real > *out)
	Outputs a SparseMatrix<Real> containing only the rows r of "in" such that keep_rows[r] == true. More...
template void	FilterSparseMatrixRows (const SparseMatrix< float > &in, const std::vector< bool > &keep_rows, SparseMatrix< float > *out)
template void	FilterSparseMatrixRows (const SparseMatrix< double > &in, const std::vector< bool > &keep_rows, SparseMatrix< double > *out)
void	FilterGeneralMatrixRows (const GeneralMatrix &in, const std::vector< bool > &keep_rows, GeneralMatrix *out)
	Outputs a GeneralMatrix containing only the rows r of "in" such that keep_rows[r] == true. More...
void	ExtractRowRangeWithPadding (const GeneralMatrix &in, int32 row_offset, int32 num_rows, GeneralMatrix *out)
	This function extracts a row-range of a GeneralMatrix and writes as a GeneralMatrix containing the same type of underlying matrix. More...
template<class CharT , class Traits >
void	swap (basic_filebuf< CharT, Traits > &x, basic_filebuf< CharT, Traits > &y)
template<class Int >
void	TestSetOfNumbers (bool binary)
template<class T >
int32	LevenshteinEditDistance (const std::vector< T > &a, const std::vector< T > &b)
template<class T >
int32	LevenshteinEditDistance (const std::vector< T > &ref, const std::vector< T > &hyp, int32 *ins, int32 *del, int32 *sub)
template<class T >
int32	LevenshteinAlignment (const std::vector< T > &a, const std::vector< T > &b, T eps_symbol, std::vector< std::pair< T, T > > *output)
void	TestEditDistance ()
void	TestEditDistanceString ()
void	TestEditDistance2 ()
void	TestEditDistance2String ()
void	TestLevenshteinAlignment ()
template<class Int , class T >
void	TestHashList ()
static bool	prefixp (const std::string &pfx, const std::string &str)
static std::string	cygprefix ("/cygdrive/")
static std::string	MapCygwinPathNoTmp (const std::string &filename)
std::string	MapCygwinPath (const std::string &filename)
static FILE *	CygwinCompatPopen (const char *command, const char *mode)
bool	ParseMatrixRangeSpecifier (const std::string &range, const int rows, const int cols, std::vector< int32 > *row_range, std::vector< int32 > *col_range)
bool	ExtractObjectRange (const GeneralMatrix &input, const std::string &range, GeneralMatrix *output)
	GeneralMatrix is always of type BaseFloat. More...
template<class Real >
bool	ExtractObjectRange (const CompressedMatrix &input, const std::string &range, Matrix< Real > *output)
	CompressedMatrix is always of the type BaseFloat but it is more efficient to provide template as it uses CompressedMatrix's own conversion to Matrix<Real> More...
template bool	ExtractObjectRange (const CompressedMatrix &, const std::string &, Matrix< float > *)
template bool	ExtractObjectRange (const CompressedMatrix &, const std::string &, Matrix< double > *)
template<class Real >
bool	ExtractObjectRange (const Matrix< Real > &input, const std::string &range, Matrix< Real > *output)
	The template is specialized with a version that actually does something, for types Matrix<float> and Matrix<double>. More...
template bool	ExtractObjectRange (const Matrix< double > &, const std::string &, Matrix< double > *)
template bool	ExtractObjectRange (const Matrix< float > &, const std::string &, Matrix< float > *)
template<class Real >
bool	ExtractObjectRange (const Vector< Real > &input, const std::string &range, Vector< Real > *output)
	The template is specialized types Vector<float> and Vector<double>. More...
template bool	ExtractObjectRange (const Vector< double > &, const std::string &, Vector< double > *)
template bool	ExtractObjectRange (const Vector< float > &, const std::string &, Vector< float > *)
bool	ExtractRangeSpecifier (const std::string &rxfilename_with_range, std::string *data_rxfilename, std::string *range)
template<class T >
bool	ExtractObjectRange (const T &input, const std::string &range, T *output)
	This templated function exists so that we can write .scp files with 'object ranges' specified: the canonical example is a [first:last] range of rows of a matrix, or [first-row:last-row,first-column,last-column] of a matrix. More...
void	UnitTestClassifyRxfilename ()
void	UnitTestClassifyWxfilename ()
void	UnitTestIoNew (bool binary)
void	UnitTestIoPipe (bool binary)
void	UnitTestIoStandard ()
void	UnitTestNativeFilename ()
std::string	PrintableRxfilename (const std::string &rxfilename)
	PrintableRxfilename turns the rxfilename into a more human-readable form for error reporting, i.e. More...
std::string	PrintableWxfilename (const std::string &wxfilename)
	PrintableWxfilename turns the wxfilename into a more human-readable form for error reporting, i.e. More...
OutputType	ClassifyWxfilename (const std::string &wxfilename)
	ClassifyWxfilename interprets filenames as follows: More...
InputType	ClassifyRxfilename (const std::string &rxfilename)
	ClassifyRxfilenames interprets filenames for reading as follows: More...
template<>
void	ReadKaldiObject (const std::string &filename, Matrix< float > *m)
template<>
void	ReadKaldiObject (const std::string &filename, Matrix< double > *m)
template<class C >
void	ReadKaldiObject (const std::string &filename, C *c)
template<class C >
void	WriteKaldiObject (const C &c, const std::string &filename, bool binary)
void	UnitTestReadScriptFile ()
void	UnitTestClassifyWspecifier ()
void	UnitTestClassifyRspecifier ()
void	UnitTestTableSequentialInt32 (bool binary)
void	UnitTestTableSequentialBool (bool binary)
void	UnitTestTableSequentialDouble (bool binary)
void	UnitTestTableSequentialDoubleBoth (bool binary, bool read_scp)
void	UnitTestTableSequentialInt32VectorBoth (bool binary, bool read_scp)
void	UnitTestTableSequentialInt32PairVectorBoth (bool binary, bool read_scp)
void	UnitTestTableSequentialInt32VectorVectorBoth (bool binary, bool read_scp)
void	UnitTestTableSequentialInt32Script (bool binary)
void	UnitTestTableSequentialDoubleMatrixBoth (bool binary, bool read_scp)
void	UnitTestTableSequentialBaseFloatVectorBoth (bool binary, bool read_scp)
template<class T >
void	RandomizeVector (std::vector< T > *v)
void	UnitTestTableRandomBothDouble (bool binary, bool read_scp, bool sorted, bool called_sorted, bool once)
void	UnitTestRangesMatrix (bool binary)
void	UnitTestTableRandomBothDoubleMatrix (bool binary, bool read_scp, bool sorted, bool called_sorted, bool once)
bool	ReadScriptFile (const std::string &rxfilename, bool warn, std::vector< std::pair< std::string, std::string > > *script_out)
bool	ReadScriptFile (std::istream &is, bool warn, std::vector< std::pair< std::string, std::string > > *script_out)
bool	WriteScriptFile (std::ostream &os, const std::vector< std::pair< std::string, std::string > > &script)
bool	WriteScriptFile (const std::string &wxfilename, const std::vector< std::pair< std::string, std::string > > &script)
WspecifierType	ClassifyWspecifier (const std::string &wspecifier, std::string *archive_wxfilename, std::string *script_wxfilename, WspecifierOptions *opts)
RspecifierType	ClassifyRspecifier (const std::string &rspecifier, std::string *rxfilename, RspecifierOptions *opts)
void	TestThreads ()
void	TestTaskSequencer ()
template<class C >
void	RunMultiThreaded (const C &c_in)
	Here, class C should inherit from MultiThreadable. More...
void	UnitTestParseOptions ()
static bool	MustBeQuoted (const std::string &str, ShellType st)
static std::string	QuoteAndEscape (const std::string &str, ShellType st)
template<class C >
void	ReadConfigFromFile (const std::string &config_filename, C *c)
	This template is provided for convenience in reading config classes from files; this is not the standard way to read configuration options, but may occasionally be needed. More...
template<class C1 , class C2 >
void	ReadConfigsFromFile (const std::string &conf, C1 *c1, C2 *c2)
	This variant of the template ReadConfigFromFile is for if you need to read two config classes from the same file. More...
bool	WriteIntegerVectorSimple (const std::string &wxfilename, const std::vector< int32 > &v)
	WriteToList attempts to write this list of integers, one per line, to the given file, in text format. More...
bool	ReadIntegerVectorSimple (const std::string &rxfilename, std::vector< int32 > *v)
	ReadFromList attempts to read this list of integers, one per line, from the given file, in text format. More...
bool	WriteIntegerVectorVectorSimple (const std::string &wxfilename, const std::vector< std::vector< int32 > > &list)
bool	ReadIntegerVectorVectorSimple (const std::string &rxfilename, std::vector< std::vector< int32 > > *list)
void	UnitTestSimpleOptions ()
template<typename T >
static bool	SetOptionImpl (const std::string &key, const T &value, std::map< std::string, T *> &some_map)
template<typename T >
static bool	GetOptionImpl (const std::string &key, T *value, std::map< std::string, T *> &some_map)
static void	TestIsSorted ()
static void	TestIsSortedAndUniq ()
static void	TestUniq ()
static void	TestSortAndUniq ()
void	TestCopySetToVector ()
void	TestCopyMapToVector ()
void	TestCopyMapKeysToVector ()
void	TestCopyMapValuesToVector ()
void	TestCopyMapKeysToSet ()
void	TestCopyMapValuesToSet ()
void	TestContainsNullPointers ()
void	TestReverseVector ()
void	TestMergePairVectorSumming ()
template<typename T >
void	SortAndUniq (std::vector< T > *vec)
	Sorts and uniq's (removes duplicates) from a vector. More...
template<typename T >
bool	IsSorted (const std::vector< T > &vec)
	Returns true if the vector is sorted. More...
template<typename T >
bool	IsSortedAndUniq (const std::vector< T > &vec)
	Returns true if the vector is sorted and contains each element only once. More...
template<typename T >
void	Uniq (std::vector< T > *vec)
	Removes duplicate elements from a sorted list. More...
template<class T >
void	CopySetToVector (const std::set< T > &s, std::vector< T > *v)
	Copies the elements of a set to a vector. More...
template<class T >
void	CopySetToVector (const unordered_set< T > &s, std::vector< T > *v)
template<class A , class B >
void	CopyMapToVector (const std::map< A, B > &m, std::vector< std::pair< A, B > > *v)
	Copies the (key, value) pairs in a map to a vector of pairs. More...
template<class A , class B >
void	CopyMapKeysToVector (const std::map< A, B > &m, std::vector< A > *v)
	Copies the keys in a map to a vector. More...
template<class A , class B >
void	CopyMapValuesToVector (const std::map< A, B > &m, std::vector< B > *v)
	Copies the values in a map to a vector. More...
template<class A , class B >
void	CopyMapKeysToSet (const std::map< A, B > &m, std::set< A > *s)
	Copies the keys in a map to a set. More...
template<class A , class B >
void	CopyMapValuesToSet (const std::map< A, B > &m, std::set< B > *s)
	Copies the values in a map to a set. More...
template<class A >
void	CopyVectorToSet (const std::vector< A > &v, std::set< A > *s)
	Copies the contents of a vector to a set. More...
template<class A >
void	DeletePointers (std::vector< A *> *v)
	Deletes any non-NULL pointers in the vector v, and sets the corresponding entries of v to NULL. More...
template<class A >
bool	ContainsNullPointers (const std::vector< A *> &v)
	Returns true if the vector of pointers contains NULL pointers. More...
template<typename A , typename B >
void	CopyVectorToVector (const std::vector< A > &vec_in, std::vector< B > *vec_out)
	Copies the contents a vector of one type to a vector of another type. More...
template<typename T >
void	ReverseVector (std::vector< T > *vec)
	Reverses the contents of a vector. More...
template<typename I , typename F >
void	MergePairVectorSumming (std::vector< std::pair< I, F > > *vec)
	For a vector of pair<I, F> where I is an integer and F a floating-point or integer type, this function sorts a vector of type vector<pair<I, F> > on the I value and then merges elements with equal I values, summing these over the F component and then removing any F component with zero value. More...
char	GetRandChar ()
char	GetRandDelim ()
void	TestSplitStringToVector ()
void	TestSplitStringToIntegers ()
void	TestSplitStringToFloats ()
void	TestConvertStringToInteger ()
template<class Real >
void	TestConvertStringToReal ()
template<class Real >
void	TestNan ()
template<class Real >
void	TestInf ()
std::string	TrimTmp (std::string s)
void	TestTrim ()
void	TestSplitStringOnFirstSpace ()
void	TestIsToken ()
void	TestIsLine ()
void	TestStringsApproxEqual ()
void	UnitTestConfigLineParse ()
void	UnitTestReadConfig ()
template<class F >
bool	SplitStringToFloats (const std::string &full, const char *delim, bool omit_empty_strings, std::vector< F > *out)
template bool	SplitStringToFloats (const std::string &full, const char *delim, bool omit_empty_strings, std::vector< float > *out)
template bool	SplitStringToFloats (const std::string &full, const char *delim, bool omit_empty_strings, std::vector< double > *out)
void	SplitStringToVector (const std::string &full, const char *delim, bool omit_empty_strings, std::vector< std::string > *out)
	Split a string using any of the single character delimiters. More...
void	JoinVectorToString (const std::vector< std::string > &vec_in, const char *delim, bool omit_empty_strings, std::string *str_out)
	Joins the elements of a vector of strings into a single string using "delim" as the delimiter. More...
void	Trim (std::string *str)
	Removes the beginning and trailing whitespaces from a string. More...
bool	IsToken (const std::string &token)
	Returns true if "token" is nonempty, and all characters are printable and whitespace-free. More...
void	SplitStringOnFirstSpace (const std::string &line, std::string *first, std::string *rest)
	Removes leading and trailing white space from the string, then splits on the first section of whitespace found (if present), putting the part before the whitespace in "first" and the rest in "rest". More...
bool	IsLine (const std::string &line)
	Returns true if "line" is free of characters and unprintable characters, and does not contain leading or trailing whitespace. More...
template<typename T >
bool	ConvertStringToReal (const std::string &str, T *out)
	ConvertStringToReal converts a string into either float or double and returns false if there was any kind of problem (i.e. More...
template bool	ConvertStringToReal (const std::string &str, float *out)
template bool	ConvertStringToReal (const std::string &str, double *out)
bool	StringsApproxEqualInternal (const char *a, const char *b, int32 decimal_places_tolerance, int32 places_into_number)
bool	StringsApproxEqual (const std::string &a, const std::string &b, int32 decimal_places_check=2)
	This function returns true when two text strings are approximately equal, and false when they are not. More...
void	ExpectOneOrTwoTokens (std::istream &is, bool binary, const std::string &token1, const std::string &token2)
	This function is like ExpectToken but for two tokens, and it will either accept token1 and then token2, or just token2. More...
bool	IsValidName (const std::string &name)
	Returns true if 'name' would be a valid name for a component or node in a nnet3Nnet. More...
void	ReadConfigLines (std::istream &is, std::vector< std::string > *lines)
	This function reads in a config file and *appends* its contents to a vector of lines; it is responsible for removing comments (anything after '#') and stripping out any lines that contain only whitespace after comment removal. More...
void	ParseConfigLines (const std::vector< std::string > &lines, std::vector< ConfigLine > *config_lines)
	This function converts config-lines from a simple sequence of strings as output by ReadConfigLines(), into a sequence of first-tokens and name-value pairs. More...
template<class I >
bool	SplitStringToIntegers (const std::string &full, const char *delim, bool omit_empty_strings, std::vector< I > *out)
	Split a string (e.g. More...
template<class Int >
bool	ConvertStringToInteger (const std::string &str, Int *out)
	Converts a string into an integer via strtoll and returns false if there was any kind of problem (i.e. More...
void	UnitTestOnlineCmvn ()
void	ComputePowerSpectrum (VectorBase< BaseFloat > *waveform)
void	ComputeDeltas (const DeltaFeaturesOptions &delta_opts, const MatrixBase< BaseFloat > &input_features, Matrix< BaseFloat > *output_features)
void	ComputeShiftedDeltas (const ShiftedDeltaFeaturesOptions &delta_opts, const MatrixBase< BaseFloat > &input_features, Matrix< BaseFloat > *output_features)
void	InitIdftBases (int32 n_bases, int32 dimension, Matrix< BaseFloat > *mat_out)
void	SpliceFrames (const MatrixBase< BaseFloat > &input_features, int32 left_context, int32 right_context, Matrix< BaseFloat > *output_features)
void	ReverseFrames (const MatrixBase< BaseFloat > &input_features, Matrix< BaseFloat > *output_features)
void	SlidingWindowCmnInternal (const SlidingWindowCmnOptions &opts, const MatrixBase< double > &input, MatrixBase< double > *output)
void	SlidingWindowCmn (const SlidingWindowCmnOptions &opts, const MatrixBase< BaseFloat > &input, MatrixBase< BaseFloat > *output)
	Applies sliding-window cepstral mean and/or variance normalization. More...
int64	FirstSampleOfFrame (int32 frame, const FrameExtractionOptions &opts)
int32	NumFrames (int64 num_samples, const FrameExtractionOptions &opts, bool flush=true)
	This function returns the number of frames that we can extract from a wave file with the given number of samples in it (assumed to have the same sampling rate as specified in 'opts'). More...
void	Dither (VectorBase< BaseFloat > *waveform, BaseFloat dither_value)
void	Preemphasize (VectorBase< BaseFloat > *waveform, BaseFloat preemph_coeff)
void	ProcessWindow (const FrameExtractionOptions &opts, const FeatureWindowFunction &window_function, VectorBase< BaseFloat > *window, BaseFloat *log_energy_pre_window=NULL)
	This function does all the windowing steps after actually extracting the windowed signal: depending on the configuration, it does dithering, dc offset removal, preemphasis, and multiplication by the windowing function. More...
void	ExtractWindow (int64 sample_offset, const VectorBase< BaseFloat > &wave, int32 f, const FrameExtractionOptions &opts, const FeatureWindowFunction &window_function, Vector< BaseFloat > *window, BaseFloat *log_energy_pre_window)
void	ComputeLifterCoeffs (BaseFloat Q, VectorBase< BaseFloat > *coeffs)
BaseFloat	Durbin (int n, const BaseFloat *pAC, BaseFloat *pLP, BaseFloat *pTmp)
void	Lpc2Cepstrum (int n, const BaseFloat *pLPC, BaseFloat *pCepst)
void	GetEqualLoudnessVector (const MelBanks &mel_banks, Vector< BaseFloat > *ans)
BaseFloat	ComputeLpc (const VectorBase< BaseFloat > &autocorr_in, Vector< BaseFloat > *lpc_out)
void	GetOutput (OnlineFeatureInterface *a, Matrix< BaseFloat > *output)
bool	RandomSplit (int32 wav_dim, std::vector< int32 > *piece_dim, int32 num_pieces, int32 trials=5)
void	TestOnlineMatrixCacheFeature ()
void	TestOnlineDeltaFeature ()
void	TestOnlineSpliceFrames ()
void	TestOnlineMfcc ()
void	TestOnlinePlp ()
void	TestOnlineTransform ()
void	TestOnlineAppendFeature ()
void	TestRecyclingVector ()
std::string	ConvertIntToString (const int &number)
bool	DirExist (const std::string &dirname)
static void	UnitTestSimple ()
static void	UnitTestSnipEdges ()
static void	UnitTestPieces ()
static void	UnitTestDelay ()
static void	UnitTestSearch ()
static void	UnitTestComputeGPE ()
static void	UnitTestKeele ()
static void	UnitTestPenaltyFactor ()
static void	UnitTestKeeleNccfBallast ()
static void	UnitTestPitchExtractionSpeed ()
static void	UnitTestPitchExtractorCompareKeele ()
void	UnitTestDiffSampleRate ()
void	UnitTestProcess ()
static void	UnitTestFeatNoKeele ()
static void	UnitTestFeatWithKeele ()
BaseFloat	NccfToPovFeature (BaseFloat n)
	This function processes the NCCF n to a POV feature f by applying the formula f = (1.0001 - n)^0.15 - 1.0 This is a nonlinear function designed to make the output reasonably Gaussian distributed. More...
BaseFloat	NccfToPov (BaseFloat n)
	This function processes the NCCF n to a reasonably accurate probability of voicing p by applying the formula: More...
void	ComputeCorrelation (const VectorBase< BaseFloat > &wave, int32 first_lag, int32 last_lag, int32 nccf_window_size, VectorBase< BaseFloat > *inner_prod, VectorBase< BaseFloat > *norm_prod)
	This function computes some dot products that are required while computing the NCCF. More...
void	ComputeNccf (const VectorBase< BaseFloat > &inner_prod, const VectorBase< BaseFloat > &norm_prod, BaseFloat nccf_ballast, VectorBase< BaseFloat > *nccf_vec)
	Computes the NCCF as a fraction of the numerator term (a dot product between two vectors) and a denominator term which equals sqrt(e1*e2 + nccf_ballast) where e1 and e2 are both dot-products of bits of the wave with themselves, and e1*e2 is supplied as "norm_prod". More...
void	SelectLags (const PitchExtractionOptions &opts, Vector< BaseFloat > *lags)
	This function selects the lags at which we measure the NCCF: we need to select lags from 1/max_f0 to 1/min_f0, in a geometric progression with ratio 1 + d. More...
void	ComputeLocalCost (const VectorBase< BaseFloat > &nccf_pitch, const VectorBase< BaseFloat > &lags, const PitchExtractionOptions &opts, VectorBase< BaseFloat > *local_cost)
	This function computes the local-cost for the Viterbi computation, see eq. More...
void	ComputeKaldiPitchFirstPass (const PitchExtractionOptions &opts, const VectorBase< BaseFloat > &wave, Matrix< BaseFloat > *output)
	This function is called from ComputeKaldiPitch when the user specifies opts.simulate_first_pass_online == true. More...
void	ComputeKaldiPitch (const PitchExtractionOptions &opts, const VectorBase< BaseFloat > &wave, Matrix< BaseFloat > *output)
	This function extracts (pitch, NCCF) per frame, using the pitch extraction method described in "A Pitch Extraction Algorithm Tuned for Automatic Speech Recognition", Pegah Ghahremani, Bagher BabaAli, Daniel Povey, Korbinian Riedhammer, Jan Trmal and Sanjeev Khudanpur, ICASSP 2014. More...
template<typename Real >
void	AppendVector (const VectorBase< Real > &src, Vector< Real > *dst)
void	ProcessPitch (const ProcessPitchOptions &opts, const MatrixBase< BaseFloat > &input, Matrix< BaseFloat > *output)
	This function processes the raw (NCCF, pitch) quantities computed by ComputeKaldiPitch, and processes them into features. More...
void	ComputeAndProcessKaldiPitch (const PitchExtractionOptions &pitch_opts, const ProcessPitchOptions &process_opts, const VectorBase< BaseFloat > &wave, Matrix< BaseFloat > *output)
	This function combines ComputeKaldiPitch and ProcessPitch. More...
void	ResampleWaveform (BaseFloat orig_freq, const VectorBase< BaseFloat > &wave, BaseFloat new_freq, Vector< BaseFloat > *new_wave)
	Downsample or upsample a waveform. More...
void	DownsampleWaveForm (BaseFloat orig_freq, const VectorBase< BaseFloat > &wave, BaseFloat new_freq, Vector< BaseFloat > *new_wave)
	This function is deprecated. More...
void	UnitTestFFTbasedBlockConvolution ()
void	UnitTestFFTbasedConvolution ()
void	ElementwiseProductOfFft (const Vector< BaseFloat > &a, Vector< BaseFloat > *b)
void	ConvolveSignals (const Vector< BaseFloat > &filter, Vector< BaseFloat > *signal)
void	FFTbasedConvolveSignals (const Vector< BaseFloat > &filter, Vector< BaseFloat > *signal)
void	FFTbasedBlockConvolveSignals (const Vector< BaseFloat > &filter, Vector< BaseFloat > *signal)
static void	WriteUint32 (std::ostream &os, int32 i)
static void	WriteUint16 (std::ostream &os, int16 i)
void	TestGenRandStats ()
void	TestBuildTree ()
void	TestTrivialTree ()
void	TestPossibleValues ()
void	TestConvertStats ()
void	TestSplitStatsByKey ()
void	TestFindAllKeys ()
void	TestDoTableSplit ()
void	TestClusterEventMapGetMappingAndRenumberEventMap ()
void	TestClusterEventMapGetMappingAndRenumberEventMap2 ()
void	TestClusterEventMap ()
void	TestClusterEventMapRestricted ()
void	TestShareEventMapLeaves ()
void	TestQuestionsInitRand ()
void	TestSplitDecisionTree ()
void	TestBuildTreeStatsIo (bool binary)
void	WriteBuildTreeStats (std::ostream &os, bool binary, const BuildTreeStatsType &stats)
	Writes BuildTreeStats object. This works even if pointers are NULL. More...
void	ReadBuildTreeStats (std::istream &is, bool binary, const Clusterable &example, BuildTreeStatsType *stats)
	Reads BuildTreeStats object. More...
bool	PossibleValues (EventKeyType key, const BuildTreeStatsType &stats, std::vector< EventValueType > *ans)
	Convenience function e.g. More...
static void	GetEventKeys (const EventType &vec, std::vector< EventKeyType > *keys)
void	FindAllKeys (const BuildTreeStatsType &stats, AllKeysType keys_type, std::vector< EventKeyType > *keys)
	FindAllKeys puts in *keys the (sorted, unique) list of all key identities in the stats. More...
EventMap *	DoTableSplit (const EventMap &orig, EventKeyType key, const BuildTreeStatsType &stats, int32 *num_leaves)
	DoTableSplit does a complete split on this key (e.g. More...
EventMap *	DoTableSplitMultiple (const EventMap &orig, const std::vector< EventKeyType > &keys, const BuildTreeStatsType &stats, int32 *num_leaves)
	DoTableSplitMultiple does a complete split on all the keys, in order from keys[0], keys[1] and so on. More...
void	SplitStatsByMap (const BuildTreeStatsType &stats_in, const EventMap &e, std::vector< BuildTreeStatsType > *stats_out)
	Splits stats according to the EventMap, indexing them at output by the leaf type. More...
void	SplitStatsByKey (const BuildTreeStatsType &stats_in, EventKeyType key, std::vector< BuildTreeStatsType > *stats_out)
	SplitStatsByKey splits stats up according to the value of a particular key, which must be always defined and nonnegative. More...
void	FilterStatsByKey (const BuildTreeStatsType &stats_in, EventKeyType key, std::vector< EventValueType > &values, bool include_if_present, BuildTreeStatsType *stats_out)
	FilterStatsByKey filters the stats according the value of a specified key. More...
Clusterable *	SumStats (const BuildTreeStatsType &stats_in)
	Sums stats, or returns NULL stats_in has no non-NULL stats. More...
BaseFloat	SumNormalizer (const BuildTreeStatsType &stats_in)
	Sums the normalizer [typically, data-count] over the stats. More...
BaseFloat	SumObjf (const BuildTreeStatsType &stats_in)
	Sums the objective function over the stats. More...
void	SumStatsVec (const std::vector< BuildTreeStatsType > &stats_in, std::vector< Clusterable * > *stats_out)
	Sum a vector of stats. More...
BaseFloat	ObjfGivenMap (const BuildTreeStatsType &stats_in, const EventMap &e)
	Cluster the stats given the event map return the total objf given those clusters. More...
BaseFloat	ComputeInitialSplit (const std::vector< Clusterable *> &summed_stats, const Questions &q_opts, EventKeyType key, std::vector< EventValueType > *yes_set)
BaseFloat	FindBestSplitForKey (const BuildTreeStatsType &stats, const Questions &qcfg, EventKeyType key, std::vector< EventValueType > *yes_set)
	FindBestSplitForKey is a function used in DoDecisionTreeSplit. More...
EventMap *	SplitDecisionTree (const EventMap &orig, const BuildTreeStatsType &stats, Questions &qcfg, BaseFloat thresh, int32 max_leaves, int32 *num_leaves, BaseFloat *objf_impr_out, BaseFloat *smallest_split_change_out)
	Does a decision-tree split at the leaves of an EventMap. More...
int	ClusterEventMapGetMapping (const EventMap &e_in, const BuildTreeStatsType &stats, BaseFloat thresh, std::vector< EventMap * > *mapping)
	"ClusterEventMapGetMapping" clusters the leaves of the EventMap, with "thresh" a delta-likelihood threshold to control how many leaves we combine (might be the same as the delta-like threshold used in splitting. More...
EventMap *	RenumberEventMap (const EventMap &e_in, int32 *num_leaves)
	RenumberEventMap [intended to be used after calling ClusterEventMap] renumbers an EventMap so its leaves are consecutive. More...
EventMap *	MapEventMapLeaves (const EventMap &e_in, const std::vector< int32 > &mapping)
	This function remaps the event-map leaves using this mapping, indexed by the number at leaf. More...
EventMap *	ClusterEventMap (const EventMap &e_in, const BuildTreeStatsType &stats, BaseFloat thresh, int32 *num_removed)
	This is as ClusterEventMapGetMapping but a more convenient interface that exposes less of the internals. More...
EventMap *	ShareEventMapLeaves (const EventMap &e_in, EventKeyType key, std::vector< std::vector< EventValueType > > &values, int32 *num_leaves)
	ShareEventMapLeaves performs a quite specific function that allows us to generate trees where, for a certain list of phones, and for all states in the phone, all the pdf's are shared. More...
void	DeleteBuildTreeStats (BuildTreeStatsType *stats)
	This frees the Clusterable* pointers in "stats", where non-NULL, and sets them to NULL. More...
EventMap *	GetToLengthMap (const BuildTreeStatsType &stats, int32 P, const std::vector< EventValueType > *phones, int32 default_length)
static int32	ClusterEventMapRestrictedHelper (const EventMap &e_in, const BuildTreeStatsType &stats, BaseFloat thresh, std::vector< EventKeyType > keys, std::vector< EventMap *> *leaf_mapping)
EventMap *	ClusterEventMapRestrictedByKeys (const EventMap &e_in, const BuildTreeStatsType &stats, BaseFloat thresh, const std::vector< EventKeyType > &keys, int32 *num_removed)
	This is as ClusterEventMap, but first splits the stats on the keys specified in "keys" (e.g. More...
EventMap *	ClusterEventMapRestrictedByMap (const EventMap &e_in, const BuildTreeStatsType &stats, BaseFloat thresh, const EventMap &e_restrict, int32 *num_removed)
	This version of ClusterEventMapRestricted restricts the clustering to only allow things that "e_restrict" maps to the same value to be clustered together. More...
EventMap *	ClusterEventMapToNClustersRestrictedByMap (const EventMap &e_in, const BuildTreeStatsType &stats, int32 num_clusters, const EventMap &e_restrict, int32 *num_removed)
	This version of ClusterEventMapRestrictedByMap clusters to get a specific number of clusters as specified by 'num_clusters'. More...
EventMap *	GetStubMap (int32 P, const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &phone2num_pdf_classes, const std::vector< bool > &share_roots, int32 *num_leaves)
	GetStubMap is used in tree-building functions to get the initial to-states map, before the decision-tree-building process. More...
bool	ConvertStats (int32 oldN, int32 oldP, int32 newN, int32 newP, BuildTreeStatsType *stats)
	Converts stats from a given context-window (N) and central-position (P) to a different N and P, by possibly reducing context. More...
EventMap *	TrivialTree (int32 *num_leaves)
	Returns a tree with just one node. More...
void	CreateRandomQuestions (const BuildTreeStatsType &stats, int32 num_quest, Questions *cfg_out)
	CreateRandomQuestions will initialize a Questions randomly, in a reasonable way [for testing purposes, or when hand-designed questions are not available]. More...
void	GenRandStats (int32 dim, int32 num_stats, int32 N, int32 P, const std::vector< int32 > &phone_ids, const std::vector< int32 > &hmm_lengths, const std::vector< bool > &is_ctx_dep, bool ensure_all_phones_covered, BuildTreeStatsType *stats_out)
	GenRandStats generates random statistics of the form used by BuildTree. More...
EventMap *	BuildTree (Questions &qopts, const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &phone2num_pdf_classes, const std::vector< bool > &share_roots, const std::vector< bool > &do_split, const BuildTreeStatsType &stats, BaseFloat thresh, int32 max_leaves, BaseFloat cluster_thresh, int32 P, bool round_num_leaves=true)
	BuildTree is the normal way to build a set of decision trees. More...
static void	ComputeTreeMapping (const EventMap &small_tree, const EventMap &big_tree, const BuildTreeStatsType &stats, std::vector< int32 > *leaf_map)
EventMap *	BuildTreeTwoLevel (Questions &qopts, const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &phone2num_pdf_classes, const std::vector< bool > &share_roots, const std::vector< bool > &do_split, const BuildTreeStatsType &stats, int32 max_leaves_first, int32 max_leaves_second, bool cluster_leaves, int32 P, std::vector< int32 > *leaf_map)
	BuildTreeTwoLevel builds a two-level tree, useful for example in building tied mixture systems with multiple codebooks. More...
void	ReadSymbolTableAsIntegers (std::string filename, bool include_eps, std::vector< int32 > *syms)
	included here because it's used in some tree-building calling code. More...
static void	RemoveDuplicates (std::vector< std::vector< int32 > > *vecs)
static void	ObtainSetsOfPhones (const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &assignments, const std::vector< int32 > &clust_assignments, int32 num_leaves, std::vector< std::vector< int32 > > *sets_out)
	ObtainSetsOfPhones is called by AutomaticallyObtainQuestions. More...
void	AutomaticallyObtainQuestions (BuildTreeStatsType &stats, const std::vector< std::vector< int32 > > &phone_sets_in, const std::vector< int32 > &all_pdf_classes_in, int32 P, std::vector< std::vector< int32 > > *questions_out)
	Outputs sets of phones that are reasonable for questions to ask in the tree-building algorithm. More...
void	KMeansClusterPhones (BuildTreeStatsType &stats, const std::vector< std::vector< int32 > > &phone_sets_in, const std::vector< int32 > &all_pdf_classes_in, int32 P, int32 num_classes, std::vector< std::vector< int32 > > *sets_out)
	This function clusters the phones (or some initially specified sets of phones) into sets of phones, using a k-means algorithm. More...
void	ReadRootsFile (std::istream &is, std::vector< std::vector< int32 > > *phone_sets, std::vector< bool > *is_shared_root, std::vector< bool > *is_split_root)
	Reads the roots file (throws on error). More...
static void	TestClusterUtils ()
static void	TestClusterUtilsVector ()
static void	TestObjfPlus ()
static void	TestObjfMinus ()
static void	TestDistance ()
static void	TestSumObjfAndSumNormalizer ()
static void	TestSum ()
static void	TestEnsureClusterableVectorNotNull ()
static void	TestAddToClusters ()
static void	TestAddToClustersOptimized ()
static void	TestClusterBottomUp ()
static void	TestRefineClusters ()
static void	TestClusterKMeans ()
static void	TestClusterKMeansVector ()
static void	TestTreeCluster ()
static void	TestClusterTopDown ()
BaseFloat	SumClusterableObjf (const std::vector< Clusterable * > &vec)
	Returns the total objective function after adding up all the statistics in the vector (pointers may be NULL). More...
BaseFloat	SumClusterableNormalizer (const std::vector< Clusterable * > &vec)
	Returns the total normalizer (usually count) of the cluster (pointers may be NULL). More...
Clusterable *	SumClusterable (const std::vector< Clusterable * > &vec)
	Sums stats (ptrs may be NULL). Returns NULL if no non-NULL stats present. More...
void	EnsureClusterableVectorNotNull (std::vector< Clusterable * > *stats)
	Fills in any (NULL) holes in "stats" vector, with empty stats, because certain algorithms require non-NULL stats. More...
void	AddToClusters (const std::vector< Clusterable * > &stats, const std::vector< int32 > &assignments, std::vector< Clusterable * > *clusters)
	Given stats and a vector "assignments" of the same size (that maps to cluster indices), sums the stats up into "clusters." It will add to any stats already present in "clusters" (although typically "clusters" will be empty when called), and it will extend with NULL pointers for any unseen indices. More...
void	AddToClustersOptimized (const std::vector< Clusterable * > &stats, const std::vector< int32 > &assignments, const Clusterable &total, std::vector< Clusterable * > *clusters)
	AddToClustersOptimized does the same as AddToClusters (it sums up the stats within each cluster, except it uses the sum of all the stats ("total") to optimize the computation for speed, if possible. More...
BaseFloat	ClusterBottomUp (const std::vector< Clusterable * > &points, BaseFloat thresh, int32 min_clust, std::vector< Clusterable * > *clusters_out, std::vector< int32 > *assignments_out)
	A bottom-up clustering algorithm. More...
bool	operator> (const CompBotClustElem &a, const CompBotClustElem &b)
BaseFloat	ClusterBottomUpCompartmentalized (const std::vector< std::vector< Clusterable * > > &points, BaseFloat thresh, int32 min_clust, std::vector< std::vector< Clusterable * > > *clusters_out, std::vector< std::vector< int32 > > *assignments_out)
	This is a bottom-up clustering where the points are pre-clustered in a set of compartments, such that only points in the same compartment are clustered together. More...
BaseFloat	RefineClusters (const std::vector< Clusterable * > &points, std::vector< Clusterable * > *clusters, std::vector< int32 > *assignments, RefineClustersOptions cfg=RefineClustersOptions())
	RefineClusters is mainly used internally by other clustering algorithms. More...
BaseFloat	ClusterKMeansOnce (const std::vector< Clusterable *> &points, int32 num_clust, std::vector< Clusterable *> *clusters_out, std::vector< int32 > *assignments_out, ClusterKMeansOptions &cfg)
	ClusterKMeansOnce is called internally by ClusterKMeans; it is equivalent to calling ClusterKMeans with cfg.num_tries == 1. More...
BaseFloat	ClusterKMeans (const std::vector< Clusterable * > &points, int32 num_clust, std::vector< Clusterable * > *clusters_out, std::vector< int32 > *assignments_out, ClusterKMeansOptions cfg=ClusterKMeansOptions())
	ClusterKMeans is a K-means-like clustering algorithm. More...
BaseFloat	TreeCluster (const std::vector< Clusterable * > &points, int32 max_clust, std::vector< Clusterable * > *clusters_out, std::vector< int32 > *assignments_out, std::vector< int32 > *clust_assignments_out, int32 *num_leaves_out, TreeClusterOptions cfg=TreeClusterOptions())
	TreeCluster is a top-down clustering algorithm, using a binary tree (not necessarily balanced). More...
BaseFloat	ClusterTopDown (const std::vector< Clusterable * > &points, int32 max_clust, std::vector< Clusterable * > *clusters_out, std::vector< int32 > *assignments_out, TreeClusterOptions cfg=TreeClusterOptions())
	A clustering algorithm that internally uses TreeCluster, but does not give you the information about the structure of the tree. More...
void	TestContextDep ()
void	TestMonophoneContextDependency ()
void	TestGenRandContextDependency ()
ContextDependency *	GenRandContextDependency (const std::vector< int32 > &phones, bool ensure_all_covered, std::vector< int32 > *num_pdf_classes)
	GenRandContextDependency is mainly of use for debugging. More...
ContextDependency *	GenRandContextDependencyLarge (const std::vector< int32 > &phones, int N, int P, bool ensure_all_covered, std::vector< int32 > *num_pdf_classes)
	GenRandContextDependencyLarge is like GenRandContextDependency but generates a larger tree with specified N and P for use in "one-time" larger-scale tests. More...
ContextDependency *	MonophoneContextDependency (const std::vector< int32 > &phones, const std::vector< int32 > &phone2num_pdf_classes)
ContextDependency *	MonophoneContextDependencyShared (const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &phone2num_pdf_classes)
void	TestEventMap ()
void	TestEventTypeIo (bool binary)
EventMap *	RandomEventMap (const std::vector< EventKeyType > &keys)
void	TestEventMapIo (bool binary)
void	TestEventMapPrune ()
void	TestEventMapMapValues ()
void	WriteEventType (std::ostream &os, bool binary, const EventType &evec)
void	ReadEventType (std::istream &is, bool binary, EventType *evec)
std::string	EventTypeToString (const EventType &evec)
static bool	IsLeafNode (const EventMap *e)
static bool	GetTreeStructureInternal (const EventMap &map, std::vector< const EventMap *> *nonleaf_nodes, std::map< const EventMap *, const EventMap *> *nonleaf_parents, std::vector< const EventMap *> *leaf_parents)
bool	GetTreeStructure (const EventMap &map, int32 *num_leaves, std::vector< int32 > *parents)
	This function gets the tree structure of the EventMap "map" in a convenient form. More...
std::pair< EventKeyType, EventValueType >	MakeEventPair (EventKeyType k, EventValueType v)
void	ClusterGaussiansToUbm (const AmDiagGmm &am, const Vector< BaseFloat > &state_occs, UbmClusteringOptions opts, DiagGmm *ubm_out)
	Clusters the Gaussians in an acoustic model to a single GMM with specified number of components. More...
void	InitRandomGmm (DiagGmm *gmm_in)
void	UnitTestDiagGmmGenerate ()
void	UnitTestDiagGmm ()
std::ostream &	operator<< (std::ostream &os, const kaldi::DiagGmm &gmm)
	ostream operator that calls DiagGMM::Write() More...
std::istream &	operator>> (std::istream &is, kaldi::DiagGmm &gmm)
	istream operator that calls DiagGMM::Read() More...
void	UnitTestEstimateMmieDiagGmm ()
static bool	EBWUpdateGaussian (BaseFloat D, GmmFlagsType flags, const VectorBase< double > &orig_mean, const VectorBase< double > &orig_var, const VectorBase< double > &x_stats, const VectorBase< double > &x2_stats, double occ, VectorBase< double > *mean, VectorBase< double > *var, double *auxf_impr)
void	UpdateEbwDiagGmm (const AccumDiagGmm &num_stats, const AccumDiagGmm &den_stats, GmmFlagsType flags, const EbwOptions &opts, DiagGmm *gmm, BaseFloat *auxf_change_out, BaseFloat *count_out, int32 *num_floored_out)
void	UpdateEbwWeightsDiagGmm (const AccumDiagGmm &num_stats, const AccumDiagGmm &den_stats, const EbwWeightOptions &opts, DiagGmm *gmm, BaseFloat *auxf_change_out, BaseFloat *count_out)
void	UpdateEbwAmDiagGmm (const AccumAmDiagGmm &num_stats, const AccumAmDiagGmm &den_stats, GmmFlagsType flags, const EbwOptions &opts, AmDiagGmm *am_gmm, BaseFloat *auxf_change_out, BaseFloat *count_out, int32 *num_floored_out)
void	UpdateEbwWeightsAmDiagGmm (const AccumAmDiagGmm &num_stats, const AccumAmDiagGmm &den_stats, const EbwWeightOptions &opts, AmDiagGmm *am_gmm, BaseFloat *auxf_change_out, BaseFloat *count_out)
void	IsmoothStatsDiagGmm (const AccumDiagGmm &src_stats, double tau, AccumDiagGmm *dst_stats)
	I-Smooth the stats. src_stats and dst_stats do not have to be different. More...
void	DiagGmmToStats (const DiagGmm &gmm, GmmFlagsType flags, double state_occ, AccumDiagGmm *dst_stats)
	Creates stats from the GMM. Resizes them as needed. More...
void	IsmoothStatsAmDiagGmm (const AccumAmDiagGmm &src_stats, double tau, AccumAmDiagGmm *dst_stats)
	Smooth "dst_stats" with "src_stats". More...
void	IsmoothStatsAmDiagGmmFromModel (const AmDiagGmm &src_model, double tau, AccumAmDiagGmm *dst_stats)
	This version of the I-smoothing function takes a model as input. More...
std::ostream &	operator<< (std::ostream &rOut, const kaldi::FullGmm &gmm)
	ostream operator that calls FullGmm::Write() More...
std::istream &	operator>> (std::istream &rIn, kaldi::FullGmm &gmm)
	istream operator that calls FullGmm::Read() More...
void	GetSingleStatsDerivative (double ml_count, double ml_x_stats, double ml_x2_stats, double disc_count, double disc_x_stats, double disc_x2_stats, double model_mean, double model_var, BaseFloat min_variance, double *ml_x_stats_deriv, double *ml_x2_stats_deriv)
void	GetStatsDerivative (const DiagGmm &gmm, const AccumDiagGmm &num_acc, const AccumDiagGmm &den_acc, const AccumDiagGmm &ml_acc, BaseFloat min_variance, BaseFloat min_gaussian_occupancy, AccumDiagGmm *out_accs)
void	GetStatsDerivative (const AmDiagGmm &gmm, const AccumAmDiagGmm &num_accs, const AccumAmDiagGmm &den_accs, const AccumAmDiagGmm &ml_accs, BaseFloat min_variance, BaseFloat min_gaussian_occupancy, AccumAmDiagGmm *out_accs)
void	DoRescalingUpdate (const AccumDiagGmm &old_ml_acc, const AccumDiagGmm &new_ml_acc, BaseFloat min_variance, BaseFloat min_gaussian_occupancy, DiagGmm *gmm, double *tot_count, double *tot_divergence)
void	DoRescalingUpdate (const AccumAmDiagGmm &old_ml_accs, const AccumAmDiagGmm &new_ml_accs, BaseFloat min_variance, BaseFloat min_gaussian_occupancy, AmDiagGmm *am_gmm)
void	ResizeModel (int32 dim, AmDiagGmm *am_gmm)
void	MleAmDiagGmmUpdate (const MleDiagGmmOptions &config, const AccumAmDiagGmm &amdiaggmm_acc, GmmFlagsType flags, AmDiagGmm *am_gmm, BaseFloat *obj_change_out, BaseFloat *count_out)
	for computing the maximum-likelihood estimates of the parameters of an acoustic model that uses diagonal Gaussian mixture models as emission densities. More...
void	MapAmDiagGmmUpdate (const MapDiagGmmOptions &config, const AccumAmDiagGmm &diag_gmm_acc, GmmFlagsType flags, AmDiagGmm *gmm, BaseFloat *obj_change_out, BaseFloat *count_out)
	Maximum A Posteriori update. More...
BaseFloat	MlObjective (const DiagGmm &gmm, const AccumDiagGmm &diaggmm_acc)
	Calc using the DiagGMM exponential form. More...
void	MleDiagGmmUpdate (const MleDiagGmmOptions &config, const AccumDiagGmm &diag_gmm_acc, GmmFlagsType flags, DiagGmm *gmm, BaseFloat *obj_change_out, BaseFloat *count_out, int32 *floored_elements_out=NULL, int32 *floored_gauss_out=NULL, int32 *removed_gauss_out=NULL)
	for computing the maximum-likelihood estimates of the parameters of a Gaussian mixture model. More...
void	MapDiagGmmUpdate (const MapDiagGmmOptions &config, const AccumDiagGmm &diag_gmm_acc, GmmFlagsType flags, DiagGmm *gmm, BaseFloat *obj_change_out, BaseFloat *count_out)
	Maximum A Posteriori estimation of the model. More...
GmmFlagsType	AugmentGmmFlags (GmmFlagsType f)
	Returns "augmented" version of flags: e.g. More...
BaseFloat	MlObjective (const FullGmm &gmm, const AccumFullGmm &fullgmm_acc)
	Calc using the DiagGMM exponential form. More...
void	MleFullGmmUpdate (const MleFullGmmOptions &config, const AccumFullGmm &fullgmm_acc, GmmFlagsType flags, FullGmm *gmm, BaseFloat *obj_change_out, BaseFloat *count_out)
	for computing the maximum-likelihood estimates of the parameters of a Gaussian mixture model. More...
GmmFlagsType	StringToGmmFlags (std::string str)
	Convert string which is some subset of "mSwa" to flags. More...
std::string	GmmFlagsToString (GmmFlagsType gmm_flags)
	Convert GMM flags to string. More...
SgmmUpdateFlagsType	StringToSgmmUpdateFlags (std::string str)
SgmmUpdateFlagsType	StringToSgmmWriteFlags (std::string str)
void	GetSplitTargets (const Vector< BaseFloat > &state_occs, int32 target_components, BaseFloat power, BaseFloat min_count, std::vector< int32 > *targets)
	Get Gaussian-mixture or substate-mixture splitting targets, according to a power rule (e.g. More...
static BaseFloat	CalBasisFmllrStepSize (const AffineXformStats &spk_stats, const Matrix< BaseFloat > &spk_stats_tmp_K, const std::vector< SpMatrix< BaseFloat > > &spk_stats_tmp_G, const Matrix< BaseFloat > &delta, const Matrix< BaseFloat > &A, const Matrix< BaseFloat > &S, int32 max_iters)
	This function takes the step direction (delta) of fMLLR matrix as argument, and optimize step size using Newton's method. More...
void	InitCmvnStats (int32 dim, Matrix< double > *stats)
	This function initializes the matrix to dimension 2 by (dim+1); 1st "dim" elements of 1st row are mean stats, 1st "dim" elements of 2nd row are var stats, last element of 1st row is count, last element of 2nd row is zero. More...
void	AccCmvnStats (const VectorBase< BaseFloat > &feat, BaseFloat weight, MatrixBase< double > *stats)
	Accumulation from a single frame (weighted). More...
void	AccCmvnStats (const MatrixBase< BaseFloat > &feats, const VectorBase< BaseFloat > *weights, MatrixBase< double > *stats)
	Accumulation from a feature file (possibly weighted– useful in excluding silence). More...
void	ApplyCmvn (const MatrixBase< double > &stats, bool norm_vars, MatrixBase< BaseFloat > *feats)
	Apply cepstral mean and variance normalization to a matrix of features. More...
void	ApplyCmvnReverse (const MatrixBase< double > &stats, bool norm_vars, MatrixBase< BaseFloat > *feats)
	This is as ApplyCmvn, but does so in the reverse sense, i.e. More...
void	FakeStatsForSomeDims (const std::vector< int32 > &dims, MatrixBase< double > *stats)
	Modify the stats so that for some dimensions (specified in "dims"), we replace them with "fake" stats that have zero mean and unit variance; this is done to disable CMVN for those dimensions. More...
static void	ComputeGconsts (const VectorBase< BaseFloat > &weights, const MatrixBase< BaseFloat > &means, const MatrixBase< BaseFloat > &inv_vars, VectorBase< BaseFloat > *gconsts_out)
void	UnitTestFmllrDiagGmm ()
void	UnitTestFmllrDiagGmmDiagonal ()
void	UnitTestFmllrDiagGmmOffset ()
BaseFloat	ComputeFmllrMatrixDiagGmm (const MatrixBase< BaseFloat > &in_xform, const AffineXformStats &stats, std::string fmllr_type, int32 num_iters, MatrixBase< BaseFloat > *out_xform)
	This function internally calls ComputeFmllrMatrixDiagGmm{Full, Diagonal, Offset}, depending on "fmllr_type". More...
void	FmllrInnerUpdate (SpMatrix< double > &inv_G, VectorBase< double > &k, double beta, int32 row, MatrixBase< double > *transform)
	This function does one row of the inner-loop fMLLR transform update. More...
BaseFloat	ComputeFmllrMatrixDiagGmmFull (const MatrixBase< BaseFloat > &in_xform, const AffineXformStats &stats, int32 num_iters, MatrixBase< BaseFloat > *out_xform)
	Updates the FMLLR matrix using Mark Gales' row-by-row update. More...
BaseFloat	ComputeFmllrMatrixDiagGmmDiagonal (const MatrixBase< BaseFloat > &in_xform, const AffineXformStats &stats, MatrixBase< BaseFloat > *out_xform)
	This does diagonal fMLLR (i.e. More...
BaseFloat	ComputeFmllrMatrixDiagGmmOffset (const MatrixBase< BaseFloat > &in_xform, const AffineXformStats &stats, MatrixBase< BaseFloat > *out_xform)
	This does offset-only fMLLR, i.e. it only estimates an offset. More...
void	ApplyFeatureTransformToStats (const MatrixBase< BaseFloat > &xform, AffineXformStats *stats)
	This function applies a feature-level transform to stats (useful for certain techniques based on fMLLR). More...
void	ApplyModelTransformToStats (const MatrixBase< BaseFloat > &xform, AffineXformStats *stats)
	ApplyModelTransformToStats takes a transform "xform", which must be diagonal (i.e. More...
float	FmllrAuxFuncDiagGmm (const MatrixBase< float > &xform, const AffineXformStats &stats)
	Returns the (diagonal-GMM) FMLLR auxiliary function value given the transform and the stats. More...
double	FmllrAuxFuncDiagGmm (const MatrixBase< double > &xform, const AffineXformStats &stats)
BaseFloat	FmllrAuxfGradient (const MatrixBase< BaseFloat > &xform, const AffineXformStats &stats, MatrixBase< BaseFloat > *grad_out)
	Returns the (diagonal-GMM) FMLLR auxiliary function value given the transform and the stats. More...
void	InitFmllr (int32 dim, Matrix< BaseFloat > *out_fmllr)
BaseFloat	ComputeFmllrDiagGmm (const FmllrDiagGmmAccs &accs, const FmllrOptions &opts, Matrix< BaseFloat > *out_fmllr, BaseFloat *logdet)
BaseFloat	ComputeFmllrLogDet (const Matrix< BaseFloat > &fmllr_mat)
BaseFloat	ComputeFmllrMatrixDiagGmmDiagonal2 (const MatrixBase< BaseFloat > &in_xform, const AffineXformStats &stats, MatrixBase< BaseFloat > *out_xform)
void	UnitTestFmllrRaw (bool use_offset)
void	GetFeatDeriv (const DiagGmm &gmm, const Matrix< BaseFloat > &feats, Matrix< BaseFloat > *deriv)
BaseFloat	GetGmmLike (const DiagGmm &gmm, const Matrix< BaseFloat > &feats)
void	TestFmpe ()
BaseFloat	ComputeAmGmmFeatureDeriv (const AmDiagGmm &am_gmm, const TransitionModel &trans_model, const Posterior &posterior, const MatrixBase< BaseFloat > &features, Matrix< BaseFloat > *direct_deriv, const AccumAmDiagGmm *model_diff=NULL, Matrix< BaseFloat > *indirect_deriv=NULL)
	Computes derivatives of the likelihood of these states (weighted), w.r.t. More...
static bool	GetActiveParents (int32 node, const vector< int32 > &parents, const vector< bool > &is_active, vector< int32 > *active_parents_out)
static void	RandFullCova (Matrix< BaseFloat > *matrix)
static void	generate_features (cova_type covariance_type, size_t n_gaussians, size_t dim, Matrix< BaseFloat > &trans_mat, size_t frames_per_gaussian, std::vector< Vector< BaseFloat > *> &train_feats, std::vector< Vector< BaseFloat > *> &adapt_feats)
void	UnitTestRegtreeFmllrDiagGmm (cova_type feature_type, size_t max_bclass)
static void	ComputeMllrMatrix (const Matrix< double > &K, const vector< SpMatrix< double > > &G, Matrix< BaseFloat > *out)
static BaseFloat	MllrAuxFunction (const Matrix< BaseFloat > &xform, const AffineXformStats &stats)
bool	ComposeTransforms (const Matrix< BaseFloat > &a, const Matrix< BaseFloat > &b, bool b_is_affine, Matrix< BaseFloat > *c)
void	ApplyAffineTransform (const MatrixBase< BaseFloat > &xform, VectorBase< BaseFloat > *vec)
	Applies the affine transform 'xform' to the vector 'vec' and overwrites the contents of 'vec'. More...
TransitionModel *	GenRandTransitionModel (ContextDependency **ctx_dep_out)
HmmTopology	GetDefaultTopology (const std::vector< int32 > &phones)
	This function returns a HmmTopology object giving a normal 3-state topology, covering all phones in the list "phones". More...
HmmTopology	GenRandTopology (const std::vector< int32 > &phones, const std::vector< int32 > &num_pdf_classes)
	This method of generating an arbitrary HmmTopology object allows you to specify the number of pdf-classes for each phone separately. More...
HmmTopology	GenRandTopology ()
	This version of GenRandTopology() generates the phone list and number of pdf classes randomly. More...
void	GeneratePathThroughHmm (const HmmTopology &topology, bool reorder, int32 phone, std::vector< std::pair< int32, int32 > > *path)
	This function generates a random path through the HMM for the given phone. More...
void	GenerateRandomAlignment (const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, bool reorder, const std::vector< int32 > &phone_sequence, std::vector< int32 > *alignment)
	For use in test code, this function generates an alignment (a sequence of transition-ids) corresponding to a given phone sequence. More...
void	TestHmmTopology ()
void	TestConvertPhnxToProns ()
void	TestAccumulateTreeStatsOptions ()
void	TestSplitToPhones ()
void	TestConvertAlignment ()
fst::VectorFst< fst::StdArc > *	GetHmmAsFsa (std::vector< int32 > context_window, const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, const HTransducerConfig &config, HmmCacheType *cache=NULL)
	Called by GetHTransducer() and probably will not need to be called directly; it creates and returns the FST corresponding to the phone. More...
fst::VectorFst< fst::StdArc > *	GetHmmAsFsaSimple (std::vector< int32 > context_window, const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, BaseFloat prob_scale)
	Included mainly as a form of documentation, not used in any other code currently. More...
static fst::VectorFst< fst::StdArc > *	MakeTrivialAcceptor (int32 label)
	This utility function, used in GetHTransducer(), creates an FSA (finite state acceptor, i.e. More...
fst::VectorFst< fst::StdArc > *	GetHTransducer (const std::vector< std::vector< int32 > > &ilabel_info, const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, const HTransducerConfig &config, std::vector< int32 > *disambig_syms_left)
	Returns the H tranducer; result owned by caller. More...
void	GetIlabelMapping (const std::vector< std::vector< int32 > > &ilabel_info_old, const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, std::vector< int32 > *old2new_map)
	GetIlabelMapping produces a mapping that's similar to HTK's logical-to-physical model mapping (i.e. More...
fst::VectorFst< fst::StdArc > *	GetPdfToTransitionIdTransducer (const TransitionModel &trans_model)
	Returns a transducer from pdfs plus one (input) to transition-ids (output). More...
static void	AddSelfLoopsReorder (const TransitionModel &trans_model, const std::vector< int32 > &disambig_syms, BaseFloat self_loop_scale, bool check_no_self_loops, fst::VectorFst< fst::StdArc > *fst)
static void	AddSelfLoopsNoReorder (const TransitionModel &trans_model, const std::vector< int32 > &disambig_syms, BaseFloat self_loop_scale, bool check_no_self_loops, fst::VectorFst< fst::StdArc > *fst)
void	AddSelfLoops (const TransitionModel &trans_model, const std::vector< int32 > &disambig_syms, BaseFloat self_loop_scale, bool reorder, bool check_no_self_loops, fst::VectorFst< fst::StdArc > *fst)
	For context, see AddSelfLoops(). More...
static bool	IsReordered (const TransitionModel &trans_model, const std::vector< int32 > &alignment)
static bool	SplitToPhonesInternal (const TransitionModel &trans_model, const std::vector< int32 > &alignment, bool reordered, std::vector< std::vector< int32 > > *split_output)
bool	SplitToPhones (const TransitionModel &trans_model, const std::vector< int32 > &alignment, std::vector< std::vector< int32 > > *split_alignment)
	SplitToPhones splits up the TransitionIds in "alignment" into their individual phones (one vector per instance of a phone). More...
static void	ConvertAlignmentForPhone (const TransitionModel &old_trans_model, const TransitionModel &new_trans_model, const ContextDependencyInterface &new_ctx_dep, const std::vector< int32 > &old_phone_alignment, const std::vector< int32 > &new_phone_window, bool old_is_reordered, bool new_is_reordered, std::vector< int32 > *new_phone_alignment)
	This function is used internally inside ConvertAlignment; it converts the alignment for a single phone. More...
static bool	ComputeNewPhoneLengths (const HmmTopology &topology, const std::vector< int32 > &mapped_phones, const std::vector< int32 > &old_lengths, int32 conversion_shift, int32 subsample_factor, std::vector< int32 > *new_lengths)
	This function, called from ConvertAlignmentInternal(), works out suitable new lengths of phones in the case where subsample_factor != 1. More...
static bool	ConvertAlignmentInternal (const TransitionModel &old_trans_model, const TransitionModel &new_trans_model, const ContextDependencyInterface &new_ctx_dep, const std::vector< int32 > &old_alignment, int32 conversion_shift, int32 subsample_factor, bool new_is_reordered, const std::vector< int32 > *phone_map, std::vector< int32 > *new_alignment)
	This function is the same as 'ConvertAligment', but instead of the 'repeat_frames' option it supports the 'conversion_shift' option; see the documentation of ComputeNewPhoneLengths() for what 'conversion_shift' is for. More...
bool	ConvertAlignment (const TransitionModel &old_trans_model, const TransitionModel &new_trans_model, const ContextDependencyInterface &new_ctx_dep, const std::vector< int32 > &old_alignment, int32 subsample_factor, bool repeat_frames, bool reorder, const std::vector< int32 > *phone_map, std::vector< int32 > *new_alignment)
	ConvertAlignment converts an alignment that was created using one model, to another model. More...
static BaseFloat	GetScaledTransitionLogProb (const TransitionModel &trans_model, int32 trans_id, BaseFloat transition_scale, BaseFloat self_loop_scale)
void	AddTransitionProbs (const TransitionModel &trans_model, const std::vector< int32 > &disambig_syms, BaseFloat transition_scale, BaseFloat self_loop_scale, fst::VectorFst< fst::StdArc > *fst)
	Adds transition-probs, with the supplied scales (see Scaling of transition and acoustic probabilities), to the graph. More...
void	AddTransitionProbs (const TransitionModel &trans_model, BaseFloat transition_scale, BaseFloat self_loop_scale, Lattice *lat)
	This is as AddSelfLoops(), but operates on a Lattice, where it affects the graph part of the weight (the first element of the pair). More...
bool	ConvertPhnxToProns (const std::vector< int32 > &phnx, const std::vector< int32 > &words, int32 word_start_sym, int32 word_end_sym, std::vector< std::vector< int32 > > *prons)
void	GetRandomAlignmentForPhone (const ContextDependencyInterface &ctx_dep, const TransitionModel &trans_model, const std::vector< int32 > &phone_window, std::vector< int32 > *alignment)
void	ChangeReorderingOfAlignment (const TransitionModel &trans_model, std::vector< int32 > *alignment)
void	GetPdfToPhonesMap (const TransitionModel &trans_model, std::vector< std::set< int32 > > *pdf2phones)
void	ConvertTransitionIdsToPdfs (const TransitionModel &trans_model, const std::vector< int32 > &disambig_syms, fst::VectorFst< fst::StdArc > *fst)
	Converts all transition-ids in the FST to pdfs plus one. More...
void	TestVectorToPosteriorEntry ()
void	TestPosteriorIo ()
void	WritePosterior (std::ostream &os, bool binary, const Posterior &post)
	stand-alone function for writing a Posterior. More...
void	ReadPosterior (std::istream &os, bool binary, Posterior *post)
	stand-alone function for reading a Posterior. More...
void	ScalePosterior (BaseFloat scale, Posterior *post)
	Scales the BaseFloat (weight) element in the posterior entries. More...
BaseFloat	TotalPosterior (const Posterior &post)
	Returns the total of all the weights in "post". More...
bool	PosteriorEntriesAreDisjoint (const std::vector< std::pair< int32, BaseFloat > > &post_elem1, const std::vector< std::pair< int32, BaseFloat > > &post_elem2)
	Returns true if the two lists of pairs have no common .first element. More...
int32	MergePosteriors (const Posterior &post1, const Posterior &post2, bool merge, bool drop_frames, Posterior *post)
	Merge two sets of posteriors, which must have the same length. More...
void	AlignmentToPosterior (const std::vector< int32 > &ali, Posterior *post)
	Convert an alignment to a posterior (with a scale of 1.0 on each entry). More...
void	SortPosteriorByPdfs (const TransitionModel &tmodel, Posterior *post)
	Sorts posterior entries so that transition-ids with same pdf-id are next to each other. More...
void	ConvertPosteriorToPdfs (const TransitionModel &tmodel, const Posterior &post_in, Posterior *post_out)
	Converts a posterior over transition-ids to be a posterior over pdf-ids. More...
void	ConvertPosteriorToPhones (const TransitionModel &tmodel, const Posterior &post_in, Posterior *post_out)
	Converts a posterior over transition-ids to be a posterior over phones. More...
void	WeightSilencePost (const TransitionModel &trans_model, const ConstIntegerSet< int32 > &silence_set, BaseFloat silence_scale, Posterior *post)
	Weight any silence phones in the posterior (i.e. More...
void	WeightSilencePostDistributed (const TransitionModel &trans_model, const ConstIntegerSet< int32 > &silence_set, BaseFloat silence_scale, Posterior *post)
	This is similar to WeightSilencePost, except that on each frame it works out the amount by which the overall posterior would be reduced, and scales down everything on that frame by the same amount. More...
static BaseFloat	GetTotalPosterior (const std::vector< std::pair< int32, BaseFloat > > &post_entry)
BaseFloat	VectorToPosteriorEntry (const VectorBase< BaseFloat > &log_likes, int32 num_gselect, BaseFloat min_post, std::vector< std::pair< int32, BaseFloat > > *post_entry)
	Given a vector of log-likelihoods (typically of Gaussians in a GMM but could be of pdf-ids), a number gselect >= 1 and a minimum posterior 0 <= min_post < 1, it gets the posterior for each element of log-likes by applying Softmax(), then prunes the posteriors using "gselect" and "min_post" (keeping at least one), and outputs the result into "post_entry", sorted from greatest to least posterior. More...
template<typename Real >
void	PosteriorToMatrix (const Posterior &post, const int32 post_dim, Matrix< Real > *mat)
	This converts a Posterior to a Matrix. More...
template void	PosteriorToMatrix< float > (const Posterior &post, const int32 post_dim, Matrix< float > *mat)
template void	PosteriorToMatrix< double > (const Posterior &post, const int32 post_dim, Matrix< double > *mat)
template<typename Real >
void	PosteriorToPdfMatrix (const Posterior &post, const TransitionModel &model, Matrix< Real > *mat)
	This converts a Posterior to a Matrix. More...
template void	PosteriorToPdfMatrix< float > (const Posterior &post, const TransitionModel &model, Matrix< float > *mat)
template void	PosteriorToPdfMatrix< double > (const Posterior &post, const TransitionModel &model, Matrix< double > *mat)
void	TestTransitionModel ()
bool	GetPdfsForPhones (const TransitionModel &trans_model, const std::vector< int32 > &phones, std::vector< int32 > *pdfs)
	Works out which pdfs might correspond to the given phones. More...
bool	GetPhonesForPdfs (const TransitionModel &trans_model, const std::vector< int32 > &pdfs, std::vector< int32 > *phones)
	Works out which phones might correspond to the given pdfs. More...
static int32	MapPhone (const std::vector< int32 > &phone_map, int32 phone)
void	TrimTrailingWhitespace (std::string *str)
static fst::StdVectorFst *	CreateGenFst (bool seps, const fst::SymbolTable *pst)
ArpaLmCompiler *	Compile (bool seps, const std::string &infile)
fst::StdArc::StateId	AddToChainFsa (fst::StdMutableFst *fst, fst::StdArc::StateId last_state, int64 symbol)
void	AddSelfLoops (fst::StdMutableFst *fst)
bool	CoverageTest (bool seps, const std::string &infile)
bool	ScoringTest (bool seps, const std::string &infile, const std::string &sentence, float expected)
bool	ThrowsExceptionTest (bool seps, const std::string &infile)
bool	BuildConstArpaLm (const ArpaParseOptions &options, const std::string &arpa_rxfilename, const std::string &const_arpa_wxfilename)
template<typename FST >
bool	DecodeUtteranceLatticeIncremental (LatticeIncrementalDecoderTpl< FST > &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignments_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
	TODO. More...
template<typename FST >
bool	DecodeUtteranceLatticeFaster (LatticeFasterDecoderTpl< FST > &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignments_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
	This function DecodeUtteranceLatticeFaster is used in several decoders, and we have moved it here. More...
template bool	DecodeUtteranceLatticeIncremental (LatticeIncrementalDecoderTpl< fst::Fst< fst::StdArc > > &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignment_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
template bool	DecodeUtteranceLatticeIncremental (LatticeIncrementalDecoderTpl< fst::GrammarFst > &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignment_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
template bool	DecodeUtteranceLatticeFaster (LatticeFasterDecoderTpl< fst::Fst< fst::StdArc > > &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignment_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
template bool	DecodeUtteranceLatticeFaster (LatticeFasterDecoderTpl< fst::GrammarFst > &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignment_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
bool	DecodeUtteranceLatticeSimple (LatticeSimpleDecoder &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignment_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
void	ModifyGraphForCarefulAlignment (fst::VectorFst< fst::StdArc > *fst)
	This function modifies the decoding graph for what we call "careful alignment". More...
void	AlignUtteranceWrapper (const AlignConfig &config, const std::string &utt, BaseFloat acoustic_scale, fst::VectorFst< fst::StdArc > *fst, DecodableInterface *decodable, Int32VectorWriter *alignment_writer, BaseFloatWriter *scores_writer, int32 *num_done, int32 *num_error, int32 *num_retried, double *tot_like, int64 *frame_count, BaseFloatVectorWriter *per_frame_acwt_writer=NULL)
	AlignUtteranceWapper is a wrapper for alignment code used in training, that is called from many different binaries, e.g. More...
static void	AddCompactLatticeArcToLattice (const CompactLatticeArc &clat_arc, LatticeArc::StateId src_state, Lattice *lat)
static int32	TotalNumArcs (const CompactLattice &clat)
void	ComposeCompactLatticePruned (const ComposeLatticePrunedOptions &opts, const CompactLattice &clat, fst::DeterministicOnDemandFst< fst::StdArc > *det_fst, CompactLattice *composed_clat)
	Does pruned composition of a lattice 'clat' with a DeterministicOnDemandFst 'det_fst'; implements LM rescoring. More...
BaseFloat	SentenceLevelConfidence (const CompactLattice &clat, int32 *num_paths, std::vector< int32 > *best_sentence, std::vector< int32 > *second_best_sentence)
	Caution: this function is not the only way to get confidences in Kaldi. More...
BaseFloat	SentenceLevelConfidence (const Lattice &lat, int32 *num_paths, std::vector< int32 > *best_sentence, std::vector< int32 > *second_best_sentence)
	This version of SentenceLevelConfidence takes as input a state-level lattice. More...
CompactLattice *	RandCompactLattice ()
Lattice *	RandLattice ()
void	TestCompactLatticeTable (bool binary)
void	TestCompactLatticeTableCross (bool binary)
void	TestLatticeTable (bool binary)
void	TestLatticeTableCross (bool binary)
template<class OrigWeightType >
CompactLattice *	ConvertToCompactLattice (fst::VectorFst< OrigWeightType > *ifst)
	Converts lattice types if necessary, deleting its input. More...
template<>
CompactLattice *	ConvertToCompactLattice (CompactLattice *ifst)
template<class OrigWeightType >
Lattice *	ConvertToLattice (fst::VectorFst< OrigWeightType > *ifst)
	Converts lattice types if necessary, deleting its input. More...
template<>
Lattice *	ConvertToLattice (Lattice *ifst)
bool	WriteCompactLattice (std::ostream &os, bool binary, const CompactLattice &t)
CompactLattice *	ReadCompactLatticeText (std::istream &is)
Lattice *	ReadLatticeText (std::istream &is)
bool	ReadCompactLattice (std::istream &is, bool binary, CompactLattice **clat)
bool	WriteLattice (std::ostream &os, bool binary, const Lattice &t)
bool	ReadLattice (std::istream &is, bool binary, Lattice **lat)
void	GetPerFrameAcousticCosts (const Lattice &nbest, Vector< BaseFloat > *per_frame_loglikes)
	This function extracts the per-frame log likelihoods from a linear lattice (which we refer to as an 'nbest' lattice elsewhere in Kaldi code). More...
int32	LatticeStateTimes (const Lattice &lat, vector< int32 > *times)
	This function iterates over the states of a topologically sorted lattice and counts the time instance corresponding to each state. More...
int32	CompactLatticeStateTimes (const CompactLattice &lat, vector< int32 > *times)
	As LatticeStateTimes, but in the CompactLattice format. More...
bool	ComputeCompactLatticeAlphas (const CompactLattice &clat, vector< double > *alpha)
bool	ComputeCompactLatticeBetas (const CompactLattice &clat, vector< double > *beta)
template<class LatType >
bool	PruneLattice (BaseFloat beam, LatType *lat)
template bool	PruneLattice (BaseFloat beam, Lattice *lat)
template bool	PruneLattice (BaseFloat beam, CompactLattice *lat)
BaseFloat	LatticeForwardBackward (const Lattice &lat, Posterior *arc_post, double *acoustic_like_sum=NULL)
	This function does the forward-backward over lattices and computes the posterior probabilities of the arcs. More...
void	LatticeActivePhones (const Lattice &lat, const TransitionModel &trans, const vector< int32 > &silence_phones, vector< std::set< int32 > > *active_phones)
	Given a lattice, and a transition model to map pdf-ids to phones, outputs for each frame the set of phones active on that frame. More...
void	ConvertLatticeToPhones (const TransitionModel &trans_model, Lattice *lat)
	Given a lattice, and a transition model to map pdf-ids to phones, replace the output symbols (presumably words), with phones; we use the TransitionModel to work out the phone sequence. More...
static double	LogAddOrMax (bool viterbi, double a, double b)
template<typename LatticeType >
double	ComputeLatticeAlphasAndBetas (const LatticeType &lat, bool viterbi, vector< double > *alpha, vector< double > *beta)
template double	ComputeLatticeAlphasAndBetas (const Lattice &lat, bool viterbi, vector< double > *alpha, vector< double > *beta)
template double	ComputeLatticeAlphasAndBetas (const CompactLattice &lat, bool viterbi, vector< double > *alpha, vector< double > *beta)
void	CompactLatticeLimitDepth (int32 max_arcs_per_frame, CompactLattice *clat)
	This function limits the depth of the lattice, per frame: that means, it does not allow more than a specified number of arcs active on any given frame. More...
void	TopSortCompactLatticeIfNeeded (CompactLattice *clat)
	Topologically sort the compact lattice if not already topologically sorted. More...
void	TopSortLatticeIfNeeded (Lattice *clat)
	Topologically sort the lattice if not already topologically sorted. More...
BaseFloat	CompactLatticeDepth (const CompactLattice &clat, int32 *num_frames)
	Returns the depth of the lattice, defined as the average number of arcs crossing any given frame. More...
void	CompactLatticeDepthPerFrame (const CompactLattice &clat, std::vector< int32 > *depth_per_frame)
	This function returns, for each frame, the number of arcs crossing that frame. More...
void	ConvertCompactLatticeToPhones (const TransitionModel &trans_model, CompactLattice *clat)
	Given a lattice, and a transition model to map pdf-ids to phones, replace the sequences of transition-ids with sequences of phones. More...
bool	LatticeBoost (const TransitionModel &trans, const std::vector< int32 > &alignment, const std::vector< int32 > &silence_phones, BaseFloat b, BaseFloat max_silence_error, Lattice *lat)
	Boosts LM probabilities by b * [number of frame errors]; equivalently, adds -b*[number of frame errors] to the graph-component of the cost of each arc/path. More...
BaseFloat	LatticeForwardBackwardMpeVariants (const TransitionModel &trans, const std::vector< int32 > &silence_phones, const Lattice &lat, const std::vector< int32 > &num_ali, std::string criterion, bool one_silence_class, Posterior *post)
	This function implements either the MPFE (minimum phone frame error) or SMBR (state-level minimum bayes risk) forward-backward, depending on whether "criterion" is "mpfe" or "smbr". More...
bool	CompactLatticeToWordAlignment (const CompactLattice &clat, std::vector< int32 > *words, std::vector< int32 > *begin_times, std::vector< int32 > *lengths)
	This function takes a CompactLattice that should only contain a single linear sequence (e.g. More...
bool	CompactLatticeToWordProns (const TransitionModel &tmodel, const CompactLattice &clat, std::vector< int32 > *words, std::vector< int32 > *begin_times, std::vector< int32 > *lengths, std::vector< std::vector< int32 > > *prons, std::vector< std::vector< int32 > > *phone_lengths)
	This function takes a CompactLattice that should only contain a single linear sequence (e.g. More...
void	CompactLatticeShortestPath (const CompactLattice &clat, CompactLattice *shortest_path)
	A form of the shortest-path/best-path algorithm that's specially coded for CompactLattice. More...
void	AddWordInsPenToCompactLattice (BaseFloat word_ins_penalty, CompactLattice *clat)
	This function add the word insertion penalty to graph score of each word in the compact lattice. More...
bool	RescoreCompactLatticeInternal (const TransitionModel *tmodel, BaseFloat speedup_factor, DecodableInterface *decodable, CompactLattice *clat)
	RescoreCompactLatticeInternal is the internal code for both RescoreCompactLattice and RescoreCompatLatticeSpeedup. More...
bool	RescoreCompactLatticeSpeedup (const TransitionModel &tmodel, BaseFloat speedup_factor, DecodableInterface *decodable, CompactLattice *clat)
	This function is like RescoreCompactLattice, but it is modified to avoid computing probabilities on most frames where all the pdf-ids are the same. More...
bool	RescoreCompactLattice (DecodableInterface *decodable, CompactLattice *clat)
	This function *adds* the negated scores obtained from the Decodable object, to the acoustic scores on the arcs. More...
bool	RescoreLattice (DecodableInterface *decodable, Lattice *lat)
	This function *adds* the negated scores obtained from the Decodable object, to the acoustic scores on the arcs. More...
BaseFloat	LatticeForwardBackwardMmi (const TransitionModel &trans, const Lattice &lat, const std::vector< int32 > &num_ali, bool drop_frames, bool convert_to_pdf_ids, bool cancel, Posterior *arc_post)
	This function can be used to compute posteriors for MMI, with a positive contribution for the numerator and a negative one for the denominator. More...
int32	LongestSentenceLength (const Lattice &lat)
	This function returns the number of words in the longest sentence in a CompactLattice (i.e. More...
int32	LongestSentenceLength (const CompactLattice &lat)
	This function returns the number of words in the longest sentence in a CompactLattice, i.e. More...
void	ComposeCompactLatticeDeterministic (const CompactLattice &clat, fst::DeterministicOnDemandFst< fst::StdArc > *det_fst, CompactLattice *composed_clat)
	This function Composes a CompactLattice format lattice with a DeterministicOnDemandFst<fst::StdFst> format fst, and outputs another CompactLattice format lattice. More...
void	ComputeAcousticScoresMap (const Lattice &lat, unordered_map< std::pair< int32, int32 >, std::pair< BaseFloat, int32 >, PairHasher< int32 > > *acoustic_scores)
	This function computes the mapping from the pair (frame-index, transition-id) to the pair (sum-of-acoustic-scores, num-of-occurences) over all occurences of the transition-id in that frame. More...
void	ReplaceAcousticScoresFromMap (const unordered_map< std::pair< int32, int32 >, std::pair< BaseFloat, int32 >, PairHasher< int32 > > &acoustic_scores, Lattice *lat)
	This function restores acoustic scores computed using the function ComputeAcousticScoresMap into the lattice. More...
int32	LatticeStateTimes (const Lattice &lat, std::vector< int32 > *times)
	This function iterates over the states of a topologically sorted lattice and counts the time instance corresponding to each state. More...
int32	CompactLatticeStateTimes (const CompactLattice &clat, std::vector< int32 > *times)
	As LatticeStateTimes, but in the CompactLattice format. More...
bool	ComputeCompactLatticeAlphas (const CompactLattice &lat, std::vector< double > *alpha)
bool	ComputeCompactLatticeBetas (const CompactLattice &lat, std::vector< double > *beta)
template<typename LatticeType >
double	ComputeLatticeAlphasAndBetas (const LatticeType &lat, bool viterbi, std::vector< double > *alpha, std::vector< double > *beta)
void	LatticeActivePhones (const Lattice &lat, const TransitionModel &trans, const std::vector< int32 > &sil_phones, std::vector< std::set< int32 > > *active_phones)
	Given a lattice, and a transition model to map pdf-ids to phones, outputs for each frame the set of phones active on that frame. More...
template<class LatticeType >
bool	PruneLattice (BaseFloat beam, LatticeType *lat)
	Prunes a lattice or compact lattice. More...
CompactLattice *	RandDeterministicCompactLattice ()
void	TestMinimizeCompactLattice ()
bool	PhoneAlignLattice (const CompactLattice &lat, const TransitionModel &tmodel, const PhoneAlignLatticeOptions &opts, CompactLattice *lat_out)
	Outputs a lattice in which the arcs correspond exactly to sequences of phones, so the boundaries between the arcs correspond to the boundaries between phones If remove-epsilon == false and replace-output-symbols == false, but an arc may have >1 phone on it, but the boundaries will still correspond with the boundaries between phones. More...
void	TestPushCompactLatticeStrings ()
void	TestPushCompactLatticeWeights ()
void	GenerateLexicon (const std::vector< int32 > &phones, bool allow_zero_words, bool allow_empty_word, bool allow_multiple_prons, std::vector< std::vector< int32 > > *lexicon)
static void	PrintLexicon (const std::vector< std::vector< int32 > > &lexicon)
static void	PrintWordsAndPhones (const std::vector< int32 > &words, const std::vector< int32 > &phones)
void	GenerateWordAndPhoneSequence (std::vector< std::vector< int32 > > &lexicon, std::vector< int32 > *phone_seq, std::vector< int32 > *word_seq)
void	GenerateCompactLatticeRandomly (const std::vector< int32 > &alignment, const std::vector< int32 > &words, CompactLattice *clat)
void	TestWordAlignLatticeLexicon ()
static bool	IsPlausibleWord (const WordAlignLatticeLexiconInfo &lexicon_info, const TransitionModel &tmodel, int32 word_id, const std::vector< int32 > &transition_ids)
static void	MapSymbols (const WordAlignLatticeLexiconInfo &lexicon_info, CompactLattice *lat)
	Testing code; map word symbols in the lattice "lat" using the equivalence-classes obtained from the lexicon, using the function EquivalenceClassOf in the lexicon_info object. More...
static bool	TestWordAlignedLattice (const WordAlignLatticeLexiconInfo &lexicon_info, const TransitionModel &tmodel, CompactLattice clat, CompactLattice aligned_clat, bool allow_duplicate_paths)
bool	WordAlignLatticeLexicon (const CompactLattice &lat, const TransitionModel &tmodel, const WordAlignLatticeLexiconInfo &lexicon_info, const WordAlignLatticeLexiconOpts &opts, CompactLattice *lat_out)
	Align lattice so that each arc has the transition-ids on it that correspond to the word that is on that arc. More...
bool	ReadLexiconForWordAlign (std::istream &is, std::vector< std::vector< int32 > > *lexicon)
	Read the lexicon in the special format required for word alignment. More...
void	TestWordAlignedLatticeLexicon (const CompactLattice &lat, const TransitionModel &tmodel, const std::vector< std::vector< int32 > > &lexicon, const CompactLattice &aligned_lat, bool allow_duplicate_paths)
	This function is designed to crash if something went wrong with the word-alignment of the lattice. More...
static bool	IsPlausibleWord (const WordBoundaryInfo &info, const TransitionModel &tmodel, const std::vector< int32 > &transition_ids)
bool	WordAlignLattice (const CompactLattice &lat, const TransitionModel &tmodel, const WordBoundaryInfo &info, int32 max_states, CompactLattice *lat_out)
	Align lattice so that each arc has the transition-ids on it that correspond to the word that is on that arc. More...
void	TestWordAlignedLattice (const CompactLattice &lat, const TransitionModel &tmodel, const WordBoundaryInfo &info, const CompactLattice &aligned_lat)
	You should only test a lattice if WordAlignLattice returned true (i.e. More...
void	RegisterCuAllocatorOptions (OptionsItf *po)
template<typename T >
std::ostream &	operator<< (std::ostream &out, const CuArray< T > &vec)
	Print the vector to stream. More...
template<class T >
void	AssertEqual (const std::vector< T > &vec1, const std::vector< T > &vec2)
template<class T >
static void	UnitTestCuArray ()
template<typename Real >
static bool	ApproxEqual (const CuBlockMatrix< Real > &A, const CuBlockMatrix< Real > &B, float tol=0.001)
template<class Real >
static void	UnitTestCuBlockMatrixIO ()
template<class Real >
static void	UnitTestCuBlockMatrixAddMatBlock ()
template<class Real >
static void	UnitTestCuBlockMatrixAddMatMat ()
template<typename Real >
void	CuBlockMatrixUnitTest ()
template<typename Real >
std::ostream &	operator<< (std::ostream &out, const CuBlockMatrix< Real > &mat)
	Print the matrix to stream. More...
template std::ostream &	operator<< (std::ostream &out, const CuBlockMatrix< float > &mat)
template std::ostream &	operator<< (std::ostream &out, const CuBlockMatrix< double > &mat)
void	CuCompressedMatrixTestSign ()
void	CuCompressedMatrixTestNonnegative ()
void	CuCompressedMatrixTestSymmetric ()
CuCompressedMatrixBase *	NewCuCompressedMatrix (CuCompressedMatrixType t, BaseFloat range, bool truncate=true)
	This function allocates a new CuCompressedMatrix with type determined by t, and with the 'range' and 'truncate' parameters provided to the constructor of class CuCompressedMatrix. More...
template<typename Real >
void	TestCuMatrixResize (int32 size_multiple)
template<typename Real >
void	CudaMatrixResizeTest ()
void	SynchronizeGpu ()
	The function SynchronizeGpu(), which for convenience is defined whether or not we have compiled for CUDA, is intended to be called in places where threads need to be synchronized. More...
template<typename Real >
static void	UnitTestCuMathRandomize ()
template<typename Real >
static void	UnitTestEnsureNonzero ()
template<typename Real >
static void	UnitTestCuMathCopy ()
template<typename Real >
static void	UnitTestCuMathSplice ()
template<typename Real >
static void	UnitTestCuMathComputeLstmNonlinearity ()
void	UnitTestLstmNonlinearity ()
template<typename Real >
static void	UnitTestBackpropLstmNonlinearity ()
template<typename Real >
static void	UnitTestCuMathNormalizePerRow ()
template<typename Real >
static void	UnitTestCuMathNormalizePerRow_v2 ()
template<typename Real >
static void	UnitTestCuDiffNormalizePerRow ()
template<typename Real >
void	CudaMathUnitTest ()
template<typename Real >
void	TestCuMatrixSum (int32 dim)
template<typename Real >
void	TestCuMatrixMax (int32 dim)
template<typename Real >
void	TestCuMatrixMin (int32 dim)
template<typename Real >
void	TestCuMatrixDivRowsVec (int32 dim)
template<typename Real >
void	TestCuMatrixTransposeNS (int32 dim)
template<typename Real >
void	TestCuMatrixTransposeS (int32 dim)
template<typename Real >
void	TestCuMatrixTransposeCross (int32 dim)
template<typename Real >
void	TestCuMatrixAddMat (int32 dim, int32 num_row_blocks, int32 num_col_blocks)
template<typename Real >
void	TestCuMatrixAddMatBlocks (int32 dim, int32 num_row_blocks, int32 num_col_blocks)
template<typename Real >
void	TestCuMatrixMatMat (int32 dim)
template<typename Real >
void	TestCuMatrixMatMatBatched (int32 dim, int32 batchCount)
template<typename Real >
void	TestCuMatrixAddDiagVecMat (int32 dim, MatrixTransposeType trans)
template<typename Real >
void	TestSymInvertPosDef (int32 dim)
template<typename Real >
static void	TestCuMatrixCompObjfAndDeriv (int32 dim)
template<typename Real >
static void	TestCuFindRowMaxId (int32 dim)
template<typename Real >
void	TestCuMatrixSigmoid (int32 dim)
template<typename Real >
void	TestCuMatrixHeaviside (int32 dim)
template<typename Real >
void	TestCuMatrixMulRowsGroupMat (int32 dim)
template<typename Real >
void	TestCuMatrixDiffSoftmax (int32 dim)
template<typename Real >
void	TestCuMatrixDiffLogSoftmax (int32 dim)
template<typename Real >
void	TestCuMatrixSoftmax (int32 dim)
template<typename Real >
void	TestCuMatrixLogSoftmax (int32 dim)
template<typename Real >
void	TestCuMatrixGroupPnorm (int32 dim)
template<typename Real >
void	TestCuMatrixDiffGroupPnorm (int32 dim)
template<typename Real >
void	TestCuMatrixGroupMax (int32 dim)
template<typename Real >
void	TestCuMatrixGroupMaxAllGroupSizes (int32 dim)
template<typename Real >
void	TestCuMatrixGroupMaxDeriv (int32 dim)
template<typename Real >
void	TestCuMatrixTraceMatMat (int32 dim)
template<typename Real >
void	TestCuMatrixCholesky (int32 dim)
template<typename Real >
void	TestCuMatrixCopyLowerToUpper (int32 dim)
template<typename Real >
void	TestCuMatrixCopyFromTp (int32 dim, MatrixTransposeType trans)
template<typename Real >
void	TestCuMatrixCopyFromSp (int32 dim)
template<typename Real >
void	TestCuMatrixCopyUpperToLower (int32 dim)
template<typename Real >
void	TestCuMatrixSetZeroAboveDiag (int32 dim)
template<typename Real >
void	TestCuMatrixLookup (int32 dim)
template<typename Real >
void	TestCuMatrixCopyRows1 (int32 dim)
template<typename Real >
void	TestCuMatrixCopyRows2 (int32 dim)
template<typename Real >
void	TestCuMatrixCopyToRows (int32 dim)
template<typename Real >
void	TestCuMatrixAddRows1 (int32 dim)
template<typename Real >
void	TestCuMatrixAddRows2 (int32 dim)
template<typename Real >
void	TestCuMatrixAddToRows (int32 dim)
template<typename Real >
void	TestCuMatrixAddRowRanges (int32 dim)
template<typename Real >
void	TestCuSparseMatrixTraceMatSmat (int32 dim)
template<typename Real >
void	CudaMatrixSpeedTest ()
template<typename Real >
static void	InitRand (VectorBase< Real > *v)
template<typename Real >
static void	InitRand (MatrixBase< Real > *M)
template<typename Real >
static void	RandZeroToOneMatrix (MatrixBase< Real > *mat)
template<typename Real >
static void	UnitTestCuMatrixTraceMatMat ()
template<typename Real >
static void	UnitTestCuCholesky ()
template<typename Real >
static void	UnitTestCuMatrixApplyLog ()
template<typename Real >
static void	UnitTestCuMatrixApplyExpSpecial ()
template<typename Real >
static void	UnitTestCuMatrixApplyExp ()
template<typename Real >
static void	UnitTestCuMatrixApplyExpLimited ()
template<typename Real >
static void	UnitTestCuMatrixSigmoid ()
template<typename Real >
static void	UnitTestCuMatrixScale ()
template<typename Real >
static void	UnitTestCuMatrixAdd ()
template<typename Real >
static void	UnitTestCuMatrixSoftHinge ()
template<typename Real >
static void	UnitTestCuMatrixGroupPnorm ()
template<typename Real >
static void	UnitTestCuMatrixGroupMax ()
template<typename Real >
static void	UnitTestCuMatrixSet ()
template<typename Real >
static void	UnitTestCuMatrixApplyPow ()
template<typename Real >
static void	UnitTestCuMatrixApplyPowAbs ()
template<typename Real >
static void	UnitTestCuMatrixCopyRowsFromVec ()
template<typename Real >
static void	UnitTestCuMatrixCopyColsFromVec ()
template<typename Real >
static void	UnitTestCuMatrixCopyRows ()
template<typename Real >
static void	UnitTestCuMatrixCopyToRows ()
template<typename Real >
static void	UnitTestCuMatrixAddRows ()
template<typename Real >
static void	UnitTestCuMatrixMulRows ()
template<typename Real >
static void	UnitTestCuMatrixAddToRows ()
template<typename Real >
void	UnitTestCuMatrixCopyCross ()
template<typename Real >
void	UnitTestCuMatrixCopyCross2 ()
template<typename Real >
static void	UnitTestCuMatrixSumColumnRanges ()
template<typename Real >
static void	UnitTestCuMatrixAddRowRanges ()
template<typename Real >
static void	UnitTestCuMatrixCopyCols ()
template<typename Real >
static void	UnitTextCuMatrixAddSmat ()
template<typename Real >
static void	UnitTextCuMatrixAddMatSmat ()
template<typename Real >
static void	UnitTextCuMatrixAddSmatMat ()
template<typename Real >
static void	UnitTestCuMatrixAddCols ()
template<typename Real >
static void	UnitTestCuMatrixApplyFloor ()
template<typename Real >
static void	UnitTestCuMatrixApplyCeiling ()
template<typename Real >
static void	UnitTestCuMatrixApplyHeaviside ()
template<typename Real >
static void	UnitTestCuMatrixHeaviside ()
template<typename Real >
static void	UnitTestCuMatrixMulElements ()
template<typename Real >
static void	UnitTestCuMatrixDivElements ()
template<typename Real >
static void	UnitTestCuMatrixMax ()
template<typename Real >
static void	UnitTestCuMatrixMin ()
template<typename Real >
static void	UnitTestCuMatrixMulColsVec ()
template<typename Real >
static void	UnitTestCuMatrixMulRowsVec ()
template<typename Real >
static void	UnitTestCuMatrixMulRowsGroupMat ()
template<typename Real >
static void	UnitTestCuMatrixDiffGroupPnorm ()
template<typename Real >
static void	UnitTestCuMatrixGroupMaxDeriv ()
template<typename Real >
static void	UnitTestCuMatrixAddDiagVecMat ()
template<typename Real >
static void	UnitTestCuMatrixAddMatDiagVec ()
template<typename Real >
static void	UnitTestCuMatrixAddMatMatElements ()
template<typename Real >
static void	UnitTestCuMatrixSetMatMatDivMat ()
template<typename Real >
static void	UnitTestCuMatrixDivRowsVec ()
template<typename Real >
static void	UnitTestCuMatrixAddMat ()
template<typename Real >
static void	UnitTestCuMatrixAddMatBlocks1 ()
template<typename Real >
static void	UnitTestCuMatrixAddMatBlocks1Trans ()
template<typename Real >
static void	UnitTestCuMatrixAddMatBlocks2 ()
template<typename Real >
static void	UnitTestCuMatrixReduceSum ()
template<typename Real >
static void	UnitTestCuMatrixReduceMax ()
template<typename Real >
static void	UnitTestCuMatrixReduceMin ()
template<typename Real >
static void	UnitTestCuMatrixAddVecToCols ()
template<typename Real >
static void	UnitTestCuMatrixAddVecToRows ()
template<typename Real >
static void	UnitTestCuMatrixSymAddMat2 ()
template<typename Real >
static void	UnitTestCuMatrixSymInvertPosDef ()
template<typename Real >
static void	UnitTestCuMatrixAddMatMat ()
template<typename Real >
static void	UnitTestCuMatrixAddVecVec ()
template<typename Real >
static void	UnitTestCuMatrixAddMatMatBatched ()
template<typename Real >
static void	UnitTestCuMatrixAddToDiag ()
template<typename Real >
static void	UnitTestCuMatrixAdd2 ()
template<typename Real >
static void	UnitTestCuMatrixCopyFromMat ()
template<typename Real >
static void	UnitTestCuMatrixCopyFromTp ()
template<typename Real >
static void	UnitTestCuMatrixAddMatTp ()
template<typename Real >
static void	UnitTestCuMatrixTranspose ()
template<typename Real >
static void	UnitTestCuMatrixAddTpMat ()
template<typename Real >
static void	UnitTestCuVectorAddVec ()
template<typename Real >
static void	UnitTestCuVectorAddRowSumMat ()
template<typename Real >
static void	UnitTestCuVectorAddRowSumMatLarge ()
template<typename Real >
static void	UnitTestCuVectorAddColSumMat ()
template<typename Real >
static void	UnitTestCuSubMatrix ()
template<typename Real >
static void	UnitTestCuVectorAddColSumMatLarge ()
template<typename Real >
static void	UnitTestCuVectorInvertElements ()
template<typename Real >
static void	UnitTestCuMatrixInvertElements ()
template<class Real >
static void	UnitTestCuMatrixIO ()
template<typename Real >
static void	UnitTestCuVectorAddTpVec ()
template<typename Real >
static void	UnitTestCuApproxEqual ()
template<typename Real >
static void	UnitTestCuVectorMulTp ()
template<typename Real , typename OtherReal >
static void	UnitTestCuCopy ()
template<typename Real >
static void	UnitTestCuSigmoid ()
template<typename Real >
static void	UnitTestCuDiffSigmoid ()
template<typename Real >
static void	UnitTestCuDiffSoftmax ()
template<typename Real >
static void	UnitTestCuDiffLogSoftmax ()
template<typename Real >
static void	UnitTestCuSoftmax ()
template<typename Real >
static void	UnitTestCuLogSoftmax ()
template<typename Real >
static void	UnitTestCuFindRowMaxId ()
template<typename Real >
static void	UnitTestCuDiffXent ()
template<typename Real >
void	UnitTestCheck ()
template<typename Real >
void	UnitTestSwapCu2Cu ()
template<typename Real >
void	UnitTestSwapCu2M ()
template<typename Real >
void	UnitTestCuTanh ()
template<typename Real >
static void	UnitTestCuDiffTanh ()
static int32	DoubleFactorial (int32 i)
template<typename Real >
static void	UnitTestCuMatrixSetRandn ()
template<typename Real >
static void	UnitTestCuMatrixSetRandUniform ()
template<typename Real >
static void	UnitTestCuMatrixCopyLowerToUpper ()
template<typename Real >
static void	UnitTestCuMatrixSetZeroAboveDiag ()
template<typename Real >
static void	UnitTestCuMatrixCopyUpperToLower ()
template<typename Real >
static void	UnitTestCuMatrixObjfDeriv ()
template<typename Real >
static void	UnitTestCuMatrixAddElements ()
template<typename Real >
static void	UnitTestCuMatrixAddToElements ()
template<typename Real >
static void	UnitTestCuMatrixLookup ()
template<typename Real >
static void	UnitTestCuMatrixEqualElementMask ()
template<typename Real >
void	CudaMatrixUnitTest ()
template<typename Real >
Real	TraceMatMat (const CuMatrixBase< Real > &A, const CuMatrixBase< Real > &B, MatrixTransposeType trans)
template float	TraceMatMat (const CuMatrixBase< float > &A, const CuMatrixBase< float > &B, MatrixTransposeType trans)
template double	TraceMatMat (const CuMatrixBase< double > &A, const CuMatrixBase< double > &B, MatrixTransposeType trans)
template<typename Real >
void	AddMatMatBatched (const Real alpha, std::vector< CuSubMatrix< Real > *> &C, const std::vector< CuSubMatrix< Real > *> &A, MatrixTransposeType transA, const std::vector< CuSubMatrix< Real > *> &B, MatrixTransposeType transB, const Real beta)
	Does multiple matrix multiplications, executing them in parallel using cuBLAS's gemmBatched if we are using a GPU. More...
template void	AddMatMatBatched (const float alpha, std::vector< CuSubMatrix< float > * > &C, const std::vector< CuSubMatrix< float > * > &A, MatrixTransposeType transA, const std::vector< CuSubMatrix< float > * > &B, MatrixTransposeType transB, const float beta)
template void	AddMatMatBatched (const double alpha, std::vector< CuSubMatrix< double > * > &C, const std::vector< CuSubMatrix< double > * > &A, MatrixTransposeType transA, const std::vector< CuSubMatrix< double > * > &B, MatrixTransposeType transB, const double beta)
template<typename Real >
std::ostream &	operator<< (std::ostream &out, const CuMatrixBase< Real > &mat)
	Print the matrix to stream. More...
template std::ostream &	operator<< (std::ostream &out, const CuMatrixBase< float > &mat)
template std::ostream &	operator<< (std::ostream &out, const CuMatrixBase< double > &mat)
template<typename Real >
bool	ApproxEqual (const CuMatrixBase< Real > &A, const CuMatrixBase< Real > &B, Real tol=0.01)
template<typename Real >
void	AssertEqual (const CuMatrixBase< Real > &A, const CuMatrixBase< Real > &B, float tol=0.01)
template<typename Real >
bool	SameDim (const CuMatrixBase< Real > &M, const CuMatrixBase< Real > &N)
template<typename Real >
bool	SameDimAndStride (const CuMatrixBase< Real > &M, const CuMatrixBase< Real > &N)
template<typename Real >
static void	AssertEqual (const CuPackedMatrix< Real > &A, const CuPackedMatrix< Real > &B, float tol=0.001)
template<typename Real >
static void	AssertEqual (const PackedMatrix< Real > &A, const PackedMatrix< Real > &B, float tol=0.001)
template<typename Real >
static void	AssertDiagEqual (const PackedMatrix< Real > &A, const CuPackedMatrix< Real > &B, float value, float tol=0.001)
template<typename Real >
static void	AssertDiagEqual (const PackedMatrix< Real > &A, const PackedMatrix< Real > &B, float value, float tol=0.001)
template<typename Real >
static void	AssertEqual (const PackedMatrix< Real > &A, const CuPackedMatrix< Real > &B, float tol=0.001)
template<typename Real >
static bool	ApproxEqual (const PackedMatrix< Real > &A, const PackedMatrix< Real > &B, Real tol=0.001)
template<typename Real >
static void	UnitTestCuPackedMatrixConstructor ()
template<typename Real >
static void	UnitTestCuPackedMatrixCopy ()
template<typename Real >
static void	UnitTestCuPackedMatrixTrace ()
template<typename Real >
static void	UnitTestCuPackedMatrixScale ()
template<typename Real >
static void	UnitTestCuPackedMatrixScaleDiag ()
template<typename Real >
static void	UnitTestCuPackedMatrixAddToDiag ()
template<typename Real >
static void	UnitTestCuPackedMatrixSetUnit ()
template<typename Real >
void	CudaPackedMatrixUnitTest ()
template<typename Real >
std::ostream &	operator<< (std::ostream &out, const CuPackedMatrix< Real > &mat)
	Print the matrix to stream. More...
template std::ostream &	operator<< (std::ostream &out, const CuPackedMatrix< float > &mat)
template std::ostream &	operator<< (std::ostream &out, const CuPackedMatrix< double > &mat)
template<typename T >
std::string	ToString (const T &t)
template<typename Real >
std::string	MeanVariance (const CuMatrixBase< Real > &m)
template<typename Real >
std::string	MeanVariance (const CuVectorBase< Real > &v)
template<typename Real >
void	CuRandUniformMatrixSpeedTest (const int32 iter)
template<typename Real >
void	CuRandUniformMatrixBaseSpeedTest (const int32 iter)
template<typename Real >
void	CuRandGaussianMatrixSpeedTest (const int32 iter)
template<typename Real >
void	CuRandGaussianMatrixBaseSpeedTest (const int32 iter)
template<typename Real >
void	CuRandUniformVectorSpeedTest (const int32 iter)
template<typename Real >
void	CuRandGaussianVectorSpeedTest (const int32 iter)
template<typename Real >
static void	UnitTestCuSpMatrixInvert (int32 dim)
template<typename Real >
static void	UnitTestCuSpMatrixCopyFromMat (int32 dim, SpCopyType copy_type)
template<typename Real >
void	CuSpMatrixSpeedTest ()
template<typename Real >
static void	UnitTestCuSpMatrixConstructor ()
template<typename Real >
static void	UnitTestCuSpMatrixApproxEqual ()
template<typename Real >
static void	UnitTestCuSpMatrixOperator ()
template<typename Real >
static void	UnitTestCuSpMatrixAddToDiag ()
template<typename Real >
static void	UnitTestCuSpMatrixCopyFromMat ()
template<typename Real >
static void	UnitTestCuSpMatrixInvert ()
template<typename Real >
static void	UnitTestCuSpMatrixAddVec2 ()
template<typename Real >
static void	UnitTestCuSpMatrixAddMat2 ()
template<typename Real >
static void	UnitTestCuSpMatrixAddSp ()
template<typename Real , typename OtherReal >
static void	UnitTestCuSpMatrixTraceSpSp ()
template<typename Real >
void	UnitTestCuSpMatrixSetUnit ()
template<class Real >
static void	UnitTestCuSpMatrixIO ()
template<typename Real , typename OtherReal >
static void	UnitTestCuSpMatrixAddSp ()
template<typename Real >
void	CudaSpMatrixUnitTest ()
template<typename Real , typename OtherReal >
void	CudaSpMatrixUnitTest ()
template<typename Real , typename OtherReal >
Real	TraceSpSp (const CuSpMatrix< Real > &A, const CuSpMatrix< OtherReal > &B)
	C++ templatd wrapper of ANSI-C CUBLAS function GEMM (matrix multiply) More...
template float	TraceSpSp (const CuSpMatrix< float > &A, const CuSpMatrix< float > &B)
template float	TraceSpSp (const CuSpMatrix< float > &A, const CuSpMatrix< double > &B)
template double	TraceSpSp (const CuSpMatrix< double > &A, const CuSpMatrix< float > &B)
template double	TraceSpSp (const CuSpMatrix< double > &A, const CuSpMatrix< double > &B)
template<typename Real >
bool	ApproxEqual (const CuSpMatrix< Real > &A, const CuSpMatrix< Real > &B, Real tol=0.001)
template<typename Real >
void	AssertEqual (const CuSpMatrix< Real > &A, const CuSpMatrix< Real > &B, Real tol=0.001)
template<typename Real >
static void	UnitTestCuSparseMatrixConstructFromIndexes ()
template<typename Real >
static void	UnitTestCuSparseMatrixSelectRowsAndTranspose ()
template<typename Real >
static void	UnitTestCuSparseMatrixTraceMatSmat ()
template<typename Real >
static void	UnitTestCuSparseMatrixSum ()
template<typename Real >
static void	UnitTestCuSparseMatrixFrobeniusNorm ()
template<typename Real >
static void	UnitTestCuSparseMatrixCopyToSmat ()
template<typename Real >
static void	UnitTestCuSparseMatrixSwap ()
template<typename Real >
void	CudaSparseMatrixUnitTest ()
template<typename Real >
Real	TraceMatSmat (const CuMatrixBase< Real > &A, const CuSparseMatrix< Real > &B, MatrixTransposeType trans)
template float	TraceMatSmat (const CuMatrixBase< float > &A, const CuSparseMatrix< float > &B, MatrixTransposeType trans)
template double	TraceMatSmat (const CuMatrixBase< double > &A, const CuSparseMatrix< double > &B, MatrixTransposeType trans)
template<typename Real >
static void	InitRand (SpMatrix< Real > *M)
template<typename Real >
static void	InitRand (VectorBase< Real > *v)
template<typename Real >
static void	UnitTestSetZeroAboveDiag ()
template<typename Real >
static void	UnitTestCholesky ()
template<typename Real >
static void	UnitTestTrace ()
template<typename Real >
static void	UnitInvert ()
template<typename Real >
static void	UnitTestInvert ()
template<typename Real >
static void	UnitTestConstructor ()
template<typename Real >
static void	UnitTestCopySp ()
template<typename Real >
static void	UnitTestCopyFromMat ()
template<typename Real >
static void	UnitTestMatrix ()
template<typename Real >
static void	UnitTestMulTp ()
template<typename Real >
static void	UnitTestVector ()
template<typename Real >
static void	CuMatrixUnitTest ()
template<typename Real >
static void	AssertEqual (const CuPackedMatrix< Real > &A, const CuPackedMatrix< Real > &B, float tol=0.001)
template<typename Real >
static void	AssertEqual (const PackedMatrix< Real > &A, const PackedMatrix< Real > &B, float tol=0.001)
template<typename Real >
static void	AssertEqual (const PackedMatrix< Real > &A, const CuPackedMatrix< Real > &B, float tol=0.001)
template<typename Real >
static void	UnitTestCuTpMatrixInvert ()
template<typename Real >
static void	UnitTestCuTpMatrixCopyFromTp ()
template<typename Real >
static void	UnitTestCuTpMatrixCopyFromMat ()
template<typename Real >
static void	UnitTestCuTpMatrixCholesky ()
template<class Real >
static void	UnitTestCuTpMatrixIO ()
template<typename Real >
void	CudaTpMatrixUnitTest ()
template<typename Real >
void	TestCuVectorSoftmax (int32 dim)
template<typename Real >
void	TestCuVectorSum (int32 dim)
template<typename Real , typename OtherReal >
void	TestCuVectorCopyFromVec (int32 dim)
template<typename Real >
void	TestCuVectorVecVecOne (int32 dim)
template<typename Real >
void	TestCuVectorAddDiagMatMat (int32 dim, MatrixTransposeType transN, MatrixTransposeType transO)
template<typename Real >
void	TestCuVectorAddDiagMat2OnVariousShapes (int32 dim, MatrixTransposeType trans)
template<typename Real >
void	TestCuVectorAddDiagMat2 (int32 dim, MatrixTransposeType trans)
template<typename Real >
void	TestCuVectorAddRowSumMat (int32 dim, MatrixTransposeType trans)
template<typename Real >
void	TestCuVectorAddColSumMat (int32 dim, MatrixTransposeType trans)
template<typename Real >
void	TestCuVectorApplyFloor (int32 dim)
template<typename Real >
void	TestCuVectorApplyFloorNoCount (int32 dim)
template<typename Real >
void	TestCuVectorApplyCeiling (int32 dim)
template<typename Real >
void	TestCuVectorApplyCeilingNoCount (int32 dim)
template<typename Real >
void	TestCuVectorAddDiagMatMatShape (int32 num_rows, int32 num_cols, MatrixTransposeType transM, MatrixTransposeType transN)
template<typename Real >
void	CudaVectorSpeedTest ()
template<class Real >
static void	UnitTestCuVectorIO ()
template<typename Real , typename OtherReal >
static void	UnitTestCuVectorCopyFromVec ()
template<typename Real >
static void	UnitTestCuSubVector ()
template<typename Real >
static void	UnitTestCuVectorMulTp ()
template<typename Real >
static void	UnitTestCuVectorAddTp ()
template<typename Real >
void	CuVectorUnitTestVecVec ()
template<typename Real >
void	CuVectorUnitTestAddVec ()
template<typename Real >
void	CuVectorUnitTestAddVecCross ()
template<typename Real >
void	CuVectorUnitTestAddVecExtra ()
template<typename Real >
void	CuVectorUnitTestCopyElements ()
template<typename Real >
void	UnitTestVecMatVec ()
template<typename Real >
void	CuVectorUnitTestAddRowSumMat ()
template<typename Real >
void	CuVectorUnitTestAddColSumMat ()
template<typename Real >
void	CuVectorUnitTestApproxEqual ()
template<typename Real >
static void	UnitTestCuVectorReplaceValue ()
template<typename Real >
static void	UnitTestCuVectorSum ()
template<typename Real >
void	CuVectorUnitTestInvertElements ()
template<typename Real >
void	CuVectorUnitTestSum ()
template<typename Real >
void	CuVectorUnitTestScale ()
template<typename Real >
void	CuVectorUnitTestCopyFromMat ()
template<typename Real >
void	CuVectorUnitTestCopyDiagFromPacked ()
template<typename Real >
void	CuVectorUnitTestCopyCross ()
template<typename Real >
void	CuVectorUnitTestCopyCross2 ()
template<typename Real >
void	CuVectorUnitTestCopyDiagFromMat ()
template<typename Real >
void	CuVectorUnitTestNorm ()
template<typename Real >
void	CuVectorUnitTestMin ()
template<typename Real >
void	CuVectorUnitTestMax ()
template<typename Real >
void	CuVectorUnitTestApplySoftMax ()
template<typename Real >
void	CuVectorUnitTestApplyExp ()
template<typename Real >
void	CuVectorUnitTestApplyLog ()
template<typename Real >
void	CuVectorUnitTestApplyFloor ()
template<typename Real >
void	CuVectorUnitTestApplyFloorNoCount ()
template<typename Real >
void	CuVectorUnitTestApplyCeiling ()
template<typename Real >
void	CuVectorUnitTestApplyCeilingNoCount ()
template<typename Real >
void	CuVectorUnitTestApplyPow ()
template<typename Real >
void	CuVectorUnitTestAddVecVec ()
template<typename Real >
void	CuVectorUnitTestAddDiagMat2 ()
template<typename Real >
static void	CuVectorUnitTestAddDiagMatMat ()
template<typename Real >
void	CuVectorUnitTestAddMatVec ()
template<typename Real >
void	CuVectorUnitTestAddSpVec ()
template<typename Real >
void	CuVectorUnitTest ()
template<typename Real >
Real	VecVec (const CuVectorBase< Real > &a, const CuVectorBase< Real > &b)
template float	VecVec (const CuVectorBase< float > &a, const CuVectorBase< float > &b)
template double	VecVec (const CuVectorBase< double > &a, const CuVectorBase< double > &b)
template<typename Real , typename OtherReal >
Real	VecVec (const CuVectorBase< Real > &A, const CuVectorBase< OtherReal > &B)
template float	VecVec (const CuVectorBase< float > &A, const CuVectorBase< double > &B)
template double	VecVec (const CuVectorBase< double > &A, const CuVectorBase< float > &B)
template<typename Real >
Real	VecMatVec (const CuVectorBase< Real > &v1, const CuMatrixBase< Real > &M, const CuVectorBase< Real > &v2)
	Returns . More...
template float	VecMatVec (const CuVectorBase< float > &v1, const CuMatrixBase< float > &M, const CuVectorBase< float > &v2)
template double	VecMatVec (const CuVectorBase< double > &v1, const CuMatrixBase< double > &M, const CuVectorBase< double > &v2)
template<typename Real >
std::ostream &	operator<< (std::ostream &out, const CuVectorBase< Real > &vec)
	Print the vector to stream. More...
template std::ostream &	operator<< (std::ostream &out, const CuVectorBase< float > &vec)
template std::ostream &	operator<< (std::ostream &out, const CuVectorBase< double > &vec)
template<typename Real >
bool	ApproxEqual (const CuVectorBase< Real > &a, const CuVectorBase< Real > &b, Real tol=0.01)
template<typename Real >
void	AssertEqual (const CuVectorBase< Real > &a, const CuVectorBase< Real > &b, Real tol=0.01)
void	GetSeenPhones (BuildTreeStatsType &stats, int P, std::vector< int32 > *phones_out)
void	AddToCount (int32 location_to_add, double value_to_add, std::vector< double > *counts)
void	AddToConfusionMatrix (int32 phone1, int32 phone2, Matrix< double > *counts)
void	WriteAsKaldiVector (const std::vector< double > &counts, std::string &wxfilename, bool binary)
int32	ProcessTopo (const HmmTopology &topo, const std::vector< std::vector< int32 > > &questions)
void	FrameLevelLpp (const SubVector< BaseFloat > &prob_row, const std::vector< std::set< int32 > > &pdf2phones, const std::vector< int32 > *phone_map, Vector< BaseFloat > *out_frame_level_lpp)
	FrameLevelLpp compute a log posterior for pure-phones by sum the posterior of the states belonging to those triphones whose current phone is the canonical phone: More...
void	GetEditsSingleHyp (const std::string &hyp_rspecifier, const std::string &ref_rspecifier, const std::string &mode, std::vector< std::pair< int32, int32 > > &edit_word_per_hyp)
void	GetEditsDualHyp (const std::string &hyp_rspecifier, const std::string &hyp_rspecifier2, const std::string &ref_rspecifier, const std::string &mode, std::vector< std::pair< int32, int32 > > &edit_word_per_hyp, std::vector< std::pair< int32, int32 > > &edit_word_per_hyp2)
void	GetBootstrapWERInterval (const std::vector< std::pair< int32, int32 > > &edit_word_per_hyp, int32 replications, BaseFloat *mean, BaseFloat *interval)
void	GetBootstrapWERTwoSystemComparison (const std::vector< std::pair< int32, int32 > > &edit_word_per_hyp, const std::vector< std::pair< int32, int32 > > &edit_word_per_hyp2, int32 replications, BaseFloat *p_improv)
void	ApplySoftMaxPerRow (MatrixBase< BaseFloat > *mat)
int32	TypeOneUsage (const ParseOptions &po, BaseFloat scale1, BaseFloat scale2)
int32	TypeOneUsageAverage (const ParseOptions &po)
int32	TypeTwoUsage (const ParseOptions &po, bool binary)
int32	TypeThreeUsage (const ParseOptions &po, bool binary, bool average)
int32	TypeOneUsage (const ParseOptions &po)
int32	TypeTwoUsage (const ParseOptions &po, bool binary, bool average=false)
int32	TypeThreeUsage (const ParseOptions &po, bool binary)
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const GaussPost &gpost, const TransitionModel &trans_model, const AmDiagGmm &am_gmm, FmllrDiagGmmAccs *spk_stats)
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const Posterior &post, const TransitionModel &trans_model, const AmDiagGmm &am_gmm, FmllrDiagGmmAccs *spk_stats)
fst::Fst< fst::StdArc > *	ReadNetwork (std::string filename)
void	AccStatsForUtterance (const TransitionModel &trans_model, const AmDiagGmm &am_gmm, const GaussPost &gpost, const Matrix< BaseFloat > &feats, FmllrRawAccs *accs)
void	AccStatsForUtterance (const TransitionModel &trans_model, const AmDiagGmm &am_gmm, const Posterior &post, const Matrix< BaseFloat > &feats, FmllrRawAccs *accs)
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const GaussPost &gpost, const AmDiagGmm &am_gmm, FmllrDiagGmmAccs *spk_stats)
bool	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const DiagGmm &gmm, const std::string &key, RandomAccessBaseFloatVectorReader *weights_reader, RandomAccessInt32VectorVectorReader *gselect_reader, AccumFullGmm *fullcov_stats)
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const Posterior &post, const DiagGmm &gmm, FmllrDiagGmmAccs *spk_stats)
void	InitGmmFromRandomFrames (const Matrix< BaseFloat > &feats, DiagGmm *gmm)
void	TrainOneIter (const Matrix< BaseFloat > &feats, const MleDiagGmmOptions &gmm_opts, int32 iter, int32 num_threads, DiagGmm *gmm)
void	ReadSharedPhonesList (std::string rxfilename, std::vector< std::vector< int32 > > *list_out)
EventMap *	GetFullBiphoneStubMap (const std::vector< std::vector< int32 > > &phone_sets, const std::vector< int32 > &phone2num_pdf_classes, const std::vector< int32 > &ci_phones_list, const std::vector< std::vector< int32 > > &bi_counts, int32 biphone_min_count, const std::vector< int32 > &mono_counts, int32 mono_min_count)
ContextDependency *	BiphoneContextDependencyFull (std::vector< std::vector< int32 > > phone_sets, const std::vector< int32 > phone2num_pdf_classes, const std::vector< int32 > &ci_phones_list, const std::vector< std::vector< int32 > > &bi_counts, int32 biphone_min_count, const std::vector< int32 > &mono_counts, int32 mono_min_count)
void	GetFeatureMeanAndVariance (const std::string &feat_rspecifier, Vector< BaseFloat > *inv_var_out, Vector< BaseFloat > *mean_out)
void	InitAmGmm (const BuildTreeStatsType &stats, const EventMap &to_pdf_map, AmDiagGmm *am_gmm, const TransitionModel &trans_model, BaseFloat var_floor)
	InitAmGmm initializes the GMM with one Gaussian per state. More...
void	GetOccs (const BuildTreeStatsType &stats, const EventMap &to_pdf_map, Vector< BaseFloat > *occs)
	Get state occupation counts. More...
void	InitAmGmmFromOld (const BuildTreeStatsType &stats, const EventMap &to_pdf_map, int32 N, int32 P, const std::string &old_tree_rxfilename, const std::string &old_model_rxfilename, BaseFloat var_floor, AmDiagGmm *am_gmm)
	InitAmGmmFromOld initializes the GMM based on a previously trained model and tree, which must require no more phonetic context than the current tree. More...
bool	DecodeUtterance (LatticeBiglmFasterDecoder &decoder, DecodableInterface &decodable, const TransitionModel &trans_model, const fst::SymbolTable *word_syms, std::string utt, double acoustic_scale, bool determinize, bool allow_partial, Int32VectorWriter *alignment_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
void	MergeFullGmm (const FullGmm &src, FullGmm *dst)
	merges GMMs by appending Gaussians in "src" to "dst". More...
void	AppendPostToFeats (const Matrix< BaseFloat > &in, const Posterior &post, const int32 post_dim, Matrix< BaseFloat > *out)
void	AppendVectorToFeats (const Matrix< BaseFloat > &in, const Vector< BaseFloat > &vec, Matrix< BaseFloat > *out)
void	GetUtterancePairs (const std::string &reco2file_and_channel_rxfilename, std::vector< std::vector< std::string > > *utt_pairs)
void	AccCmvnStatsForPair (const std::string &utt1, const std::string &utt2, const MatrixBase< BaseFloat > &feats1, const MatrixBase< BaseFloat > &feats2, BaseFloat quieter_channel_weight, MatrixBase< double > *cmvn_stats1, MatrixBase< double > *cmvn_stats2)
bool	AccCmvnStatsWrapper (const std::string &utt, const MatrixBase< BaseFloat > &feats, RandomAccessBaseFloatVectorReader *weights_reader, Matrix< double > *cmvn_stats)
void	ConcatFeats (const std::vector< Matrix< BaseFloat > > &in, Matrix< BaseFloat > *out)
void	IncreaseTransformDimension (int32 new_dimension, Matrix< BaseFloat > *mat)
void	LinearlyInterpolatePitch (Matrix< BaseFloat > *mat)
bool	AppendFeats (const std::vector< Matrix< BaseFloat > > &in, const std::string &utt, int32 tolerance, Matrix< BaseFloat > *out)
void	ProcessPovFeatures (Matrix< BaseFloat > *mat)
void	TakeLogOfPitch (Matrix< BaseFloat > *mat)
void	SubtractMovingAverage (int32 normalization_window_size, Matrix< BaseFloat > *mat)
void	SetToMovingAverage (int32 average_window_size, Matrix< BaseFloat > *mat)
void	ShiftFeatureMatrix (const Matrix< BaseFloat > &src, int32 shift, Matrix< BaseFloat > *rearranged)
void	AddVectorsOfUnequalLength (const VectorBase< BaseFloat > &signal1, Vector< BaseFloat > *signal2)
void	AddVectorsWithOffset (const Vector< BaseFloat > &signal1, int32 offset, Vector< BaseFloat > *signal2)
BaseFloat	MaxAbsolute (const Vector< BaseFloat > &vector)
BaseFloat	ComputeEarlyReverbEnergy (const Vector< BaseFloat > &rir, const Vector< BaseFloat > &signal, BaseFloat samp_freq)
float	DoReverberation (const Vector< BaseFloat > &rir, BaseFloat samp_freq, Vector< BaseFloat > *signal)
void	AddNoise (Vector< BaseFloat > *noise, BaseFloat snr_db, BaseFloat time, BaseFloat samp_freq, BaseFloat signal_power, Vector< BaseFloat > *signal)
void	ReadCommaSeparatedCommand (const std::string &s, std::vector< BaseFloat > *v)
bool	ReadData (SequentialBaseFloatMatrixReader &feature_reader, RandomAccessPosteriorReader &target_reader, RandomAccessBaseFloatVectorReader &weights_reader, int32 length_tolerance, Matrix< BaseFloat > *feats, Posterior *targets, Vector< BaseFloat > *weights, int32 *num_no_tgt_mat, int32 *num_other_error)
bool	CompactLatticeNormalize (CompactLattice *clat, BaseFloat weight)
void	SplitStringToWeights (const string &full, const char *delim, vector< BaseFloat > *out)
int32	CopySubsetLattices (std::string filename, SequentialLatticeReader *lattice_reader, LatticeWriter *lattice_writer, bool include=true, bool ignore_missing=false, bool sorted=false)
int32	CopySubsetLattices (std::string filename, SequentialCompactLatticeReader *lattice_reader, CompactLatticeWriter *lattice_writer, bool include=true, bool ignore_missing=false, bool sorted=false)
bool	DeterminizeLatticeWrapper (const Lattice &lat, const std::string &key, bool prune, BaseFloat beam, BaseFloat beam_ratio, int32 max_mem, int32 max_loop, BaseFloat delta, int32 num_loops, CompactLattice *clat)
void	ReadSymbolList (const std::string &rxfilename, fst::SymbolTable *word_syms, LabelPairVector *lpairs)
void	ConvertLatticeToUnweightedAcceptor (const kaldi::Lattice &ilat, const LabelPairVector &wildcards, fst::StdVectorFst *ofst)
void	CreateEditDistance (const fst::StdVectorFst &fst1, const fst::StdVectorFst &fst2, fst::StdVectorFst *pfst)
void	CountErrors (const fst::StdVectorFst &fst, int32 *correct, int32 *substitutions, int32 *insertions, int32 *deletions, int32 *num_words)
bool	CheckFst (const fst::StdVectorFst &fst, string name, string key)
void	LatticeAcousticRescore (const TransitionModel &trans_model, const Matrix< BaseFloat > &log_likes, const std::vector< int32 > &state_times, Lattice *lat)
void	MakeLatticeFromLinear (const std::vector< int32 > &ali, const std::vector< int32 > &words, BaseFloat lm_cost, BaseFloat ac_cost, Lattice *lat_out)
static float	_RandGauss ()
void	ComputeFeatureNormalizingTransform (const FullGmm &gmm, Matrix< BaseFloat > *xform)
	Computes the inverse of an LDA transform (without dimensionality reduction) The computed transform is used in initializing the phonetic and speaker subspaces, as well as while increasing the dimensions of those spaces. More...
static void	ApplyPreXformToGradient (const Sgmm2FmllrGlobalParams &globals, const Matrix< BaseFloat > &gradient_in, Matrix< BaseFloat > *gradient_out)
static void	ApplyInvPreXformToChange (const Sgmm2FmllrGlobalParams &globals, const Matrix< BaseFloat > &delta_in, Matrix< BaseFloat > *delta_out)
static void	ApplyHessianXformToGradient (const Sgmm2FmllrGlobalParams &globals, const Matrix< BaseFloat > &gradient_in, Matrix< BaseFloat > *gradient_out)
static void	ApplyInvHessianXformToChange (const Sgmm2FmllrGlobalParams &globals, const Matrix< BaseFloat > &delta_in, Matrix< BaseFloat > *delta_out)
static BaseFloat	CalcFmllrStepSize (const AffineXformStats &stats, const AmSgmm2 &sgmm, const MatrixBase< BaseFloat > &Delta, const MatrixBase< BaseFloat > &A, const Matrix< BaseFloat > &G, int32 max_iters)
void	EstimateSgmm2FmllrSubspace (const SpMatrix< double > &fmllr_grad_scatter, int32 num_fmllr_bases, int32 feat_dim, Sgmm2FmllrGlobalParams *fmllr_globals, double min_eig=0.0)
	Computes the fMLLR basis matrices given the scatter of the vectorized gradients (eq: B.10). More...
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const Matrix< BaseFloat > &transformed_feats, const std::vector< std::vector< int32 > > &gselect, const Posterior &post, const TransitionModel &trans_model, const AmSgmm2 &am_sgmm, BaseFloat logdet, Sgmm2PerSpkDerivedVars *spk_vars, FmllrSgmm2Accs *spk_stats)
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const Sgmm2GauPost &gpost, const TransitionModel &trans_model, const AmSgmm2 &am_sgmm, Sgmm2PerSpkDerivedVars *spk_vars, MleSgmm2SpeakerAccs *spk_stats)
void	AccumulateForUtterance (const Matrix< BaseFloat > &feats, const Posterior &post, const TransitionModel &trans_model, const AmSgmm2 &am_sgmm, const vector< vector< int32 > > &gselect, Sgmm2PerSpkDerivedVars *spk_vars, MleSgmm2SpeakerAccs *spk_stats)
void	ProcessUtterance (const AmSgmm2 &am_sgmm, const TransitionModel &trans_model, double log_prune, double acoustic_scale, const Matrix< BaseFloat > &features, RandomAccessInt32VectorVectorReader &gselect_reader, RandomAccessBaseFloatVectorReaderMapped &spkvecs_reader, const fst::SymbolTable *word_syms, const std::string &utt, bool determinize, bool allow_partial, Int32VectorWriter *alignments_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, LatticeFasterDecoder *decoder, double *like_sum, int64 *frame_sum, int32 *num_done, int32 *num_err, TaskSequencer< DecodeUtteranceLatticeFasterClass > *sequencer)
bool	ProcessUtterance (LatticeFasterDecoder &decoder, const AmSgmm2 &am_sgmm, const TransitionModel &trans_model, double log_prune, double acoustic_scale, const Matrix< BaseFloat > &features, RandomAccessInt32VectorVectorReader &gselect_reader, RandomAccessBaseFloatVectorReaderMapped &spkvecs_reader, const fst::SymbolTable *word_syms, const std::string &utt, bool determinize, bool allow_partial, Int32VectorWriter *alignments_writer, Int32VectorWriter *words_writer, CompactLatticeWriter *compact_lattice_writer, LatticeWriter *lattice_writer, double *like_ptr)
void	GetWeights (const std::string &weights_str, int32 num_inputs, std::vector< BaseFloat > *weights)
std::vector< bool >	GetSkipLayers (const std::string &skip_layers_str, const int32 first_layer_idx, const int32 last_layer_idx)
bool	SplitEgsKey (const std::string &key, std::string *utt_id, int32 *frame_id)
nnet2::Component *	ConvertAffineTransformComponent (const nnet1::Component &nnet1_component, const bool use_preconditioned_affine_component)
nnet2::Component *	ConvertSoftmaxComponent (const nnet1::Component &nnet1_component)
nnet2::Component *	ConvertSigmoidComponent (const nnet1::Component &nnet1_component)
nnet2::Component *	ConvertSpliceComponent (const nnet1::Component &nnet1_component)
nnet2::Component *	ConvertAddShiftComponent (const nnet1::Component &nnet1_component)
nnet2::Component *	ConvertRescaleComponent (const nnet1::Component &nnet1_component)
nnet2::Component *	ConvertComponent (const nnet1::Component &nnet1_component, const bool use_preconditioned_affine_component)
nnet2::Nnet *	ConvertNnet1ToNnet2 (const nnet1::Nnet &nnet1, const bool use_preconditioned_affine_component)
void	ReadModels (std::vector< std::pair< std::string, BaseFloat > > models_and_weights, nnet3::Nnet *output_nnet, int32 *success)
int32	GetCount (double expected_count)
void	SplitArgOnEquals (const std::string &arg, std::string *name, std::string *rspecifier)
void	HandleOutput (bool determinize, const fst::SymbolTable *word_syms, nnet3::NnetBatchDecoder *decoder, CompactLatticeWriter *clat_writer, LatticeWriter *lat_writer)
bool	CompareInterval (const Interval &i1, const Interval &i2)
bool	ClusterLattice (CompactLattice *clat, const std::vector< int32 > &state_times)
bool	CreateFactorTransducer (const CompactLattice &clat, const std::vector< int32 > &state_times, int32 utterance_id, KwsProductFst *factor_transducer)
void	RemoveLongSilences (int32 max_silence_frames, const std::vector< int32 > &state_times, KwsProductFst *factor_transducer)
template<class Arc >
static void	DifferenceWrapper (const fst::VectorFst< Arc > &fst1, const fst::VectorFst< Arc > &fst2, fst::VectorFst< Arc > *difference)
void	MaybeDoSanityCheck (const KwsLexicographicFst &index_transducer)
void	MaybeDoSanityCheck (const KwsProductFst &product_transducer)
void	DoFactorMerging (KwsProductFst *factor_transducer, KwsLexicographicFst *index_transducer)
void	DoFactorDisambiguation (KwsLexicographicFst *index_transducer)
void	OptimizeFactorTransducer (KwsLexicographicFst *index_transducer, int32 max_states, bool allow_partial)
template<class Arc >
static void	ReplaceSymbolWithEpsilon (typename Arc::Label symbol, fst::VectorFst< Arc > *fst)
uint64	EncodeLabel (StateId ilabel, StateId olabel)
StateId	DecodeLabelUid (uint64 osymbol)
bool	GenerateActivePaths (const KwsLexicographicFst &proxy, std::vector< ActivePath > *paths, KwsLexicographicFst::StateId cur_state, std::vector< KwsLexicographicArc::Label > cur_path, KwsLexicographicArc::Weight cur_weight)
void	SetLinearAcceptorWeight (double cost, fst::VectorFst< fst::StdArc > *fst)
void	AgglomerativeCluster (const Matrix< BaseFloat > &costs, BaseFloat threshold, int32 min_clusters, int32 first_pass_max_points, BaseFloat max_cluster_fraction, std::vector< int32 > *assignments_out)
	This is the function that is called to perform the agglomerative clustering. More...
void	TestIvectorExtractorIO (const IvectorExtractor &extractor)
void	TestIvectorExtractorStatsIO (IvectorExtractorStats &stats)
void	TestIvectorExtraction (const IvectorExtractor &extractor, const MatrixBase< BaseFloat > &feats, const FullGmm &fgmm)
void	UnitTestIvectorExtractor ()
static double	GetLogDetNoFailure (const SpMatrix< double > &var)
static void	ConvertPostToGaussInfo (const std::vector< std::vector< std::pair< int32, BaseFloat > > > &gauss_post, std::unordered_map< int32, GaussInfo > *gauss_info)
double	EstimateIvectorsOnline (const Matrix< BaseFloat > &feats, const Posterior &post, const IvectorExtractor &extractor, int32 ivector_period, int32 num_cg_iters, BaseFloat max_count, Matrix< BaseFloat > *ivectors)
void	UnitTestPosteriors ()
void	UnitTestTrain ()
void	UnitTestPldaEstimation (int32 dim)
template<class Real >
static void	ComputeNormalizingTransform (const SpMatrix< Real > &covar, MatrixBase< Real > *proj)
	This function computes a projection matrix that when applied makes the covariance unit (i.e. More...
void	ComputeVadEnergy (const VadEnergyOptions &opts, const MatrixBase< BaseFloat > &input_features, Vector< BaseFloat > *output_voiced)
	Compute voice-activity vector for a file: 1 if we judge the frame as voiced, 0 otherwise. More...
BaseFloat	ComputeEer (std::vector< BaseFloat > *target_scores, std::vector< BaseFloat > *nontarget_scores, BaseFloat *threshold)
	ComputeEer computes the Equal Error Rate (EER) for the given scores and returns it as a proportion beween 0 and 1. More...
void	PrepareMap (const std::string &map_rxfilename, int32 num_classes, unordered_map< int32, int32 > *map)
	PrepareMap creates a map that specifies the mapping between the input and output class labels. More...
void	PreparePriors (const std::string &priors_str, int32 num_classes, std::vector< BaseFloat > *priors)
	PreparePriors creates a table specifying the priors for each class. More...
template<class Real >
void	ComputeNormalizingTransform (const SpMatrix< Real > &covar, Real floor, MatrixBase< Real > *proj)
void	ComputeLdaTransform (const std::map< std::string, Vector< BaseFloat > *> &utt2ivector, const std::map< std::string, std::vector< std::string > > &spk2utt, BaseFloat total_covariance_factor, BaseFloat covariance_floor, MatrixBase< BaseFloat > *lda_out)
void	ComputeAndSubtractMean (std::map< std::string, Vector< BaseFloat > *> utt2ivector, Vector< BaseFloat > *mean_out)
int32	RunPerSpeaker (const std::string &ivector_extractor_rxfilename, const IvectorEstimationOptions &opts, bool compute_objf_change, const std::string &spk2utt_rspecifier, const std::string &feature_rspecifier, const std::string &posterior_rspecifier, const std::string &ivector_wspecifier)
bool	EstPca (const Matrix< BaseFloat > &ivector_mat, BaseFloat target_energy, const std::string &reco, Matrix< BaseFloat > *mat)
void	TransformIvectors (const Matrix< BaseFloat > &ivectors_in, const PldaConfig &plda_config, const Plda &plda, Matrix< BaseFloat > *ivectors_out)
void	ApplyPca (const Matrix< BaseFloat > &ivectors_in, const Matrix< BaseFloat > &pca_mat, Matrix< BaseFloat > *ivectors_out)
void	PrepareMap (const std::string map_rxfilename, unordered_map< std::pair< int32, int32 >, int32, PairHasher< int32 > > *map)
	PrepareMap creates a mapping between the pairs of VAD decisions and the output label. More...
int	PaCallback (const void *input, void *output, long unsigned frame_count, const PaStreamCallbackTimeInfo *time_info, PaStreamCallbackFlags status_flags, void *user_data)
template<class Real >
static void	AssertEqual (const Matrix< Real > &A, const Matrix< Real > &B, float tol=0.001)
void	GetOutput (OnlineFeatInputItf *a, Matrix< BaseFloat > *output)
void	TestOnlineMatrixInput ()
void	TestOnlineFeatureMatrix ()
void	TestOnlineLdaInput ()
void	TestOnlineDeltaInput ()
void	TestOnlineCmnInput ()
fst::Fst< fst::StdArc > *	ReadDecodeGraph (const std::string &filename)
void	PrintPartialResult (const std::vector< int32 > &words, const fst::SymbolTable *word_syms, bool line_break)
bool	WriteFull (int32 desc, char *data, int32 size)
bool	ReadLine (int32 desc, std::string *str)
std::string	TimeToTimecode (float time)
bool	WriteLine (int32 socket, std::string line)
void	SendPartialResult (const std::vector< int32 > &words, const fst::SymbolTable *word_syms, const bool line_break, const int32 serv_sock, const sockaddr_in &client_addr)
static bool	RuleActivated (const OnlineEndpointRule &rule, const std::string &rule_name, BaseFloat trailing_silence, BaseFloat relative_cost, BaseFloat utterance_length)
bool	EndpointDetected (const OnlineEndpointConfig &config, int32 num_frames_decoded, int32 trailing_silence_frames, BaseFloat frame_shift_in_seconds, BaseFloat final_relative_cost)
	This function returns true if this set of endpointing rules thinks we should terminate decoding. More...
template<typename FST , typename DEC >
int32	TrailingSilenceLength (const TransitionModel &tmodel, const std::string &silence_phones, const DEC &decoder)
	returns the number of frames of trailing silence in the best-path traceback (not using final-probs). More...
template<typename FST >
bool	EndpointDetected (const OnlineEndpointConfig &config, const TransitionModel &tmodel, BaseFloat frame_shift_in_seconds, const LatticeFasterOnlineDecoderTpl< FST > &decoder)
	This is a higher-level convenience function that works out the arguments to the EndpointDetected function above, from the decoder. More...
template<typename FST >
bool	EndpointDetected (const OnlineEndpointConfig &config, const TransitionModel &tmodel, BaseFloat frame_shift_in_seconds, const LatticeIncrementalOnlineDecoderTpl< FST > &decoder)
	This is a higher-level convenience function that works out the arguments to the EndpointDetected function above, from the decoder. More...
template bool	EndpointDetected< fst::Fst< fst::StdArc > > (const OnlineEndpointConfig &config, const TransitionModel &tmodel, BaseFloat frame_shift_in_seconds, const LatticeFasterOnlineDecoderTpl< fst::Fst< fst::StdArc > > &decoder)
template bool	EndpointDetected< fst::GrammarFst > (const OnlineEndpointConfig &config, const TransitionModel &tmodel, BaseFloat frame_shift_in_seconds, const LatticeFasterOnlineDecoderTpl< fst::GrammarFst > &decoder)
template bool	EndpointDetected< fst::Fst< fst::StdArc > > (const OnlineEndpointConfig &config, const TransitionModel &tmodel, BaseFloat frame_shift_in_seconds, const LatticeIncrementalOnlineDecoderTpl< fst::Fst< fst::StdArc > > &decoder)
template bool	EndpointDetected< fst::GrammarFst > (const OnlineEndpointConfig &config, const TransitionModel &tmodel, BaseFloat frame_shift_in_seconds, const LatticeIncrementalOnlineDecoderTpl< fst::GrammarFst > &decoder)
template void	OnlineSilenceWeighting::ComputeCurrentTraceback< fst::Fst< fst::StdArc > > (const LatticeFasterOnlineDecoderTpl< fst::Fst< fst::StdArc > > &decoder)
template void	OnlineSilenceWeighting::ComputeCurrentTraceback< fst::GrammarFst > (const LatticeFasterOnlineDecoderTpl< fst::GrammarFst > &decoder)
template void	OnlineSilenceWeighting::ComputeCurrentTraceback< fst::Fst< fst::StdArc > > (const LatticeIncrementalOnlineDecoderTpl< fst::Fst< fst::StdArc > > &decoder)
template void	OnlineSilenceWeighting::ComputeCurrentTraceback< fst::GrammarFst > (const LatticeIncrementalOnlineDecoderTpl< fst::GrammarFst > &decoder)
void	FindQuietestSegment (const Vector< BaseFloat > &wav_in, BaseFloat samp_rate, Vector< BaseFloat > *wav_sil, BaseFloat search_dur=0.5, BaseFloat seg_dur=0.1, BaseFloat seg_shift_dur=0.05)
void	ExtendWaveWithSilence (const Vector< BaseFloat > &wav_in, BaseFloat samp_rate, Vector< BaseFloat > *wav_out, BaseFloat sil_search_len, BaseFloat sil_extract_len, BaseFloat sil_extract_shift)
std::string	LatticeToString (const Lattice &lat, const fst::SymbolTable &word_syms)
std::string	GetTimeString (int32 t_beg, int32 t_end, BaseFloat time_unit)
int32	GetLatticeTimeSpan (const Lattice &lat)
std::string	LatticeToString (const CompactLattice &clat, const fst::SymbolTable &word_syms)
void	GetDiagnosticsAndPrintOutput (const std::string &utt, const fst::SymbolTable *word_syms, const CompactLattice &clat, int64 *tot_num_frames, double *tot_like)
template<typename Real >
Real	TraceMatMat (const MatrixBase< Real > &A, const MatrixBase< Real > &B, MatrixTransposeType trans=kNoTrans)
	We need to declare this here as it will be a friend function. More...
void	AccumulateTreeStats (const TransitionModel &trans_model, const AccumulateTreeStatsInfo &info, const std::vector< int32 > &alignment, const Matrix< BaseFloat > &features, std::map< EventType, GaussClusterable * > *stats)
	Accumulates the stats needed for training context-dependency trees (in the "normal" way). More...
void	ReadPhoneMap (std::string phone_map_rxfilename, std::vector< int32 > *phone_map)

Variables
int32	g_kaldi_verbose_level = 0
	This is set by util/parse-options. More...
static std::string	program_name
static LogHandler	log_handler = NULL
static std::mutex	_RandMutex
static const double	kMinLogDiffDouble = Log(DBL_EPSILON)
static const float	kMinLogDiffFloat = Log(FLT_EPSILON)
const float	kLogZeroFloat = -std::numeric_limits<float>::infinity()
const double	kLogZeroDouble = -std::numeric_limits<double>::infinity()
const BaseFloat	kLogZeroBaseFloat = -std::numeric_limits<BaseFloat>::infinity()
ProfileStats	g_profile_stats
int32	g_num_threads = 8
static ShellType	kShellType = kBash
const char *	ws_delim = " \t\n\r"
bool	pitch_use_naive_search = false
const BaseFloat	kWaveSampleMax = 32768.0
	For historical reasons, we scale waveforms to the range (2^15-1)*[-1, 1], not the usual default DSP range [-1, 1]. More...
static const EventKeyType	kPdfClass = -1
const int32	kMaxVal = 20
static const int32	kNoPdf = -1
	A constant used in the HmmTopology class as the pdf-class kNoPdf, which is used when a HMM-state is nonemitting (has no associated PDF). More...
static const int	kRandomSentences = 50
const int	kTemporaryEpsilon = -2
const int	kNumStatesOffset = 1000
CuAllocatorOptions	g_allocator_options
int32	buffer_offset = 0
int32	buffer_fill = 0
char	read_buffer [1025]
const float	kFramesPerSecond = 100.0f

Detailed Description

This code computes Goodness of Pronunciation (GOP) and extracts phone-level pronunciation feature for mispronunciations detection tasks, the reference:

Relabels neural network egs with the read pdf-id alignments.

"Improved mispronunciation detection with deep neural network trained acoustic models and transfer learning based logistic regression classifiers" by Hu et al., Speech Comunication, 2015.

GOP is widely used to detect mispronunciations. The DNN-based GOP was defined as the log phone posterior ratio between the canonical phone and the one with the highest score.

To compute GOP, we need to compute Log Phone Posterior (LPP): LPP(p) = p(p| o; t_s,t_e) where { o} is the input observations, p is the canonical phone, {t_s, t_e} are the start and end frame indexes.

LPP could be calculated as the average of the frame-level LPP, i.e. p(p|o_t): LPP(p) = {1}{t_e-t_s+1} {t=t_s}^{t_e} p(p|o_t) p(p|o_t) = {s p} p(s|o_t) where s is the senone label, {s|s p} is the states belonging to those triphones whose current phone is p.

GOP is extracted from LPP: GOP(p) = {LPP(p)}{{q Q} LPP(q)}

An array of a phone-level feature for each phone is extracted as well, which could be used to train a classifier to detect mispronunciations. Normally the classifier-based approach archives better performance than the GOP-based approach.

The phone-level feature is defined as: {[LPP(p_1),,LPP(p_M), LPR(p_1|p_i), , LPR(p_j|p_i),]}^T

where the Log Posterior Ratio (LPR) between phone p_j and p_i is defined as: LPR(p_j|p_i) = p(p_j| o; t_s, t_e) - p(p_i| o; t_s, t_e)

Typedef Documentation

Arc

typedef KwsLexicographicArc Arc

Definition at line 35 of file lattice-determinize-non-compact.cc.

BaseFloat

typedef float BaseFloat

Definition at line 29 of file kaldi-types.h.

CompactLattice

typedef fst::VectorFst<CompactLatticeArc> CompactLattice

Definition at line 46 of file kaldi-lattice.h.

CompactLatticeArc

typedef fst::ArcTpl<CompactLatticeWeight> CompactLatticeArc

Definition at line 42 of file kaldi-lattice.h.

CompactLatticeWeight

typedef fst::CompactLatticeWeightTpl<LatticeWeight, int32> CompactLatticeWeight

Definition at line 35 of file kaldi-lattice.h.

CompactLatticeWeightCommonDivisor

typedef fst::CompactLatticeWeightCommonDivisorTpl<LatticeWeight, int32> CompactLatticeWeightCommonDivisor

Definition at line 38 of file kaldi-lattice.h.

CompactLatticeWriter

typedef TableWriter<CompactLatticeHolder> CompactLatticeWriter

Definition at line 149 of file kaldi-lattice.h.

double64

typedef double double64

Definition at line 54 of file kaldi-types.h.

EventAnswerType

typedef int32 EventAnswerType

As far as the event-map code itself is concerned, things of type EventAnswerType may take any value except kNoAnswer (== -1).

However, some specific uses of EventMap (e.g. in build-tree-utils.h) assume these quantities are nonnegative.

Definition at line 56 of file event-map.h.

EventKeyType

typedef int32 EventKeyType

Things of type EventKeyType can take any value.

The code does not assume they are contiguous. So values like -1, 1000000 and the like are acceptable.

Definition at line 45 of file event-map.h.

EventType

typedef std::vector<std::pair<EventKeyType, EventValueType> > EventType

Definition at line 58 of file event-map.h.

EventValueType

typedef int32 EventValueType

Given current code, things of type EventValueType should generally be nonnegative and in a reasonably small range (e.g.

not one million), as we sometimes construct vectors of the size: [largest value we saw for this key]. This deficiency may be fixed in future [would require modifying TableEventMap]

Definition at line 51 of file event-map.h.

float32

typedef float float32

Definition at line 53 of file kaldi-types.h.

GmmFlagsType

typedef uint16 GmmFlagsType

Bitwise OR of the above flags.

Definition at line 35 of file model-common.h.

int32

typedef kaldi::int32 int32

Definition at line 27 of file online-tcp-source.cc.

int_smaller

typedef int16 int_smaller

Definition at line 33 of file cluster-utils.cc.

KwsLexicographicArc

typedef StdLStdLStdArc KwsLexicographicArc

Definition at line 45 of file kaldi-kws.h.

KwsLexicographicFst

typedef fst::VectorFst<KwsLexicographicArc> KwsLexicographicFst

Definition at line 46 of file kaldi-kws.h.

KwsLexicographicWeight

typedef StdLStdLStdWeight KwsLexicographicWeight

Definition at line 44 of file kaldi-kws.h.

KwsProductArc

typedef LogXStdXStdprimeArc KwsProductArc

Definition at line 48 of file kaldi-kws.h.

KwsProductFst

typedef fst::VectorFst<KwsProductArc> KwsProductFst

Definition at line 49 of file kaldi-kws.h.

KwsProductWeight

typedef LogXStdXStdprimeWeight KwsProductWeight

Definition at line 47 of file kaldi-kws.h.

Label

typedef fst::StdArc::Label Label

Definition at line 32 of file lattice-oracle.cc.

LabelPairVector

typedef std::vector<std::pair<Label, Label> > LabelPairVector

Definition at line 33 of file lattice-oracle.cc.

Lattice

typedef fst::VectorFst<LatticeArc> Lattice

Definition at line 44 of file kaldi-lattice.h.

LatticeArc

typedef fst::ArcTpl<LatticeWeight> LatticeArc

Definition at line 40 of file kaldi-lattice.h.

LatticeBiglmFasterDecoderConfig

typedef LatticeFasterDecoderConfig LatticeBiglmFasterDecoderConfig

Definition at line 37 of file lattice-biglm-faster-decoder.h.

LatticeFasterDecoder

typedef LatticeFasterDecoderTpl<fst::StdFst, decoder::StdToken> LatticeFasterDecoder

Definition at line 522 of file lattice-faster-decoder.h.

LatticeFasterOnlineDecoder

typedef LatticeFasterOnlineDecoderTpl<fst::StdFst> LatticeFasterOnlineDecoder

Definition at line 142 of file lattice-faster-online-decoder.h.

LatticeIncrementalDecoder

typedef LatticeIncrementalDecoderTpl<fst::StdFst, decoder::StdToken> LatticeIncrementalDecoder

Definition at line 724 of file lattice-incremental-decoder.h.

LatticeIncrementalOnlineDecoder

typedef LatticeIncrementalOnlineDecoderTpl<fst::StdFst> LatticeIncrementalOnlineDecoder

Definition at line 127 of file lattice-incremental-online-decoder.h.

LatticeWeight

typedef fst::LatticeWeightTpl<BaseFloat> LatticeWeight

Definition at line 32 of file kaldi-lattice.h.

LatticeWriter

typedef TableWriter<LatticeHolder> LatticeWriter

Definition at line 145 of file kaldi-lattice.h.

LogXStdXStdprimeArc

typedef fst::ArcTpl<LogXStdXStdprimeWeight> LogXStdXStdprimeArc

Definition at line 41 of file kaldi-kws.h.

LogXStdXStdprimeWeight

typedef fst::ProductWeight<LogWeight, StdXStdprimeWeight> LogXStdXStdprimeWeight

Definition at line 40 of file kaldi-kws.h.

MapAmDiagGmmSeqReader

typedef SequentialTableReader< KaldiObjectHolder<AmDiagGmm> > MapAmDiagGmmSeqReader

Definition at line 133 of file mle-am-diag-gmm.h.

MapAmDiagGmmWriter

typedef TableWriter< KaldiObjectHolder<AmDiagGmm> > MapAmDiagGmmWriter

Definition at line 130 of file mle-am-diag-gmm.h.

MatrixIndexT

typedef int32 MatrixIndexT

Definition at line 98 of file matrix-common.h.

PipebufType

typedef basic_pipebuf<char> PipebufType

Definition at line 55 of file kaldi-io.cc.

RandomAccessCompactLatticeReader

typedef RandomAccessTableReader<CompactLatticeHolder> RandomAccessCompactLatticeReader

Definition at line 151 of file kaldi-lattice.h.

RandomAccessLatticeReader

typedef RandomAccessTableReader<LatticeHolder> RandomAccessLatticeReader

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

RandomAccessMapAmDiagGmmReader

typedef RandomAccessTableReader< KaldiObjectHolder<AmDiagGmm> > RandomAccessMapAmDiagGmmReader

Definition at line 131 of file mle-am-diag-gmm.h.

RandomAccessMapAmDiagGmmReaderMapped

typedef RandomAccessTableReaderMapped< KaldiObjectHolder<AmDiagGmm> > RandomAccessMapAmDiagGmmReaderMapped

Definition at line 132 of file mle-am-diag-gmm.h.

RandomAccessRegtreeFmllrDiagGmmReader

typedef RandomAccessTableReader< KaldiObjectHolder<RegtreeFmllrDiagGmm> > RandomAccessRegtreeFmllrDiagGmmReader

Definition at line 138 of file regtree-fmllr-diag-gmm.h.

RandomAccessRegtreeFmllrDiagGmmReaderMapped

typedef RandomAccessTableReaderMapped< KaldiObjectHolder<RegtreeFmllrDiagGmm> > RandomAccessRegtreeFmllrDiagGmmReaderMapped

Definition at line 140 of file regtree-fmllr-diag-gmm.h.

RandomAccessRegtreeMllrDiagGmmReader

typedef RandomAccessTableReader< KaldiObjectHolder<RegtreeMllrDiagGmm> > RandomAccessRegtreeMllrDiagGmmReader

Definition at line 156 of file regtree-mllr-diag-gmm.h.

RandomAccessRegtreeMllrDiagGmmReaderMapped

typedef RandomAccessTableReaderMapped< KaldiObjectHolder<RegtreeMllrDiagGmm> > RandomAccessRegtreeMllrDiagGmmReaderMapped

Definition at line 158 of file regtree-mllr-diag-gmm.h.

RandomAccessSgmm2GauPostReader

typedef RandomAccessTableReader<Sgmm2GauPostHolder> RandomAccessSgmm2GauPostReader

Definition at line 579 of file am-sgmm2.h.

RegtreeFmllrDiagGmmSeqReader

typedef SequentialTableReader< KaldiObjectHolder<RegtreeFmllrDiagGmm> > RegtreeFmllrDiagGmmSeqReader

Definition at line 141 of file regtree-fmllr-diag-gmm.h.

RegtreeFmllrDiagGmmWriter

typedef TableWriter< KaldiObjectHolder<RegtreeFmllrDiagGmm> > RegtreeFmllrDiagGmmWriter

Definition at line 136 of file regtree-fmllr-diag-gmm.h.

RegtreeMllrDiagGmmSeqReader

typedef SequentialTableReader< KaldiObjectHolder<RegtreeMllrDiagGmm> > RegtreeMllrDiagGmmSeqReader

Definition at line 160 of file regtree-mllr-diag-gmm.h.

RegtreeMllrDiagGmmWriter

typedef TableWriter< KaldiObjectHolder<RegtreeMllrDiagGmm> > RegtreeMllrDiagGmmWriter

Definition at line 154 of file regtree-mllr-diag-gmm.h.

SequentialCompactLatticeReader

typedef SequentialTableReader<CompactLatticeHolder> SequentialCompactLatticeReader

Definition at line 150 of file kaldi-lattice.h.

SequentialLatticeReader

typedef SequentialTableReader<LatticeHolder> SequentialLatticeReader

Definition at line 146 of file kaldi-lattice.h.

SequentialSgmm2GauPostReader

typedef SequentialTableReader<Sgmm2GauPostHolder> SequentialSgmm2GauPostReader

Definition at line 580 of file am-sgmm2.h.

Sgmm2GauPostHolder

typedef KaldiObjectHolder<Sgmm2GauPost> Sgmm2GauPostHolder

Definition at line 578 of file am-sgmm2.h.

Sgmm2GauPostWriter

typedef TableWriter<Sgmm2GauPostHolder> Sgmm2GauPostWriter

Definition at line 581 of file am-sgmm2.h.

SgmmUpdateFlagsType

typedef uint16 SgmmUpdateFlagsType

Bitwise OR of the above flags.

Definition at line 59 of file model-common.h.

SgmmWriteFlagsType

typedef uint16 SgmmWriteFlagsType

Bitwise OR of the above flags.

Definition at line 70 of file model-common.h.

SignedMatrixIndexT

typedef int32 SignedMatrixIndexT

Definition at line 99 of file matrix-common.h.

StateId

typedef Arc::StateId StateId

Definition at line 34 of file lattice-determinize-non-compact.cc.

StdLStdLStdArc

typedef fst::ArcTpl<StdLStdLStdWeight> StdLStdLStdArc

Definition at line 36 of file kaldi-kws.h.

StdLStdLStdWeight

typedef fst::LexicographicWeight<TropicalWeight, StdLStdWeight> StdLStdLStdWeight

Definition at line 35 of file kaldi-kws.h.

StdLStdWeight

typedef fst::LexicographicWeight<TropicalWeight, TropicalWeight> StdLStdWeight

Definition at line 34 of file kaldi-kws.h.

StdXStdprimeWeight

typedef fst::ProductWeight<TropicalWeight, ArcticWeight> StdXStdprimeWeight

Definition at line 39 of file kaldi-kws.h.

uint_smaller

typedef uint16 uint_smaller

Definition at line 32 of file cluster-utils.cc.

UnsignedMatrixIndexT

typedef uint32 UnsignedMatrixIndexT

Definition at line 100 of file matrix-common.h.

Weight

typedef Arc::Weight Weight

Definition at line 31 of file kws-search.cc.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kEps
kDisambig
kBos
kEos

Definition at line 33 of file arpa-lm-compiler-test.cc.

     {
  kEps = 0,
  kDisambig,
  kBos, kEos,
};

cova_type

enum cova_type

Generate features for a certain covariance type covariance_type == 0: full covariance covariance_type == 1: diagonal covariance.

Enumerator
full
diag

Definition at line 58 of file regtree-fmllr-diag-gmm-test.cc.

               {
  full,
  diag
};

CuCompressedMatrixType

enum CuCompressedMatrixType

Enumerator
kCompressedMatrixInt8
kCompressedMatrixUint8
kCompressedMatrixInt16
kCompressedMatrixUint16

Definition at line 140 of file cu-compressed-matrix.h.

                             {
  kCompressedMatrixInt8 = 1,
  kCompressedMatrixUint8 = 2,
  kCompressedMatrixInt16 = 3,
  kCompressedMatrixUint16 = 4
};

DetectionDecision

enum DetectionDecision

Enumerator
kKwsFalseAlarm
kKwsMiss
kKwsCorr
kKwsCorrUndetected
kKwsUnseen

Definition at line 81 of file kws-scoring.h.

                       {
  kKwsFalseAlarm,      // Marked incorrectly as a hit
  kKwsMiss,            // Not marked as hit while it should be
  kKwsCorr,            // Marked correctly as a hit
  kKwsCorrUndetected,  // Not marked as a hit, correctly
  kKwsUnseen           // Instance not seen in the hypotheses list
};

GmmUpdateFlags

enum GmmUpdateFlags

Enumerator
kGmmMeans
kGmmVariances
kGmmWeights
kGmmTransitions
kGmmAll

Definition at line 28 of file model-common.h.

                    {
  kGmmMeans       = 0x001,  // m
  kGmmVariances   = 0x002,  // v
  kGmmWeights     = 0x004,  // w
  kGmmTransitions = 0x008,  // t ... not really part of GMM.
  kGmmAll       = 0x00F  // a
};

MatrixResizeType

enum MatrixResizeType

Enumerator
kSetZero
kUndefined
kCopyData

Definition at line 37 of file matrix-common.h.

             {
  kSetZero,
  kUndefined,
  kCopyData
} MatrixResizeType;

MatrixStrideType

enum MatrixStrideType

Enumerator
kDefaultStride
kStrideEqualNumCols

Definition at line 44 of file matrix-common.h.

             {
  kDefaultStride,
  kStrideEqualNumCols,
} MatrixStrideType;

MatrixTransposeType

enum MatrixTransposeType

Enumerator
kTrans
kNoTrans

Definition at line 32 of file matrix-common.h.

             {
  kTrans    = 112, // = CblasTrans
  kNoTrans  = 111  // = CblasNoTrans
} MatrixTransposeType;

SgmmUpdateFlags

enum SgmmUpdateFlags

Enumerator
kSgmmPhoneVectors	The letters correspond to the variable names.
kSgmmPhoneProjections	v
kSgmmPhoneWeightProjections	M.
kSgmmCovarianceMatrix	w
kSgmmSubstateWeights	S.
kSgmmSpeakerProjections	c
kSgmmTransitions	N.
kSgmmSpeakerWeightProjections	t .. not really part of SGMM.
kSgmmAll	u [ for SSGMM ]

Definition at line 47 of file model-common.h.

                     {  
  kSgmmPhoneVectors                = 0x001,  
  kSgmmPhoneProjections            = 0x002,  
  kSgmmPhoneWeightProjections      = 0x004,  
  kSgmmCovarianceMatrix            = 0x008,  
  kSgmmSubstateWeights             = 0x010,  
  kSgmmSpeakerProjections          = 0x020,  
  kSgmmTransitions                 = 0x040,  
  kSgmmSpeakerWeightProjections    = 0x080,  
  kSgmmAll                         = 0x0FF   
};

SgmmWriteFlags

enum SgmmWriteFlags

Enumerator
kSgmmGlobalParams
kSgmmStateParams	g
kSgmmNormalizers	s
kSgmmBackgroundGmms	n
kSgmmWriteAll	u

Definition at line 62 of file model-common.h.

                    {
  kSgmmGlobalParams    = 0x001,  
  kSgmmStateParams     = 0x002,  
  kSgmmNormalizers     = 0x004,  
  kSgmmBackgroundGmms  = 0x008,  
  kSgmmWriteAll        = 0x00F  
};

ShellType

enum ShellType

Enumerator
kBash

Definition at line 210 of file parse-options.cc.

{ kBash = 0 };

SpCopyType

enum SpCopyType

Enumerator
kTakeLower
kTakeUpper
kTakeMean
kTakeMeanAndCheck

Definition at line 49 of file matrix-common.h.

             {
  kTakeLower,
  kTakeUpper,
  kTakeMean,
  kTakeMeanAndCheck
} SpCopyType;

Function Documentation

_RandGauss()

static float kaldi::_RandGauss ( )

inlinestatic

Definition at line 34 of file am-sgmm2.cc.

References RandGauss().

Referenced by AmSgmm2::SplitSubstatesInGroup().

{
  return RandGauss();
}

AccCmvnStats() [1/2]

void AccCmvnStats	(	const VectorBase< BaseFloat > &	feats,
		BaseFloat	weight,
		MatrixBase< double > *	stats
	)

Accumulation from a single frame (weighted).

Definition at line 30 of file cmvn.cc.

References VectorBase< Real >::Data(), VectorBase< Real >::Dim(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::RowData().

Referenced by AccCmvnStats(), AccCmvnStatsForPair(), AccCmvnStatsWrapper(), and main().

                                                                                                   {
  int32 dim = feats.Dim();
  KALDI_ASSERT(stats != NULL);
  KALDI_ASSERT(stats->NumRows() == 2 && stats->NumCols() == dim + 1);
  // Remove these __restrict__ modifiers if they cause compilation problems.
  // It's just an optimization.
   double *__restrict__ mean_ptr = stats->RowData(0),
       *__restrict__ var_ptr = stats->RowData(1),
       *__restrict__ count_ptr = mean_ptr + dim;
   const BaseFloat * __restrict__ feats_ptr = feats.Data();
  *count_ptr += weight;
  // Careful-- if we change the format of the matrix, the "mean_ptr < count_ptr"
  // statement below might become wrong.
  for (; mean_ptr < count_ptr; mean_ptr++, var_ptr++, feats_ptr++) {
    *mean_ptr += *feats_ptr * weight;
    *var_ptr +=  *feats_ptr * *feats_ptr * weight;
  }
}

AccCmvnStats() [2/2]

void AccCmvnStats	(	const MatrixBase< BaseFloat > &	feats,
		const VectorBase< BaseFloat > *	weights,
		MatrixBase< double > *	stats
	)

Accumulation from a feature file (possibly weighted– useful in excluding silence).

Definition at line 49 of file cmvn.cc.

References AccCmvnStats(), VectorBase< Real >::Dim(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

                                             {
  int32 num_frames = feats.NumRows();
  if (weights != NULL) {
    KALDI_ASSERT(weights->Dim() == num_frames);
  }
  for (int32 i = 0; i < num_frames; i++) {
    SubVector<BaseFloat> this_frame = feats.Row(i);
    BaseFloat weight = (weights == NULL ? 1.0 : (*weights)(i));
    if (weight != 0.0)
      AccCmvnStats(this_frame, weight, stats);
  }
}

AccCmvnStatsForPair()

void kaldi::AccCmvnStatsForPair	(	const std::string &	utt1,
		const std::string &	utt2,
		const MatrixBase< BaseFloat > &	feats1,
		const MatrixBase< BaseFloat > &	feats2,
		BaseFloat	quieter_channel_weight,
		MatrixBase< double > *	cmvn_stats1,
		MatrixBase< double > *	cmvn_stats2
	)

Definition at line 69 of file compute-cmvn-stats-two-channel.cc.

References AccCmvnStats(), rnnlm::i, KALDI_ASSERT, KALDI_WARN, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by main().

                                                          {
  KALDI_ASSERT(feats1.NumCols() == feats2.NumCols()); // same dim.
  if (feats1.NumRows() != feats2.NumRows()) {
    KALDI_WARN << "Number of frames differ between " << utt1 << " and " << utt2
               << ": " << feats1.NumRows() << " vs. " << feats2.NumRows()
               << ", treating them separately.";
    AccCmvnStats(feats1, NULL, cmvn_stats1);
    AccCmvnStats(feats2, NULL, cmvn_stats2);
    return;
  }

  for (int32 i = 0; i < feats1.NumRows(); i++) {
    if (feats1(i, 0) > feats2(i, 0)) {
      AccCmvnStats(feats1.Row(i), 1.0, cmvn_stats1);
      AccCmvnStats(feats2.Row(i), quieter_channel_weight, cmvn_stats2);
    }
    else {
      AccCmvnStats(feats2.Row(i), 1.0, cmvn_stats2);
      AccCmvnStats(feats1.Row(i), quieter_channel_weight, cmvn_stats1);
    }
  }
}

AccCmvnStatsWrapper()

bool kaldi::AccCmvnStatsWrapper	(	const std::string &	utt,
		const MatrixBase< BaseFloat > &	feats,
		RandomAccessBaseFloatVectorReader *	weights_reader,
		Matrix< double > *	cmvn_stats
	)

Definition at line 28 of file compute-cmvn-stats.cc.

References AccCmvnStats(), VectorBase< Real >::Dim(), RandomAccessTableReader< Holder >::HasKey(), RandomAccessTableReader< Holder >::IsOpen(), KALDI_WARN, MatrixBase< Real >::NumRows(), and RandomAccessTableReader< Holder >::Value().

Referenced by main().

                                                     {
  if (!weights_reader->IsOpen()) {
    AccCmvnStats(feats, NULL, cmvn_stats);
    return true;
  } else {
    if (!weights_reader->HasKey(utt)) {
      KALDI_WARN << "No weights available for utterance " << utt;
      return false;
    }
    const Vector<BaseFloat> &weights = weights_reader->Value(utt);
    if (weights.Dim() != feats.NumRows()) {
      KALDI_WARN << "Weights for utterance " << utt << " have wrong dimension "
                 << weights.Dim() << " vs. " << feats.NumRows();
      return false;
    }
    AccCmvnStats(feats, &weights, cmvn_stats);
    return true;
  }
}

AccStatsForUtterance() [1/2]

void kaldi::AccStatsForUtterance	(	const TransitionModel &	trans_model,
		const AmDiagGmm &	am_gmm,
		const GaussPost &	gpost,
		const Matrix< BaseFloat > &	feats,
		FmllrRawAccs *	accs
	)

Definition at line 31 of file gmm-est-fmllr-raw-gpost.cc.

References FmllrRawAccs::AccumulateFromPosteriors(), AmDiagGmm::GetPdf(), rnnlm::i, and MatrixBase< Real >::Row().

Referenced by UtteranceSplitter::ExitStatus(), IvectorExtractorStats::IvectorExtractorStats(), and main().

                                              {
  for (size_t t = 0; t < gpost.size(); t++) {
    for (size_t i = 0; i < gpost[t].size(); i++) {
      int32 pdf = gpost[t][i].first;
      const Vector<BaseFloat> &posterior(gpost[t][i].second);      
      accs->AccumulateFromPosteriors(am_gmm.GetPdf(pdf),
                                     feats.Row(t), posterior);
    }
  }
}

AccStatsForUtterance() [2/2]

void kaldi::AccStatsForUtterance	(	const TransitionModel &	trans_model,
		const AmDiagGmm &	am_gmm,
		const Posterior &	post,
		const Matrix< BaseFloat > &	feats,
		FmllrRawAccs *	accs
	)

Definition at line 31 of file gmm-est-fmllr-raw.cc.

References FmllrRawAccs::AccumulateForGmm(), ConvertPosteriorToPdfs(), AmDiagGmm::GetPdf(), rnnlm::i, and MatrixBase< Real >::Row().

                                              {
  Posterior pdf_post;
  ConvertPosteriorToPdfs(trans_model, post, &pdf_post);
  for (size_t t = 0; t < post.size(); t++) {
    for (size_t i = 0; i < pdf_post[t].size(); i++) {
      int32 pdf = pdf_post[t][i].first;
      BaseFloat weight = pdf_post[t][i].second;
      accs->AccumulateForGmm(am_gmm.GetPdf(pdf),
                             feats.Row(t), weight);
    }
  }
}

AccumulateForUtterance() [1/8]

bool kaldi::AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const DiagGmm &	gmm,
		const std::string &	key,
		RandomAccessBaseFloatVectorReader *	weights_reader,
		RandomAccessInt32VectorVectorReader *	gselect_reader,
		AccumFullGmm *	fullcov_stats
	)

Definition at line 32 of file gmm-global-est-fmllr.cc.

References AccumFullGmm::AccumulateForComponent(), AccumFullGmm::AccumulateFromDiag(), VectorBase< Real >::Dim(), RandomAccessTableReader< Holder >::HasKey(), rnnlm::i, RandomAccessTableReader< Holder >::IsOpen(), KALDI_WARN, DiagGmm::LogLikelihoodsPreselect(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), and RandomAccessTableReader< Holder >::Value().

                                                         {
  Vector<BaseFloat> weights;
  if (weights_reader->IsOpen()) {
    if (!weights_reader->HasKey(key)) {
      KALDI_WARN << "No weights present for utterance " << key;
      return false;
    }
    weights = weights_reader->Value(key);
  }
  int32 num_frames = feats.NumRows();
  if (gselect_reader->IsOpen()) {
    if (!gselect_reader->HasKey(key)) {
      KALDI_WARN << "No gselect information present for utterance " << key;
      return false;
    }
    const std::vector<std::vector<int32> > &gselect(gselect_reader->Value(key));
    if (gselect.size() != num_frames) {
      KALDI_WARN << "gselect information has wrong size for utterance " << key;
      return false;
    }
    for (int32 t = 0; t < num_frames; t++) {
      const std::vector<int32> &this_gselect(gselect[t]);
      BaseFloat weight = (weights.Dim() != 0 ? weights(t) : 1.0);
      if (weight != 0.0) {
        Vector<BaseFloat> post(this_gselect.size());
        gmm.LogLikelihoodsPreselect(feats.Row(t), this_gselect, &post);
        post.ApplySoftMax(); // get posteriors.
        post.Scale(weight); // scale by the weight for this frame.
        for (size_t i = 0; i < this_gselect.size(); i++)
          fullcov_stats->AccumulateForComponent(feats.Row(t),
                                                this_gselect[i], post(i));
      }
    }
  } else {
    for (int32 t = 0; t < num_frames; t++) {
      BaseFloat weight = (weights.Dim() != 0 ? weights(t) : 1.0);
      if (weight != 0.0)
        fullcov_stats->AccumulateFromDiag(gmm, feats.Row(t), weight);
    }
  }
  return true;
}

AccumulateForUtterance() [2/8]

void kaldi::AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const Sgmm2GauPost &	gpost,
		const TransitionModel &	trans_model,
		const AmSgmm2 &	am_sgmm,
		Sgmm2PerSpkDerivedVars *	spk_vars,
		MleSgmm2SpeakerAccs *	spk_stats
	)

Definition at line 33 of file sgmm2-est-spkvecs-gpost.cc.

References MleSgmm2SpeakerAccs::AccumulateFromPosteriors(), AmSgmm2::ComputePerFrameVars(), rnnlm::i, rnnlm::j, MatrixBase< Real >::Row(), and TransitionModel::TransitionIdToPdf().

                                                            {
  kaldi::Sgmm2PerFrameDerivedVars per_frame_vars;

  for (size_t i = 0; i < gpost.size(); i++) {
    am_sgmm.ComputePerFrameVars(feats.Row(i),
                                gpost[i].gselect, *spk_vars,
                                &per_frame_vars);

    for (size_t j = 0; j < gpost[i].tids.size(); j++) {
      int32 pdf_id = trans_model.TransitionIdToPdf(gpost[i].tids[j]);
      spk_stats->AccumulateFromPosteriors(am_sgmm, per_frame_vars,
                                          gpost[i].posteriors[j], pdf_id,
                                          spk_vars);
    }
  }
}

AccumulateForUtterance() [3/8]

void kaldi::AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const Posterior &	post,
		const DiagGmm &	gmm,
		FmllrDiagGmmAccs *	spk_stats
	)

Definition at line 34 of file gmm-global-est-lvtln-trans.cc.

References FmllrDiagGmmAccs::AccumulateFromPosteriorsPreselect(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

                                                         {
  KALDI_ASSERT(static_cast<int32>(post.size()) == feats.NumRows());
  for (size_t i = 0; i < post.size(); i++) {
    std::vector<int32> gselect(post[i].size());
    Vector<BaseFloat> this_post(post[i].size());
    for (size_t j = 0; j < post[i].size(); j++) {
      int32 g = post[i][j].first;
      BaseFloat weight = post[i][j].second;
      gselect[j] = g;
      this_post(j) = weight;
    }
    spk_stats->AccumulateFromPosteriorsPreselect(gmm, gselect,
                                                 feats.Row(i),
                                                 this_post);
  }
}

AccumulateForUtterance() [4/8]

void kaldi::AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const GaussPost &	gpost,
		const AmDiagGmm &	am_gmm,
		FmllrDiagGmmAccs *	spk_stats
	)

Definition at line 34 of file gmm-est-lvtln-trans.cc.

References FmllrDiagGmmAccs::AccumulateFromPosteriors(), AmDiagGmm::GetPdf(), rnnlm::i, rnnlm::j, and MatrixBase< Real >::Row().

                                                         {
  for (size_t i = 0; i < gpost.size(); i++) {
    for (size_t j = 0; j < gpost[i].size(); j++) {
      int32 pdf_id = gpost[i][j].first;
      const Vector<BaseFloat> &posterior(gpost[i][j].second);
      spk_stats->AccumulateFromPosteriors(am_gmm.GetPdf(pdf_id),
                                          feats.Row(i), posterior);
    }
  }
}

AccumulateForUtterance() [5/8]

void AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const GaussPost &	gpost,
		const TransitionModel &	trans_model,
		const AmDiagGmm &	am_gmm,
		FmllrDiagGmmAccs *	spk_stats
	)

Definition at line 35 of file gmm-basis-fmllr-accs-gpost.cc.

References FmllrDiagGmmAccs::AccumulateFromPosteriors(), AmDiagGmm::GetPdf(), rnnlm::i, rnnlm::j, and MatrixBase< Real >::Row().

Referenced by main().

                                                         {
  for (size_t i = 0; i < gpost.size(); i++) {
    for (size_t j = 0; j < gpost[i].size(); j++) {
      int32 pdf_id = gpost[i][j].first;
      const Vector<BaseFloat> & posterior(gpost[i][j].second);
      spk_stats->AccumulateFromPosteriors(am_gmm.GetPdf(pdf_id),
                                          feats.Row(i), posterior);
    }
  }
}

AccumulateForUtterance() [6/8]

void AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const Posterior &	post,
		const TransitionModel &	trans_model,
		const AmDiagGmm &	am_gmm,
		FmllrDiagGmmAccs *	spk_stats
	)

Definition at line 35 of file gmm-basis-fmllr-accs.cc.

References FmllrDiagGmmAccs::AccumulateForGmm(), ConvertPosteriorToPdfs(), AmDiagGmm::GetPdf(), rnnlm::i, rnnlm::j, and MatrixBase< Real >::Row().

                                                         {
  Posterior pdf_post;
  ConvertPosteriorToPdfs(trans_model, post, &pdf_post);
  for (size_t i = 0; i < post.size(); i++) {
    for (size_t j = 0; j < pdf_post[i].size(); j++) {
      int32 pdf_id = pdf_post[i][j].first;
      spk_stats->AccumulateForGmm(am_gmm.GetPdf(pdf_id),
                                  feats.Row(i),
                                  pdf_post[i][j].second);
    }
  }
}

AccumulateForUtterance() [7/8]

void kaldi::AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const Matrix< BaseFloat > &	transformed_feats,
		const std::vector< std::vector< int32 > > &	gselect,
		const Posterior &	post,
		const TransitionModel &	trans_model,
		const AmSgmm2 &	am_sgmm,
		BaseFloat	logdet,
		Sgmm2PerSpkDerivedVars *	spk_vars,
		FmllrSgmm2Accs *	spk_stats
	)

Definition at line 35 of file sgmm2-est-fmllr.cc.

References FmllrSgmm2Accs::AccumulateFromPosteriors(), AmSgmm2::ComponentPosteriors(), AmSgmm2::ComputePerFrameVars(), ConvertPosteriorToPdfs(), rnnlm::j, MatrixBase< Real >::Row(), and MatrixBase< Real >::Scale().

                                                       {
  kaldi::Sgmm2PerFrameDerivedVars per_frame_vars;

  Posterior pdf_post;
  ConvertPosteriorToPdfs(trans_model, post, &pdf_post);
  for (size_t t = 0; t < post.size(); t++) {
    // per-frame vars only used for computing posteriors... use the
    // transformed feats for this, if available.
    am_sgmm.ComputePerFrameVars(transformed_feats.Row(t), gselect[t],
                                *spk_vars, &per_frame_vars);
    

    for (size_t j = 0; j < pdf_post[t].size(); j++) {
      int32 pdf_id = pdf_post[t][j].first;
      Matrix<BaseFloat> posteriors;
      am_sgmm.ComponentPosteriors(per_frame_vars, pdf_id,
                                  spk_vars, &posteriors);
      posteriors.Scale(pdf_post[t][j].second);
      spk_stats->AccumulateFromPosteriors(am_sgmm, *spk_vars, feats.Row(t),
                                          gselect[t], posteriors, pdf_id);
    }
  }
}

AccumulateForUtterance() [8/8]

void kaldi::AccumulateForUtterance	(	const Matrix< BaseFloat > &	feats,
		const Posterior &	post,
		const TransitionModel &	trans_model,
		const AmSgmm2 &	am_sgmm,
		const vector< vector< int32 > > &	gselect,
		Sgmm2PerSpkDerivedVars *	spk_vars,
		MleSgmm2SpeakerAccs *	spk_stats
	)

Definition at line 36 of file sgmm2-est-spkvecs.cc.

References MleSgmm2SpeakerAccs::Accumulate(), AmSgmm2::ComputePerFrameVars(), ConvertPosteriorToPdfs(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

                                                            {
  kaldi::Sgmm2PerFrameDerivedVars per_frame_vars;

  KALDI_ASSERT(gselect.size() == feats.NumRows());
  Posterior pdf_post;
  ConvertPosteriorToPdfs(trans_model, post, &pdf_post);
  for (size_t i = 0; i < post.size(); i++) {
    am_sgmm.ComputePerFrameVars(feats.Row(i), gselect[i],
                                *spk_vars, &per_frame_vars);
    
    for (size_t j = 0; j < pdf_post[i].size(); j++) {
      int32 pdf_id = pdf_post[i][j].first;
      spk_stats->Accumulate(am_sgmm, per_frame_vars, pdf_id,
                            pdf_post[i][j].second, spk_vars);
    }
  }
}

AccumulateTreeStats()

void AccumulateTreeStats	(	const TransitionModel &	trans_model,
		const AccumulateTreeStatsInfo &	info,
		const std::vector< int32 > &	alignment,
		const Matrix< BaseFloat > &	features,
		std::map< EventType, GaussClusterable * > *	stats
	)

Accumulates the stats needed for training context-dependency trees (in the "normal" way).

It adds to 'stats' the stats obtained from this file. Any new GaussClusterable* pointers in "stats" will be allocated with "new".

Definition at line 36 of file tree-accu.cc.

References AccumulateTreeStatsInfo::central_position, AccumulateTreeStatsInfo::ci_phones, AccumulateTreeStatsInfo::context_width, rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_WARN, kPdfClass, MapPhone(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), AccumulateTreeStatsInfo::phone_map, MatrixBase< Real >::Row(), SplitToPhones(), TransitionModel::TransitionIdToPdfClass(), TransitionModel::TransitionIdToPhone(), and AccumulateTreeStatsInfo::var_floor.

Referenced by main().

                                                                      {
  std::vector<std::vector<int32> > split_alignment;
  bool ans = SplitToPhones(trans_model, alignment, &split_alignment);
  if (!ans) {
    KALDI_WARN << "AccumulateTreeStats: alignment appears to be bad, not using it";
    return;
  }
  int32 cur_pos = 0;
  int32 dim = features.NumCols();
  KALDI_ASSERT(features.NumRows() == static_cast<int32>(alignment.size()));
  for (int32 i = -info.context_width; i < static_cast<int32>(split_alignment.size()); i++) {
    // consider window starting at i, only if i+info.central_position is within
    // list of phones.
    if (i + info.central_position >= 0 &&
        i + info.central_position < static_cast<int32>(split_alignment.size())) {
      int32 central_phone =
          MapPhone(info.phone_map,
                   trans_model.TransitionIdToPhone(
                       split_alignment[i+info.central_position][0]));
      bool is_ctx_dep = !std::binary_search(info.ci_phones.begin(),
                                            info.ci_phones.end(),
                                            central_phone);
      EventType evec;
      for (int32 j = 0; j < info.context_width; j++) {
        int32 phone;
        if (i + j >= 0 && i + j < static_cast<int32>(split_alignment.size()))
          phone =
              MapPhone(info.phone_map,
                       trans_model.TransitionIdToPhone(split_alignment[i+j][0]));
        else
          phone = 0;  // ContextDependency class uses 0 to mean "out of window";
        // we also set the phone arbitrarily to 0

        // Don't add stuff to the event that we don't "allow" to be asked, due
        // to the central phone being context-independent: check "is_ctx_dep".
        // Why not just set the value to zero in this
        // case?  It's for safety.  By omitting the key from the event, we
        // ensure that there is no way a question can ever be asked that might
        // give an inconsistent answer in tree-training versus graph-building.
        // [setting it to zero would have the same effect given the "normal"
        // recipe but might be less robust to changes in tree-building recipe].
        if (is_ctx_dep || j == info.central_position)
          evec.push_back(std::make_pair(static_cast<EventKeyType>(j), static_cast<EventValueType>(phone)));
      }
      for (int32 j = 0; j < static_cast<int32>(split_alignment[i+info.central_position].size());j++) {
        // for central phone of this window...
        EventType evec_more(evec);
        int32 pdf_class = trans_model.TransitionIdToPdfClass(
            split_alignment[i+info.central_position][j]);
        // pdf_class will normally by 0, 1 or 2 for 3-state HMM.
        std::pair<EventKeyType, EventValueType> pr(kPdfClass, pdf_class);
        evec_more.push_back(pr);
        std::sort(evec_more.begin(), evec_more.end());  // these must be sorted!
        if (stats->count(evec_more) == 0)
          (*stats)[evec_more] = new GaussClusterable(dim, info.var_floor);

        BaseFloat weight = 1.0;
        (*stats)[evec_more]->AddStats(features.Row(cur_pos), weight);
        cur_pos++;
      }
    }
  }
  KALDI_ASSERT(cur_pos == static_cast<int32>(alignment.size()));
}

AddCompactLatticeArcToLattice()

static void kaldi::AddCompactLatticeArcToLattice ( const CompactLatticeArc &  clat_arc, LatticeArc::StateId  src_state, Lattice *  lat  )

static

Definition at line 1106 of file lattice-incremental-decoder.cc.

References rnnlm::i.

Referenced by LatticeIncrementalDeterminizer::InitializeRawLatticeChunk().

                  {
  const std::vector<int32> &string = clat_arc.weight.String();
  size_t N = string.size();
  if (N == 0) {
    LatticeArc arc;
    arc.ilabel = 0;
    arc.olabel = clat_arc.ilabel;
    arc.nextstate = clat_arc.nextstate;
    arc.weight = clat_arc.weight.Weight();
    lat->AddArc(src_state, arc);
  } else {
    LatticeArc::StateId cur_state = src_state;
    for (size_t i = 0; i < N; i++) {
      LatticeArc arc;
      arc.ilabel = string[i];
      arc.olabel = (i == 0 ? clat_arc.ilabel : 0);
      arc.nextstate = (i + 1 == N ? clat_arc.nextstate : lat->AddState());
      arc.weight = (i == 0 ? clat_arc.weight.Weight() : LatticeWeight::One());
      lat->AddArc(cur_state, arc);
      cur_state = arc.nextstate;
    }
  }
}

AddMatMatBatched() [1/3]

void AddMatMatBatched	(	const Real	alpha,
		std::vector< CuSubMatrix< Real > *> &	C,
		const std::vector< CuSubMatrix< Real > *> &	A,
		MatrixTransposeType	transA,
		const std::vector< CuSubMatrix< Real > *> &	B,
		MatrixTransposeType	transB,
		const Real	beta
	)

Does multiple matrix multiplications, executing them in parallel using cuBLAS's gemmBatched if we are using a GPU.

Vectors A, B and C must have the same length; for each i, this function executes the matrix operation C[i] = alpha * A[i](^T)*B[i](^T) + beta * C[i].

Definition at line 2207 of file cu-matrix.cc.

References AddMatMatBatched(), CuMatrixBase< Real >::data_, rnnlm::i, KALDI_ASSERT, kTrans, rnnlm::n, CuMatrixBase< Real >::NumCols(), and CuMatrixBase< Real >::NumRows().

Referenced by TestCuMatrixMatMatBatched(), and UnitTestCuMatrixAddMatMatBatched().

                                                                   {
  KALDI_ASSERT(A.size() == B.size() && B.size() == C.size());
  int32 size = A.size();

  if (size == 0) return;

  // all elements must have the same num-rows, num-cols and stride
  for (int32 i = 0; i + 1 < size; i++) {
    KALDI_ASSERT(A[i]->NumRows() == A[i+1]->NumRows());
    KALDI_ASSERT(A[i]->NumCols() == A[i+1]->NumCols());
    KALDI_ASSERT(A[i]->Stride() == A[i+1]->Stride());
    KALDI_ASSERT(B[i]->NumRows() == B[i+1]->NumRows());
    KALDI_ASSERT(B[i]->NumCols() == B[i+1]->NumCols());
    KALDI_ASSERT(B[i]->Stride() == B[i+1]->Stride());
    KALDI_ASSERT(C[i]->NumRows() == C[i+1]->NumRows());
    KALDI_ASSERT(C[i]->NumCols() == C[i+1]->NumCols());
    KALDI_ASSERT(C[i]->Stride() == C[i+1]->Stride());
  }
  // CUBLAS is col-major, cudamatrix is row-major, how to do the mapping?
  // keep trans..., just swap A&B matrices: A->B B->A
  MatrixIndexT m = ((transB==kTrans)? B[0]->NumRows() : B[0]->NumCols());
  MatrixIndexT n = ((transA==kTrans)? A[0]->NumCols() : A[0]->NumRows());
  MatrixIndexT k = ((transB==kTrans)? B[0]->NumCols() : B[0]->NumRows());
  MatrixIndexT k1 = ((transA==kTrans)? A[0]->NumRows() : A[0]->NumCols());

  KALDI_ASSERT(m == C[0]->NumCols());
  KALDI_ASSERT(n == C[0]->NumRows());
  KALDI_ASSERT(k == k1);

  if (m == 0) return;

#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    CuTimer tim;
    Real **device_abc_array =
        static_cast<Real**>(CuDevice::Instantiate().Malloc(3 * size * sizeof(Real*)));
    const Real **device_a_array = const_cast<const Real**>(device_abc_array);
    const Real **device_b_array = const_cast<const Real**>(device_abc_array) + size;
    Real **device_c_array = device_abc_array + 2 * size;
    const Real **host_abc_array = new const Real*[3*size];
    const Real **host_a_array = host_abc_array;
    const Real **host_b_array = host_abc_array + size;
    const Real **host_c_array = host_abc_array + 2 * size;

    for (int32 i = 0; i < size; i++) {
      host_a_array[i] = A[i]->data_;
      host_b_array[i] = B[i]->data_;
      host_c_array[i] = C[i]->data_;
    }

    CU_SAFE_CALL(cudaMemcpyAsync(device_abc_array, host_abc_array,
                                 3*size*sizeof(Real*), cudaMemcpyHostToDevice,
                                 cudaStreamPerThread));

    CUBLAS_SAFE_CALL(cublas_gemmBatched(GetCublasHandle(),
                                        (transB==kTrans? CUBLAS_OP_T:CUBLAS_OP_N),
                                        (transA==kTrans? CUBLAS_OP_T:CUBLAS_OP_N),
                                        m, n, k, alpha, device_b_array,
                                        B[0]->Stride(), device_a_array,
                                        A[0]->Stride(), beta, device_c_array,
                                        C[0]->Stride(), size));

    CuDevice::Instantiate().Free(device_abc_array);
    delete[] host_abc_array;

    CuDevice::Instantiate().AccuProfile(__func__, tim);
  } else
#endif
  {
    for (int32 i = 0; i < size; i++) {
      C[i]->Mat().AddMatMat(alpha, A[i]->Mat(), transA, B[i]->Mat(), transB, beta);
    }
  }
}

AddMatMatBatched() [2/3]

template void kaldi::AddMatMatBatched	(	const float	alpha,
		std::vector< CuSubMatrix< float > * > &	C,
		const std::vector< CuSubMatrix< float > * > &	A,
		MatrixTransposeType	transA,
		const std::vector< CuSubMatrix< float > * > &	B,
		MatrixTransposeType	transB,
		const float	beta
	)

AddMatMatBatched() [3/3]

template void kaldi::AddMatMatBatched	(	const double	alpha,
		std::vector< CuSubMatrix< double > * > &	C,
		const std::vector< CuSubMatrix< double > * > &	A,
		MatrixTransposeType	transA,
		const std::vector< CuSubMatrix< double > * > &	B,
		MatrixTransposeType	transB,
		const double	beta
	)

Referenced by AddMatMatBatched().

AddNoise()

void kaldi::AddNoise	(	Vector< BaseFloat > *	noise,
		BaseFloat	snr_db,
		BaseFloat	time,
		BaseFloat	samp_freq,
		BaseFloat	signal_power,
		Vector< BaseFloat > *	signal
	)

Definition at line 104 of file wav-reverberate.cc.

References AddVectorsWithOffset(), VectorBase< Real >::Dim(), KALDI_VLOG, VectorBase< Real >::Scale(), and VecVec().

Referenced by main().

                                                                   {
  float noise_power = VecVec(*noise, *noise) / noise->Dim();
  float scale_factor = sqrt(pow(10, -snr_db / 10) * signal_power / noise_power);
  noise->Scale(scale_factor);
  KALDI_VLOG(1) << "Noise signal is being scaled with " << scale_factor
                << " to generate output with SNR " << snr_db << "db\n";
  int32 offset = time * samp_freq;
  AddVectorsWithOffset(*noise, offset, signal);
}

AddOuterProductPlusMinus< double >()

template void kaldi::AddOuterProductPlusMinus< double >	(	double	alpha,
		const VectorBase< double > &	a,
		const VectorBase< double > &	b,
		MatrixBase< double > *	plus,
		MatrixBase< double > *	minus
	)

Referenced by AddOuterProductPlusMinus().

AddOuterProductPlusMinus< float >()

template void kaldi::AddOuterProductPlusMinus< float >	(	float	alpha,
		const VectorBase< float > &	a,
		const VectorBase< float > &	b,
		MatrixBase< float > *	plus,
		MatrixBase< float > *	minus
	)

Referenced by AddOuterProductPlusMinus().

AddSelfLoops()

void kaldi::AddSelfLoops

(

fst::StdMutableFst *

fst

)

Definition at line 109 of file arpa-lm-compiler-test.cc.

References kDisambig, and kEps.

                                         {
  for (fst::StateIterator<fst::StdMutableFst> siter(*fst);
       !siter.Done(); siter.Next()) {
    fst->AddArc(siter.Value(),
                fst::StdArc(kEps, kDisambig, 0, siter.Value()));
  }
}

AddSelfLoopsNoReorder()

static void kaldi::AddSelfLoopsNoReorder ( const TransitionModel &  trans_model, const std::vector< int32 > &  disambig_syms, BaseFloat  self_loop_scale, bool  check_no_self_loops, fst::VectorFst< fst::StdArc > *  fst  )

static

Definition at line 555 of file hmm-utils.cc.

References TransitionModel::GetNonSelfLoopLogProb(), TransitionModel::GetTransitionLogProb(), KALDI_ASSERT, fst::MakeFollowingInputSymbolsSameClass(), TransitionModel::SelfLoopOf(), and fst::Times().

Referenced by AddSelfLoops().

                                  {
  using namespace fst;
  typedef StdArc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;
  typedef Arc::Weight Weight;

  // Duplicate states as necessary so that each state has at most one self-loop
  // on it.
  TidToTstateMapper f(trans_model, disambig_syms, check_no_self_loops);
  MakeFollowingInputSymbolsSameClass(true, fst, f);

  StateId num_states = fst->NumStates();
  for (StateId s = 0; s < num_states; s++) {
    int32 my_trans_state = f(kNoLabel);
    KALDI_ASSERT(my_trans_state == -1);
    for (MutableArcIterator<VectorFst<Arc> > aiter(fst, s);
         !aiter.Done();
         aiter.Next()) {
      Arc arc = aiter.Value();
      if (my_trans_state == -1) my_trans_state = f(arc.ilabel);
      else KALDI_ASSERT(my_trans_state == f(arc.ilabel));  // or MakeFollowingInputSymbolsSameClass failed.
      if (my_trans_state > 0) {  // transition-id; multiply weight...
        BaseFloat log_prob = trans_model.GetNonSelfLoopLogProb(my_trans_state);
        arc.weight = Times(arc.weight, Weight(-log_prob*self_loop_scale));
        aiter.SetValue(arc);
      }
    }
    if (fst->Final(s) != Weight::Zero()) {
      KALDI_ASSERT(my_trans_state == kNoLabel || my_trans_state == 0);  // or MakeFollowingInputSymbolsSameClass failed.
    }
    if (my_trans_state != kNoLabel && my_trans_state != 0) {
      // a transition-state;  add self-loop, if it has one.
      int32 trans_id = trans_model.SelfLoopOf(my_trans_state);
      if (trans_id != 0) {  // has self-loop.
        BaseFloat log_prob = trans_model.GetTransitionLogProb(trans_id);
        fst->AddArc(s, Arc(trans_id, 0, Weight(-log_prob*self_loop_scale), s));
      }
    }
  }
}

AddSelfLoopsReorder()

static void kaldi::AddSelfLoopsReorder ( const TransitionModel &  trans_model, const std::vector< int32 > &  disambig_syms, BaseFloat  self_loop_scale, bool  check_no_self_loops, fst::VectorFst< fst::StdArc > *  fst  )

static

Definition at line 472 of file hmm-utils.cc.

References TransitionModel::GetNonSelfLoopLogProb(), TransitionModel::GetTransitionLogProb(), KALDI_ASSERT, fst::MakePrecedingInputSymbolsSameClass(), TransitionModel::SelfLoopOf(), and fst::Times().

Referenced by AddSelfLoops().

                                                              {
  using namespace fst;
  typedef StdArc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;
  typedef Arc::Weight Weight;

  TidToTstateMapper f(trans_model, disambig_syms, check_no_self_loops);
  // Duplicate states as necessary so that each state will require at most one
  // self-loop to be added to it.  Approximately this means that if a
  // state has multiple different symbols on arcs entering it, it will be
  // duplicated, with one copy per incoming symbol.
  MakePrecedingInputSymbolsSameClass(true, fst, f);

  int32 kNoTransState = f(kNoLabel);
  KALDI_ASSERT(kNoTransState == -1);

  // use the following to keep track of the transition-state for each state.
  std::vector<int32> state_in(fst->NumStates(), kNoTransState);

  // This first loop just works out the label into each state,
  // and converts the transitions in the graph from transition-states
  // to transition-ids.

  for (StateIterator<VectorFst<Arc> > siter(*fst);
       !siter.Done();
       siter.Next()) {
    StateId s = siter.Value();
    for (MutableArcIterator<VectorFst<Arc> > aiter(fst, s);
         !aiter.Done();
         aiter.Next()) {
      Arc arc = aiter.Value();
      int32 trans_state = f(arc.ilabel);
      if (state_in[arc.nextstate] == kNoTransState)
        state_in[arc.nextstate] = trans_state;
      else {
        KALDI_ASSERT(state_in[arc.nextstate] == trans_state);
        // or probably an error in MakePrecedingInputSymbolsSame.
      }
    }
  }

  KALDI_ASSERT(state_in[fst->Start()] == kNoStateId || state_in[fst->Start()] == 0);
  // or MakePrecedingInputSymbolsSame failed.

  // The next loop looks at each graph state, adds the self-loop [if needed] and
  // multiples all the out-transitions' probs (and final-prob) by the
  // forward-prob for that state (which is one minus self-loop-prob).  We do it
  // like this to maintain stochasticity (i.e. rather than multiplying the arcs
  // with the corresponding labels on them by this probability).

  for (StateId s = 0; s < static_cast<StateId>(state_in.size()); s++) {
    if (state_in[s] > 0) {  // defined, and not eps or a disambiguation symbol or a
                            // nonterminal-related sybol for grammar decoding...
      int32 trans_state = static_cast<int32>(state_in[s]);
      // First multiply all probabilities by "forward" probability.
      BaseFloat log_prob = trans_model.GetNonSelfLoopLogProb(trans_state);
      fst->SetFinal(s, Times(fst->Final(s), Weight(-log_prob*self_loop_scale)));
      for (MutableArcIterator<MutableFst<Arc> > aiter(fst, s);
          !aiter.Done();
          aiter.Next()) {
        Arc arc = aiter.Value();
        arc.weight = Times(arc.weight, Weight(-log_prob*self_loop_scale));
        aiter.SetValue(arc);
      }
      // Now add self-loop, if needed.
      int32 trans_id = trans_model.SelfLoopOf(trans_state);
      if (trans_id != 0) {  // has self-loop.
        BaseFloat log_prob = trans_model.GetTransitionLogProb(trans_id);
        fst->AddArc(s, Arc(trans_id, 0, Weight(-log_prob*self_loop_scale), s));
      }
    }
  }
}

AddToChainFsa()

fst::StdArc::StateId kaldi::AddToChainFsa	(	fst::StdMutableFst *	fst,
		fst::StdArc::StateId	last_state,
		int64	symbol
	)

Definition at line 100 of file arpa-lm-compiler-test.cc.

Referenced by ScoringTest().

                                                 {
  fst::StdArc::StateId next_state  = fst->AddState();
  fst->AddArc(last_state, fst::StdArc(symbol, symbol, 0, next_state));
  return next_state;
}

AddToConfusionMatrix()

void kaldi::AddToConfusionMatrix	(	int32	phone1,
		int32	phone2,
		Matrix< double > *	counts
	)

Definition at line 40 of file compare-int-vector.cc.

References KALDI_ERR, kCopyData, MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by main().

                                                  {
  if (phone1 < 0 || phone2 < 0)
    KALDI_ERR << "Contents of vectors cannot be "
        "negative if --write-confusion-matrix option is "
        "provided.";
  int32 max_size = std::max<int32>(phone1, phone2) + 1;
  if (counts->NumRows() < max_size)
    counts->Resize(max_size, max_size, kCopyData);
  (*counts)(phone1, phone2) += 1.0;
}

AddToCount()

void kaldi::AddToCount	(	int32	location_to_add,
		double	value_to_add,
		std::vector< double > *	counts
	)

Definition at line 28 of file compare-int-vector.cc.

References KALDI_ERR.

Referenced by main().

                                           {
  if (location_to_add < 0)
    KALDI_ERR << "Contents of vectors cannot be "
        "negative if --write-tot-counts or --write-diff-counts "
        "options are provided.";
  if (counts->size() <= static_cast<size_t>(location_to_add))
    counts->resize(location_to_add + 1, 0.0);
  (*counts)[location_to_add] += value_to_add;
}

AddVectorsOfUnequalLength()

void kaldi::AddVectorsOfUnequalLength	(	const VectorBase< BaseFloat > &	signal1,
		Vector< BaseFloat > *	signal2
	)

Definition at line 31 of file wav-reverberate.cc.

References VectorBase< Real >::Dim(), and VectorBase< Real >::Range().

Referenced by main().

                                                                 {
  for (int32 po = 0; po < signal2->Dim(); po += signal1.Dim()) {
    int32 block_length = signal1.Dim();
    if (signal2->Dim() - po < block_length) block_length = signal2->Dim() - po;
    signal2->Range(po, block_length).AddVec(1.0, signal1.Range(0, block_length));
  }
}

AddVectorsWithOffset()

void kaldi::AddVectorsWithOffset	(	const Vector< BaseFloat > &	signal1,
		int32	offset,
		Vector< BaseFloat > *	signal2
	)

Definition at line 44 of file wav-reverberate.cc.

References VectorBase< Real >::Dim(), and VectorBase< Real >::Range().

Referenced by AddNoise().

                                                                         {
  int32 add_length = std::min(signal2->Dim() - offset, signal1.Dim());
  if (add_length > 0)
    signal2->Range(offset, add_length).AddVec(1.0, signal1.Range(0, add_length));
}

AddWordInsPenToCompactLattice()

void AddWordInsPenToCompactLattice	(	BaseFloat	word_ins_penalty,
		CompactLattice *	clat
	)

This function add the word insertion penalty to graph score of each word in the compact lattice.

Definition at line 1181 of file lattice-functions.cc.

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

Referenced by main().

                                                         {
  typedef CompactLatticeArc Arc;
  int32 num_states = clat->NumStates();

  //scan the lattice
  for (int32 state = 0; state < num_states; state++) {
    for (fst::MutableArcIterator<CompactLattice> aiter(clat, state);
         !aiter.Done(); aiter.Next()) {

      Arc arc(aiter.Value());

      if (arc.ilabel != 0) { // if there is a word on this arc
        LatticeWeight weight = arc.weight.Weight();
        // add word insertion penalty to lattice
        weight.SetValue1( weight.Value1() + word_ins_penalty);
        arc.weight.SetWeight(weight);
        aiter.SetValue(arc);
      }
    } // end looping over arcs
  }  // end looping over states
}

AgglomerativeCluster()

void AgglomerativeCluster	(	const Matrix< BaseFloat > &	costs,
		BaseFloat	threshold,
		int32	min_clusters,
		int32	first_pass_max_points,
		BaseFloat	max_cluster_fraction,
		std::vector< int32 > *	assignments_out
	)

This is the function that is called to perform the agglomerative clustering.

It takes the following arguments:

• A matrix of all pairwise costs, with each row/column corresponding to an utterance ID, and the elements of the matrix containing the cost for pairing the utterances for its row and column
• A threshold which is used as the stopping criterion for the clusters
• A minimum number of clusters that will not be merged past
• A maximum fraction of points that can be in a cluster
• A vector which will be filled with integer IDs corresponding to each of the rows/columns of the score matrix.

The basic algorithm is as follows:

while (num-clusters > min-clusters && smallest-merge-cost <= threshold)
    if (size-of-new-cluster <= max-cluster-size)
        merge the two clusters with lowest cost

The cost between two clusters is the average cost of all pairwise costs between points across the two clusters.

The algorithm takes advantage of the fact that the sum of the pairwise costs between the points of clusters I and J is equiavlent to the sum of the pairwise costs between cluster I and the parents of cluster J. In other words, the total cost between I and J is the sum of the costs between clusters I and M and clusters I and N, where cluster J was formed by merging clusters M and N.

If the number of points to cluster is larger than first-pass-max-points, then clustering is done in two passes. In the first pass, input points are divided into contiguous subsets of size at most first-pass-max-points and each subset is clustered separately. In the second pass, the first pass clusters are merged into the final set of clusters.

Definition at line 223 of file agglomerative-clustering.cc.

References AgglomerativeClusterer::Cluster(), and KALDI_ASSERT.

Referenced by main().

                                       {
  KALDI_ASSERT(min_clusters >= 0);
  KALDI_ASSERT(max_cluster_fraction >= 1.0 / min_clusters);
  AgglomerativeClusterer ac(costs, threshold, min_clusters,
                            first_pass_max_points, max_cluster_fraction,
                            assignments_out);
  ac.Cluster();
}

AlignUtteranceWrapper()

void AlignUtteranceWrapper	(	const AlignConfig &	config,
		const std::string &	utt,
		BaseFloat	acoustic_scale,
		fst::VectorFst< fst::StdArc > *	fst,
		DecodableInterface *	decodable,
		Int32VectorWriter *	alignment_writer,
		BaseFloatWriter *	scores_writer,
		int32 *	num_done,
		int32 *	num_error,
		int32 *	num_retried,
		double *	tot_like,
		int64 *	frame_count,
		BaseFloatVectorWriter *	per_frame_acwt_writer = NULL
	)

AlignUtteranceWapper is a wrapper for alignment code used in training, that is called from many different binaries, e.g.

gmm-align, gmm-align-compiled, sgmm-align, etc. The writers for alignments and words will only be written to if they are open. The num_done, num_error, num_retried, tot_like and frame_count pointers will (if non-NULL) be incremented or added to, not set, by this function.

Definition at line 576 of file decoder-wrappers.cc.

References FasterDecoderOptions::beam, AlignConfig::beam, AlignConfig::careful, FasterDecoder::Decode(), FasterDecoder::GetBestPath(), fst::GetLinearSymbolSequence(), GetPerFrameAcousticCosts(), TableWriter< Holder >::IsOpen(), KALDI_ERR, KALDI_WARN, ModifyGraphForCarefulAlignment(), DecodableInterface::NumFramesReady(), FasterDecoder::ReachedFinal(), AlignConfig::retry_beam, VectorBase< Real >::Scale(), FasterDecoder::SetOptions(), LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), words, and TableWriter< Holder >::Write().

Referenced by main(), and AlignConfig::Register().

                                                  {

  if ((config.retry_beam != 0 && config.retry_beam <= config.beam) ||
      config.beam <= 0.0) {
    KALDI_ERR << "Beams do not make sense: beam " << config.beam
              << ", retry-beam " << config.retry_beam;
  }

  if (fst->Start() == fst::kNoStateId) {
    KALDI_WARN << "Empty decoding graph for " << utt;
    if (num_error != NULL) (*num_error)++;
    return;
  }

  if (config.careful)
    ModifyGraphForCarefulAlignment(fst);

  FasterDecoderOptions decode_opts;
  decode_opts.beam = config.beam;

  FasterDecoder decoder(*fst, decode_opts);
  decoder.Decode(decodable);

  bool ans = decoder.ReachedFinal();  // consider only final states.

  if (!ans && config.retry_beam != 0.0) {
    if (num_retried != NULL) (*num_retried)++;
    KALDI_WARN << "Retrying utterance " << utt << " with beam "
               << config.retry_beam;
    decode_opts.beam = config.retry_beam;
    decoder.SetOptions(decode_opts);
    decoder.Decode(decodable);
    ans = decoder.ReachedFinal();
  }

  if (!ans) {  // Still did not reach final state.
    KALDI_WARN << "Did not successfully decode file " << utt << ", len = "
               << decodable->NumFramesReady();
    if (num_error != NULL) (*num_error)++;
    return;
  }

  fst::VectorFst<LatticeArc> decoded;  // linear FST.
  decoder.GetBestPath(&decoded);
  if (decoded.NumStates() == 0) {
    KALDI_WARN << "Error getting best path from decoder (likely a bug)";
    if (num_error != NULL) (*num_error)++;
    return;
  }

  std::vector<int32> alignment;
  std::vector<int32> words;
  LatticeWeight weight;

  GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
  BaseFloat like = -(weight.Value1()+weight.Value2()) / acoustic_scale;

  if (num_done != NULL) (*num_done)++;
  if (tot_like != NULL) (*tot_like) += like;
  if (frame_count != NULL) (*frame_count) += decodable->NumFramesReady();

  if (alignment_writer != NULL && alignment_writer->IsOpen())
    alignment_writer->Write(utt, alignment);

  if (scores_writer != NULL && scores_writer->IsOpen())
    scores_writer->Write(utt, -(weight.Value1()+weight.Value2()));

  Vector<BaseFloat> per_frame_loglikes;
  if (per_frame_acwt_writer != NULL && per_frame_acwt_writer->IsOpen()) {
    GetPerFrameAcousticCosts(decoded, &per_frame_loglikes);
    per_frame_loglikes.Scale(-1 / acoustic_scale);
    per_frame_acwt_writer->Write(utt, per_frame_loglikes);
  }
}

AppendFeats()

bool kaldi::AppendFeats	(	const std::vector< Matrix< BaseFloat > > &	in,
		const std::string &	utt,
		int32	tolerance,
		Matrix< BaseFloat > *	out
	)

Definition at line 30 of file paste-feats.cc.

References rnnlm::i, KALDI_VLOG, KALDI_WARN, MatrixBase< Real >::Range(), and Matrix< Real >::Resize().

Referenced by main().

                                         {
  // Check the lengths
  int32 min_len = in[0].NumRows(),
      max_len = in[0].NumRows(),
      tot_dim = in[0].NumCols();
  for (int32 i = 1; i < in.size(); i++) {
    int32 len = in[i].NumRows(), dim = in[i].NumCols();
    tot_dim += dim;
    if(len < min_len) min_len = len;
    if(len > max_len) max_len = len;
  }
  if (max_len - min_len > tolerance || min_len == 0) {
    KALDI_WARN << "Length mismatch " << max_len << " vs. " << min_len
               << (utt.empty() ? "" : " for utt ") << utt
               << " exceeds tolerance " << tolerance;
    out->Resize(0, 0);
    return false;
  }
  if (max_len - min_len > 0) {
    KALDI_VLOG(2) << "Length mismatch " << max_len << " vs. " << min_len
                  << (utt.empty() ? "" : " for utt ") << utt
                  << " within tolerance " << tolerance;
  }
  out->Resize(min_len, tot_dim);
  int32 dim_offset = 0;
  for (int32 i = 0; i < in.size(); i++) {
    int32 this_dim = in[i].NumCols();
    out->Range(0, min_len, dim_offset, this_dim).CopyFromMat(
        in[i].Range(0, min_len, 0, this_dim));
    dim_offset += this_dim;
  }
  return true;
}

AppendPostToFeats()

void kaldi::AppendPostToFeats	(	const Matrix< BaseFloat > &	in,
		const Posterior &	post,
		const int32	post_dim,
		Matrix< BaseFloat > *	out
	)

Definition at line 28 of file append-post-to-feats.cc.

References MatrixBase< Real >::ColRange(), KALDI_ASSERT, KALDI_WARN, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), PosteriorToMatrix(), and Matrix< Real >::Resize().

Referenced by main().

                                               {
  // Check inputs,
  if (in.NumRows() != post.size()) {
    KALDI_WARN << "Mismatch of length!"
               << " features: " << in.NumRows()
               << " posteriors: " << post.size();
  }
  KALDI_ASSERT(in.NumRows() == post.size());
  // Convert post to Matrix,
  Matrix<BaseFloat> post_mat;
  PosteriorToMatrix(post, post_dim, &post_mat);
  // Build the output matrix,
  out->Resize(in.NumRows(), in.NumCols() + post_dim);
  out->ColRange(0, in.NumCols()).CopyFromMat(in);
  out->ColRange(in.NumCols(), post_mat.NumCols()).CopyFromMat(post_mat);
}

AppendVector()

void kaldi::AppendVector ( const VectorBase< Real > &  src, Vector< Real > *  dst  )

inline

Definition at line 1377 of file pitch-functions.cc.

References VectorBase< Real >::Dim(), kCopyData, VectorBase< Real >::Range(), and Vector< Real >::Resize().

                                                                         {
  if (src.Dim() == 0) return;
  dst->Resize(dst->Dim() + src.Dim(), kCopyData);
  dst->Range(dst->Dim() - src.Dim(), src.Dim()).CopyFromVec(src);
}

AppendVectorToFeats()

void kaldi::AppendVectorToFeats	(	const Matrix< BaseFloat > &	in,
		const Vector< BaseFloat > &	vec,
		Matrix< BaseFloat > *	out
	)

Definition at line 29 of file append-vector-to-feats.cc.

References MatrixBase< Real >::ColRange(), VectorBase< Real >::Dim(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by main().

                                                 {
  // Check inputs,
  KALDI_ASSERT(in.NumRows() != 0);
  // Build the output matrix,
  out->Resize(in.NumRows(), in.NumCols() + vec.Dim());
  out->ColRange(0, in.NumCols()).CopyFromMat(in);
  out->ColRange(in.NumCols(), vec.Dim()).CopyRowsFromVec(vec);
}

ApplyAffineTransform()

void ApplyAffineTransform	(	const MatrixBase< BaseFloat > &	xform,
		VectorBase< BaseFloat > *	vec
	)

Applies the affine transform 'xform' to the vector 'vec' and overwrites the contents of 'vec'.

Definition at line 168 of file transform-common.cc.

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), KALDI_ASSERT, kNoTrans, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by AffineXformStats::AffineXformStats(), main(), TestOnlineTransform(), UnitTestFmllrDiagGmm(), UnitTestFmllrDiagGmmDiagonal(), UnitTestFmllrDiagGmmOffset(), and UnitTestFmllrRaw().

                                                      {
  int32 dim = xform.NumRows();
  KALDI_ASSERT(dim > 0 && xform.NumCols() == dim+1 && vec->Dim() == dim);
  Vector<BaseFloat> tmp(dim+1);
  SubVector<BaseFloat> tmp_part(tmp, 0, dim);
  tmp_part.CopyFromVec(*vec);
  tmp(dim) = 1.0;
  // next line is: vec = 1.0 * xform * tmp + 0.0 * vec
  vec->AddMatVec(1.0, xform, kNoTrans, tmp, 0.0);
}

ApplyCmvn()

void ApplyCmvn	(	const MatrixBase< double > &	stats,
		bool	norm_vars,
		MatrixBase< BaseFloat > *	feats
	)

Apply cepstral mean and variance normalization to a matrix of features.

If norm_vars == true, expects stats to be of dimension 2 by (dim+1), but if norm_vars == false, will accept stats of dimension 1 by (dim+1); these are produced by the balanced-cmvn code when it computes an offset and represents it as "fake stats".

Definition at line 64 of file cmvn.cc.

References VectorBase< Real >::AddVec(), MatrixBase< Real >::AddVecToRows(), count, rnnlm::d, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, MatrixBase< Real >::MulColsVec(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), and MatrixBase< Real >::RowData().

Referenced by OnlineCmvn::GetFrame(), and main().

                                             {
  KALDI_ASSERT(feats != NULL);
  int32 dim = stats.NumCols() - 1;
  if (stats.NumRows() > 2 || stats.NumRows() < 1 || feats->NumCols() != dim) {
    KALDI_ERR << "Dim mismatch: cmvn "
              << stats.NumRows() << 'x' << stats.NumCols()
              << ", feats " << feats->NumRows() << 'x' << feats->NumCols();
  }
  if (stats.NumRows() == 1 && var_norm)
    KALDI_ERR << "You requested variance normalization but no variance stats "
              << "are supplied.";

  double count = stats(0, dim);
  // Do not change the threshold of 1.0 here: in the balanced-cmvn code, when
  // computing an offset and representing it as stats, we use a count of one.
  if (count < 1.0)
    KALDI_ERR << "Insufficient stats for cepstral mean and variance normalization: "
              << "count = " << count;

  if (!var_norm) {
    Vector<BaseFloat> offset(dim);
    SubVector<double> mean_stats(stats.RowData(0), dim);
    offset.AddVec(-1.0 / count, mean_stats);
    feats->AddVecToRows(1.0, offset);
    return;
  }
  // norm(0, d) = mean offset;
  // norm(1, d) = scale, e.g. x(d) <-- x(d)*norm(1, d) + norm(0, d).
  Matrix<BaseFloat> norm(2, dim);
  for (int32 d = 0; d < dim; d++) {
    double mean, offset, scale;
    mean = stats(0, d)/count;
    double var = (stats(1, d)/count) - mean*mean,
        floor = 1.0e-20;
    if (var < floor) {
      KALDI_WARN << "Flooring cepstral variance from " << var << " to "
                 << floor;
      var = floor;
    }
    scale = 1.0 / sqrt(var);
    if (scale != scale || 1/scale == 0.0)
      KALDI_ERR << "NaN or infinity in cepstral mean/variance computation";
    offset = -(mean*scale);
    norm(0, d) = offset;
    norm(1, d) = scale;
  }
  // Apply the normalization.
  feats->MulColsVec(norm.Row(1));
  feats->AddVecToRows(1.0, norm.Row(0));
}

ApplyCmvnReverse()

void ApplyCmvnReverse	(	const MatrixBase< double > &	stats,
		bool	norm_vars,
		MatrixBase< BaseFloat > *	feats
	)

This is as ApplyCmvn, but does so in the reverse sense, i.e.

applies a transform that would take zero-mean, unit-variance input and turn it into output with the stats of "stats". This can be useful if you trained without CMVN but later want to correct a mismatch, so you would first apply CMVN and then do the "reverse" CMVN with the summed stats of your training data.

Definition at line 117 of file cmvn.cc.

References MatrixBase< Real >::AddVecToRows(), count, rnnlm::d, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, MatrixBase< Real >::MulColsVec(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by main().

                                                    {
  KALDI_ASSERT(feats != NULL);
  int32 dim = stats.NumCols() - 1;
  if (stats.NumRows() > 2 || stats.NumRows() < 1 || feats->NumCols() != dim) {
    KALDI_ERR << "Dim mismatch: cmvn "
              << stats.NumRows() << 'x' << stats.NumCols()
              << ", feats " << feats->NumRows() << 'x' << feats->NumCols();
  }
  if (stats.NumRows() == 1 && var_norm)
    KALDI_ERR << "You requested variance normalization but no variance stats "
              << "are supplied.";

  double count = stats(0, dim);
  // Do not change the threshold of 1.0 here: in the balanced-cmvn code, when
  // computing an offset and representing it as stats, we use a count of one.
  if (count < 1.0)
    KALDI_ERR << "Insufficient stats for cepstral mean and variance normalization: "
              << "count = " << count;

  Matrix<BaseFloat> norm(2, dim);  // norm(0, d) = mean offset
  // norm(1, d) = scale, e.g. x(d) <-- x(d)*norm(1, d) + norm(0, d).
  for (int32 d = 0; d < dim; d++) {
    double mean, offset, scale;
    mean = stats(0, d) / count;
    if (!var_norm) {
      scale = 1.0;
      offset = mean;
    } else {
      double var = (stats(1, d)/count) - mean*mean,
          floor = 1.0e-20;
      if (var < floor) {
        KALDI_WARN << "Flooring cepstral variance from " << var << " to "
                   << floor;
        var = floor;
      }
      // we aim to transform zero-mean, unit-variance input into data
      // with the given mean and variance.
      scale = sqrt(var);
      offset = mean;
    }
    norm(0, d) = offset;
    norm(1, d) = scale;
  }
  if (var_norm)
    feats->MulColsVec(norm.Row(1));
  feats->AddVecToRows(1.0, norm.Row(0));
}

ApplyFeatureTransformToStats()

void ApplyFeatureTransformToStats	(	const MatrixBase< BaseFloat > &	xform,
		AffineXformStats *	stats
	)

This function applies a feature-level transform to stats (useful for certain techniques based on fMLLR).

Assumes the stats are of the standard diagonal sort. The transform "xform" may be either dim x dim (linear), dim x dim+1 (affine), or dim+1 x dim+1 (affine with the last row equal to 0 0 0 .. 0 1).

Definition at line 381 of file fmllr-diag-gmm.cc.

References SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::CopyFromMat(), AffineXformStats::Dim(), AffineXformStats::G_, rnnlm::i, AffineXformStats::K_, KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by ComputeFmllrLogDet(), LinearVtln::ComputeTransform(), and UnitTestFmllrDiagGmm().

                                                           {
  KALDI_ASSERT(stats != NULL && stats->Dim() != 0);
  int32 dim = stats->Dim();
  // make sure the stats are of the standard diagonal kind.
  KALDI_ASSERT(stats->G_.size() == static_cast<size_t>(dim));
  KALDI_ASSERT( (xform.NumRows() == dim && xform.NumCols() == dim) // linear
                || (xform.NumRows() == dim && xform.NumCols() == dim+1) // affine
                || (xform.NumRows() == dim+1 && xform.NumCols() == dim+1));  // affine w/ extra row.
  if (xform.NumRows() == dim+1) {  // check last row of input
    // has correct value. 0 0 0 ..  0 1.
    for (int32 i = 0; i < dim; i++)
      KALDI_ASSERT(xform(dim, i) == 0.0);
    KALDI_ASSERT(xform(dim, dim) == 1.0);
  }

  // Get the transform into the (dim+1 x dim+1) format, with
  // 0 0 0 .. 0 1 as the last row.
  SubMatrix<BaseFloat> xform_square(xform, 0, dim, 0, dim);
  Matrix<double> xform_full(dim+1, dim+1);
  SubMatrix<double> xform_full_square(xform_full, 0, dim, 0, dim);
  xform_full_square.CopyFromMat(xform_square);
  if (xform.NumCols() == dim+1)  // copy offset.
    for (int32 i = 0; i < dim; i++)
      xform_full(i, dim) = xform(i, dim);

  xform_full(dim, dim) = 1.0;

  SpMatrix<double> Gtmp(dim+1);
  for (int32 i = 0; i < dim; i++) {
    // Gtmp <-- xform_full * stats->G_[i] * xform_full^T
    Gtmp.AddMat2Sp(1.0, xform_full, kNoTrans, stats->G_[i], 0.0);
    stats->G_[i].CopyFromSp(Gtmp);
  }
  Matrix<double> Ktmp(dim, dim+1);
  // Ktmp <-- stats->K_ * xform_full^T
  Ktmp.AddMatMat(1.0, stats->K_, kNoTrans, xform_full, kTrans, 0.0);
  stats->K_.CopyFromMat(Ktmp);
}

ApplyHessianXformToGradient()

static void kaldi::ApplyHessianXformToGradient ( const Sgmm2FmllrGlobalParams &  globals, const Matrix< BaseFloat > &  gradient_in, Matrix< BaseFloat > *  gradient_out  )

static

Definition at line 59 of file fmllr-sgmm2.cc.

References KALDI_ERR, Sgmm2FmllrGlobalParams::mean_scatter_, VectorBase< Real >::Min(), and MatrixBase< Real >::NumRows().

Referenced by FmllrSgmm2Accs::AccumulateForFmllrSubspace(), and FmllrSgmm2Accs::Update().

                                                                         {
  int32 dim = gradient_in.NumRows();
  const Vector<BaseFloat> &D = globals.mean_scatter_;
  if (D.Min() <= 0.0)
    KALDI_ERR << "Cannot estimate FMLLR: mean scatter has 0 eigenvalues.";
  for (int32 r = 0; r < dim; r++) {
    for (int32 c = 0; c < r; c++) {
      // Eq. (B.15)
      (*gradient_out)(r, c) = gradient_in(r, c) / std::sqrt(1 + D(c));
      // Eq. (B.16)
      (*gradient_out)(c, r) = gradient_in(c, r) / std::sqrt(1 + D(r) -
          1 / (1 + D(c))) - gradient_in(r, c) / ((1 + D(c)) *
              std::sqrt(1 + D(r) - 1 / (1 + D(c))));
    }
    // Eq. (B.17) & (B.18)
    (*gradient_out)(r, r) = gradient_in(r, r) / std::sqrt(2 + D(r));
    (*gradient_out)(r, dim) = gradient_in(r, dim);
  }
}

ApplyInvHessianXformToChange()

static void kaldi::ApplyInvHessianXformToChange ( const Sgmm2FmllrGlobalParams &  globals, const Matrix< BaseFloat > &  delta_in, Matrix< BaseFloat > *  delta_out  )

static

Definition at line 81 of file fmllr-sgmm2.cc.

References KALDI_ERR, Sgmm2FmllrGlobalParams::mean_scatter_, VectorBase< Real >::Min(), and MatrixBase< Real >::NumRows().

Referenced by FmllrSgmm2Accs::Update().

                                                                       {
  int32 dim = delta_in.NumRows();
  const Vector<BaseFloat> &D = globals.mean_scatter_;
  if (D.Min() <= 0.0)
    KALDI_ERR << "Cannot estimate FMLLR: mean scatter has 0 eigenvalues.";
  for (int32 r = 0; r < dim; r++) {
    for (int32 c = 0; c < r; c++) {
      // Eq. (B.21)
      (*delta_out)(r, c) = delta_in(r, c) / std::sqrt(1 + D(c)) -
          delta_in(c, r) / ((1 + D(c)) * std::sqrt(1 + D(r) - 1 / (1 + D(c))));
      // Eq. (B.22)
      (*delta_out)(c, r) = delta_in(c, r) / std::sqrt(1 + D(r) - 1/ (1 + D(c)));
    }
    // Eq. (B.23) & (B.24)
    (*delta_out)(r, r) = delta_in(r, r) / std::sqrt(2 + D(r));
    (*delta_out)(r, dim) = delta_in(r, dim);
  }
}

ApplyInvPreXformToChange()

static void kaldi::ApplyInvPreXformToChange ( const Sgmm2FmllrGlobalParams &  globals, const Matrix< BaseFloat > &  delta_in, Matrix< BaseFloat > *  delta_out  )

static

Definition at line 45 of file fmllr-sgmm2.cc.

References MatrixBase< Real >::AddMatMat(), Sgmm2FmllrGlobalParams::inv_xform_, kNoTrans, kSetZero, kUndefined, MatrixBase< Real >::NumRows(), Sgmm2FmllrGlobalParams::pre_xform_, and MatrixBase< Real >::Range().

Referenced by FmllrSgmm2Accs::Update().

                                                                   {
  // Eq. (B.25): \Delta = A_{inv} \Delta' W_{pre}^+
  int32 dim = delta_in.NumRows();
  Matrix<BaseFloat> Wpre_plus(dim + 1, dim + 1, kSetZero);
  Wpre_plus.Range(0, dim, 0, dim + 1).CopyFromMat(globals.pre_xform_);
  Wpre_plus(dim, dim) = 1;
  SubMatrix<BaseFloat> Ainv(globals.inv_xform_, 0, dim, 0, dim);
  Matrix<BaseFloat> AinvD(dim, dim + 1, kUndefined);
  AinvD.AddMatMat(1.0, Ainv, kNoTrans, delta_in, kNoTrans, 0.0);
  delta_out->AddMatMat(1.0, AinvD, kNoTrans, Wpre_plus, kNoTrans, 0.0);
}

ApplyModelTransformToStats()

void ApplyModelTransformToStats	(	const MatrixBase< BaseFloat > &	xform,
		AffineXformStats *	stats
	)

ApplyModelTransformToStats takes a transform "xform", which must be diagonal (i.e.

of the form T = [ D; b ] where D is diagonal), and applies it to the stats as if we had made it a model-space transform (note that the transform applied to the model means is the inverse transform of T). Thus, if we are estimating a transform T U, and we get stats valid for estimating T U and we estimate T, we can then call this function (treating T as a model-space transform) and will get stats valid for estimating U. This only works if T is diagonal, because otherwise the standard stats format is not valid. xform must be of dimension d x d+1

Definition at line 421 of file fmllr-diag-gmm.cc.

References AffineXformStats::Dim(), AffineXformStats::G_, rnnlm::i, MatrixBase< Real >::IsDiagonal(), rnnlm::j, AffineXformStats::K_, KALDI_ASSERT, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by ComputeFmllrLogDet(), UnitTestFmllrDiagGmmDiagonal(), and UnitTestFmllrDiagGmmOffset().

                                                         {
  KALDI_ASSERT(stats != NULL && stats->Dim() != 0.0);
  int32 dim = stats->Dim();
  KALDI_ASSERT(xform.NumRows() == dim && xform.NumCols() == dim+1);
  {
    SubMatrix<BaseFloat> xform_square(xform, 0, dim, 0, dim);
    // Only works with diagonal transforms.
    KALDI_ASSERT(xform_square.IsDiagonal());
  }

  // Working out rules for transforming fMLLR statistics under diagonal
  // model-space transformations.
  //
  // We work out what the stats would be if we had accumulated
  // with offset/scaled means and vars. Let T be the transform
  // T = [ D; b ],
  // where D is diagonal, d_i is the i'th diagonal of D, and b_i
  // is the i'th offset element.  This is equivalent to the transform
  //   x_i -> y_i = d_i x_i + b_i,
  // so d_i is the diagonal and b_i is the offset term.  We work out the
  // reverse feature transform (from general to speaker-specific space),
  // which is
  //  y_i -> x_i = (y_i - b_i) / d_i
  // the corresponding mean transform to speaker-space is the same:
  //  mu_i -> (mu_i - b_i) / d_i
  // and the transfrom on the variances is:
  //  sigma_i^2 -> sigma_i^2 / d_i^2,
  // so on inverse variance this becomes:
  //  (1/sigma_i^2) -> (1/sigma_i^2) * d_i^2.
  //
  // Now, we work out the change in K and G_i from these effects on the
  // means and variances.
  //
  // Now, k_{ij} is \sum_{m, t} \gamma_m (1/\sigma^2_{m, i}) \mu_{m, i} x^+_j .
  //
  // If we are transforming to K', we want:
  //
  // k'_{ij} = \sum_{m, t} \gamma_m (d_i^2/\sigma^2_{m, i}) ((\mu_{m, i} - b_i)/d_i)  x^+_j .
  //         = d_i k_{i, j} - \sum_{m, t} \gamma_m (1/\sigma^2_{m, i}) d_i b_i x^+_j .
  //         = d_i k_{i, j} - d_i b_i g_{i, d, j},
  // where g_{i, d, j} is the {d, j}'th element of G_i. (in zero-based indexing).
  //
  //
  // G_i only depends on the variances and features, so the only change
  // in G_i is G_i -> d_i^2 G_i (this comes from the change in 1/sigma_i^2).
  // This is done after the change in K.

  for (int32 i = 0; i < dim; i++) {
    BaseFloat d_i = xform(i, i), b_i = xform(i, dim);
    for (int32 j = 0; j <= dim; j++) {
      stats->K_(i, j) = d_i * stats->K_(i, j) - d_i * b_i * stats->G_[i](dim, j);
    }
  }
  for (int32 i = 0; i < dim; i++) {
    BaseFloat d_i = xform(i, i);
    stats->G_[i].Scale(d_i * d_i);
  }
}

ApplyPca()

void kaldi::ApplyPca	(	const Matrix< BaseFloat > &	ivectors_in,
		const Matrix< BaseFloat > &	pca_mat,
		Matrix< BaseFloat > *	ivectors_out
	)

Definition at line 101 of file ivector-plda-scoring-dense.cc.

References MatrixBase< Real >::AddMatMat(), KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by main().

                                                                     {
  int32 transform_cols = pca_mat.NumCols(),
        transform_rows = pca_mat.NumRows(),
        feat_dim = ivectors_in.NumCols();
  ivectors_out->Resize(ivectors_in.NumRows(), transform_rows);
  KALDI_ASSERT(transform_cols == feat_dim);
  ivectors_out->AddMatMat(1.0, ivectors_in, kNoTrans,
    pca_mat, kTrans, 0.0);
}

ApplyPreXformToGradient()

static void kaldi::ApplyPreXformToGradient ( const Sgmm2FmllrGlobalParams &  globals, const Matrix< BaseFloat > &  gradient_in, Matrix< BaseFloat > *  gradient_out  )

static

Definition at line 31 of file fmllr-sgmm2.cc.

References MatrixBase< Real >::AddMatMat(), Sgmm2FmllrGlobalParams::inv_xform_, kNoTrans, kSetZero, kTrans, kUndefined, MatrixBase< Real >::NumRows(), Sgmm2FmllrGlobalParams::pre_xform_, and MatrixBase< Real >::Range().

Referenced by FmllrSgmm2Accs::AccumulateForFmllrSubspace(), and FmllrSgmm2Accs::Update().

                                                                     {
  // Eq. (B.14): P' = A_{inv}^T P {W_{pre}^+}^T
  int32 dim = gradient_in.NumRows();
  Matrix<BaseFloat> Wpre_plus(dim + 1, dim + 1, kSetZero);
  Wpre_plus.Range(0, dim, 0, dim + 1).CopyFromMat(globals.pre_xform_);
  Wpre_plus(dim, dim) = 1;
  SubMatrix<BaseFloat> Ainv(globals.inv_xform_, 0, dim, 0, dim);
  Matrix<BaseFloat> AinvP(dim, dim + 1, kUndefined);
  AinvP.AddMatMat(1.0, Ainv, kTrans, gradient_in, kNoTrans, 0.0);
  gradient_out->AddMatMat(1.0, AinvP, kNoTrans, Wpre_plus, kTrans, 0.0);
}

ApplySoftMaxPerRow()

void kaldi::ApplySoftMaxPerRow

(

MatrixBase< BaseFloat > *

mat

)

Definition at line 27 of file copy-matrix.cc.

References rnnlm::i, MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by main().

                                                    {
  for (int32 i = 0; i < mat->NumRows(); i++) {
    mat->Row(i).ApplySoftMax();
  }
}

approx_equal()

static bool kaldi::approx_equal ( Real  a, Real  b  )

static

Definition at line 3323 of file matrix-lib-test.cc.

Referenced by UnitTestTrace().

                                         {
  return  ( std::abs(a-b) <= 1.0e-03 * (std::abs(a)+std::abs(b)));
}

ApproxEqual() [1/6]

static bool kaldi::ApproxEqual ( const CuBlockMatrix< Real > &  A, const CuBlockMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 35 of file cu-block-matrix-test.cc.

                                           {
  CuMatrix<Real> Acopy(A), Bcopy(B);
  return Acopy.ApproxEqual(Bcopy, tol);
}

ApproxEqual() [2/6]

static bool kaldi::ApproxEqual ( const PackedMatrix< Real > &  A, const PackedMatrix< Real > &  B, Real  tol = 0.001  )

static

Definition at line 100 of file cu-packed-matrix-test.cc.

References rnnlm::d, KALDI_ASSERT, PackedMatrix< Real >::Max(), PackedMatrix< Real >::Min(), and PackedMatrix< Real >::NumRows().

                                                                       {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  PackedMatrix<Real> diff(A);
  diff.AddPacked(1.0, B);
  Real a = std::max(A.Max(), -A.Min()), b = std::max(B.Max(), -B.Min()),
      d = std::max(diff.Max(), -diff.Min());
  return (d <= tol * std::max(a, b));
}

ApproxEqual() [3/6]

bool kaldi::ApproxEqual ( const CuSpMatrix< Real > &  A, const CuSpMatrix< Real > &  B, Real  tol = 0.001  )

inline

Definition at line 141 of file cu-sp-matrix.h.

                                                              {
  return A.ApproxEqual(B, tol);
}

ApproxEqual() [4/6]

static bool kaldi::ApproxEqual ( float  a, float  b, float  relative_tolerance = 0.001  )

inlinestatic

return abs(a - b) <= relative_tolerance * (abs(a)+abs(b)).

Definition at line 265 of file kaldi-math.h.

Referenced by AssertEqual(), MleAmSgmm2Accs::Check(), ComputeFmllrMatrixDiagGmmFull(), ComputeLatticeAlphasAndBetas(), CreateEigenvalueMatrix(), CuVectorUnitTestNorm(), CuVectorUnitTestScale(), DecisionTreeSplitter::DoSplitInternal(), EstPca(), kaldi::nnet3::ExampleApproxEqual(), FindBestSplitForKey(), LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), AmSgmm2::LogLikelihood(), main(), FullGmm::Merge(), DiagGmm::Merge(), FullGmm::MergePreselect(), NnetIo::operator==(), OnlinePreconditioner::PreconditionDirectionsInternal(), KlHmm::PropagateFnc(), MultiBasisComponent::PropagateFnc(), LatticeSimpleDecoder::PruneForwardLinksFinal(), LatticeFasterDecoderTpl< fst::StdFst, decoder::BackpointerToken >::PruneForwardLinksFinal(), LatticeBiglmFasterDecoder::PruneForwardLinksFinal(), LatticeIncrementalDecoderTpl< FST, decoder::BackpointerToken >::PruneForwardLinksFinal(), OnlinePitchFeatureImpl::RecomputeBacktraces(), ScoringTest(), TestCuMatrixCompObjfAndDeriv(), kaldi::nnet3::time_height_convolution::TestDataBackprop(), kaldi::nnet3::TestNnetComponentVectorizeUnVectorize(), kaldi::nnet3::time_height_convolution::TestParamsBackprop(), TestPushCompactLatticeWeights(), kaldi::nnet3::TestSimpleComponentDataDerivative(), kaldi::nnet3::TestSimpleComponentModelDerivative(), UnitTestApproxEqual(), UnitTestComplexFft2(), UnitTestCompressedMatrix2(), UnitTestCuBlockMatrixAddMatMat(), UnitTestCuDiffLogSoftmax(), UnitTestCuDiffSigmoid(), UnitTestCuDiffSoftmax(), UnitTestCuDiffTanh(), UnitTestCuDiffXent(), UnitTestCuLogSoftmax(), UnitTestCuMatrixAdd(), UnitTestCuMatrixAdd2(), UnitTestCuMatrixAddCols(), UnitTestCuMatrixAddDiagVecMat(), UnitTestCuMatrixAddElements(), UnitTestCuMatrixAddMat(), UnitTestCuMatrixAddMatBlocks1(), UnitTestCuMatrixAddMatBlocks1Trans(), UnitTestCuMatrixAddMatBlocks2(), UnitTestCuMatrixAddMatDiagVec(), UnitTestCuMatrixAddMatMat(), UnitTestCuMatrixAddMatMatBatched(), UnitTestCuMatrixAddMatMatElements(), UnitTestCuMatrixAddRowRanges(), UnitTestCuMatrixAddRows(), UnitTestCuMatrixAddToDiag(), UnitTestCuMatrixAddToElements(), UnitTestCuMatrixAddToRows(), UnitTestCuMatrixAddVecToCols(), UnitTestCuMatrixAddVecToRows(), UnitTestCuMatrixAddVecVec(), UnitTestCuMatrixApplyCeiling(), UnitTestCuMatrixApplyExp(), UnitTestCuMatrixApplyExpLimited(), UnitTestCuMatrixApplyExpSpecial(), UnitTestCuMatrixApplyFloor(), UnitTestCuMatrixApplyHeaviside(), UnitTestCuMatrixApplyLog(), UnitTestCuMatrixApplyPow(), UnitTestCuMatrixApplyPowAbs(), UnitTestCuMatrixCopyCols(), UnitTestCuMatrixCopyColsFromVec(), UnitTestCuMatrixCopyCross(), UnitTestCuMatrixCopyCross2(), UnitTestCuMatrixCopyRows(), UnitTestCuMatrixCopyRowsFromVec(), UnitTestCuMatrixCopyToRows(), UnitTestCuMatrixDiffGroupPnorm(), UnitTestCuMatrixDivElements(), UnitTestCuMatrixDivRowsVec(), UnitTestCuMatrixGroupMax(), UnitTestCuMatrixGroupMaxDeriv(), UnitTestCuMatrixGroupPnorm(), UnitTestCuMatrixHeaviside(), UnitTestCuMatrixInvertElements(), UnitTestCuMatrixIO(), UnitTestCuMatrixMax(), UnitTestCuMatrixMin(), UnitTestCuMatrixMulColsVec(), UnitTestCuMatrixMulElements(), UnitTestCuMatrixMulRows(), UnitTestCuMatrixMulRowsGroupMat(), UnitTestCuMatrixMulRowsVec(), UnitTestCuMatrixObjfDeriv(), UnitTestCuMatrixReduceMax(), UnitTestCuMatrixReduceMin(), UnitTestCuMatrixReduceSum(), UnitTestCuMatrixScale(), UnitTestCuMatrixSet(), UnitTestCuMatrixSetMatMatDivMat(), UnitTestCuMatrixSetRandn(), UnitTestCuMatrixSigmoid(), UnitTestCuMatrixSoftHinge(), UnitTestCuMatrixSumColumnRanges(), UnitTestCuMatrixSymAddMat2(), UnitTestCuMatrixSymInvertPosDef(), UnitTestCuMatrixTraceMatMat(), UnitTestCuMatrixTranspose(), UnitTestCuSigmoid(), UnitTestCuSoftmax(), UnitTestCuSpMatrixCopyFromMat(), UnitTestCuSpMatrixTraceSpSp(), UnitTestCuTanh(), UnitTestCuVectorAddColSumMat(), UnitTestCuVectorAddColSumMatLarge(), UnitTestCuVectorAddRowSumMat(), UnitTestCuVectorAddRowSumMatLarge(), UnitTestCuVectorAddTpVec(), UnitTestCuVectorAddVec(), UnitTestCuVectorInvertElements(), UnitTestCuVectorMulTp(), UnitTestCuVectorSum(), UnitTestDelay(), UnitTestEstimateDiagGmm(), UnitTestEstimateFullGmm(), UnitTestFmllrDiagGmm(), UnitTestFmllrDiagGmmDiagonal(), UnitTestFmllrDiagGmmOffset(), UnitTestLinearResample(), UnitTestLstmNonlinearity(), kaldi::nnet3::UnitTestNnetCompute(), kaldi::nnet2::UnitTestNnetDecodable(), kaldi::nnet3::UnitTestNnetInputDerivatives(), kaldi::nnet3::UnitTestNnetModelDerivatives(), kaldi::nnet3::UnitTestNnetOptimizeWithOptions(), UnitTestNorm(), UnitTestPieces(), UnitTestPosteriors(), UnitTestRange(), UnitTestReadConfig(), UnitTestSnipEdges(), UnitTestSplitRadixComplexFft2(), UnitTestSwapCu2Cu(), UnitTestSwapCu2M(), UnitTestTableRandomBothDouble(), UnitTestTableSequentialBaseFloatVectorBoth(), UnitTestTableSequentialDouble(), UnitTestTableSequentialDoubleBoth(), UnitTestTableSequentialDoubleMatrixBoth(), UnitTextCuMatrixAddMatSmat(), UnitTextCuMatrixAddSmat(), UnitTextCuMatrixAddSmatMat(), IvectorExtractorStats::UpdatePrior(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                                                 {
  // a==b handles infinities.
  if (a == b) return true;
  float diff = std::abs(a-b);
  if (diff == std::numeric_limits<float>::infinity()
      || diff != diff) return false;  // diff is +inf or nan.
  return (diff <= relative_tolerance*(std::abs(a)+std::abs(b)));
}

ApproxEqual() [5/6]

bool kaldi::ApproxEqual	(	const CuVectorBase< Real > &	a,
		const CuVectorBase< Real > &	b,
		Real	tol = 0.01
	)

Definition at line 364 of file cu-vector.h.

                                                               {
  return a.ApproxEqual(b, tol);
}

ApproxEqual() [6/6]

bool kaldi::ApproxEqual	(	const CuMatrixBase< Real > &	A,
		const CuMatrixBase< Real > &	B,
		Real	tol = 0.01
	)

Definition at line 937 of file cu-matrix.h.

                                                               {
  return A.ApproxEqual(B, tol);
}

AssertDiagEqual() [1/2]

static void kaldi::AssertDiagEqual ( const PackedMatrix< Real > &  A, const CuPackedMatrix< Real > &  B, float  value, float  tol = 0.001  )

static

Definition at line 68 of file cu-packed-matrix-test.cc.

References rnnlm::i, KALDI_ASSERT, and PackedMatrix< Real >::NumRows().

Referenced by UnitTestCuPackedMatrixAddToDiag().

                                           {
  for (MatrixIndexT i = 0; i < A.NumRows(); i++) {
    KALDI_ASSERT(std::abs((A(i, i)+value) - B(i, i))  
                 < tol * std::max(1.0, (double) (std::abs(A(i, i)) + std::abs(B(i, i) + value))));
  }
}

AssertDiagEqual() [2/2]

static void kaldi::AssertDiagEqual ( const PackedMatrix< Real > &  A, const PackedMatrix< Real > &  B, float  value, float  tol = 0.001  )

static

Definition at line 78 of file cu-packed-matrix-test.cc.

References rnnlm::i, KALDI_ASSERT, and PackedMatrix< Real >::NumRows().

                                           {
  for (MatrixIndexT i = 0; i < A.NumRows(); i++) {
    KALDI_ASSERT(std::abs((A(i, i)+value) - B(i, i))  
                 < tol * std::max(1.0, (double) (std::abs(A(i, i)) + std::abs(B(i, i) + value))));
  }
}

AssertEqual() [1/12]

void kaldi::AssertEqual	(	const std::vector< T > &	vec1,
		const std::vector< T > &	vec2
	)

Definition at line 36 of file cu-array-test.cc.

References rnnlm::i, and KALDI_ASSERT.

                                           {
  // use this instead of "vec1 == vec2" because
  // for doubles and floats, this can fail if we
  // have NaNs, even if identical.
  KALDI_ASSERT(vec1.size() == vec2.size());
  if (vec1.size() > 0) {
    const char *p1 = reinterpret_cast<const char*>(&(vec1[0]));
    const char *p2 = reinterpret_cast<const char*>(&(vec2[0]));
    size_t size = sizeof(T) * vec1.size();
    for (size_t i = 0; i < size; i++)
      KALDI_ASSERT(p1[i] == p2[i]);
  }
}

AssertEqual() [2/12]

static void kaldi::AssertEqual ( const CuPackedMatrix< Real > &  A, const CuPackedMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 41 of file cu-tp-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and CuPackedMatrix< Real >::NumRows().

                                           {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  for (MatrixIndexT i = 0; i < A.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      KALDI_ASSERT(std::abs(A(i, j) - B(i, j))
                   < tol * std::max(1.0, (double) (std::abs(A(i, j)) + std::abs(B(i, j)))));
}

AssertEqual() [3/12]

static void kaldi::AssertEqual ( const CuPackedMatrix< Real > &  A, const CuPackedMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 46 of file cu-packed-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and CuPackedMatrix< Real >::NumRows().

                                           {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  for (MatrixIndexT i = 0; i < A.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      KALDI_ASSERT(std::abs(A(i, j) - B(i, j))
                   < tol * std::max(1.0, (double) (std::abs(A(i, j)) + std::abs(B(i, j)))));
}

AssertEqual() [4/12]

static void kaldi::AssertEqual ( const PackedMatrix< Real > &  A, const PackedMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 52 of file cu-tp-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and PackedMatrix< Real >::NumRows().

                                           {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  for (MatrixIndexT i = 0; i < A.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      KALDI_ASSERT(std::abs(A(i, j) - B(i, j))
                   < tol * std::max(1.0, (double) (std::abs(A(i, j)) + std::abs(B(i, j)))));
}

AssertEqual() [5/12]

static void kaldi::AssertEqual ( const PackedMatrix< Real > &  A, const PackedMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 57 of file cu-packed-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and PackedMatrix< Real >::NumRows().

                                           {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  for (MatrixIndexT i = 0; i < A.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      KALDI_ASSERT(std::abs(A(i, j) - B(i, j))
                   < tol * std::max(1.0, (double) (std::abs(A(i, j)) + std::abs(B(i, j)))));
}

AssertEqual() [6/12]

static void kaldi::AssertEqual ( const PackedMatrix< Real > &  A, const CuPackedMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 63 of file cu-tp-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, PackedMatrix< Real >::NumRows(), and CuPackedMatrix< Real >::NumRows().

                                           {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  for (MatrixIndexT i = 0; i < A.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      KALDI_ASSERT(std::abs(A(i, j) - B(i, j))
                   < tol * std::max(1.0, (double) (std::abs(A(i, j)) + std::abs(B(i, j)))));
}

AssertEqual() [7/12]

static void kaldi::AssertEqual ( const Matrix< Real > &  A, const Matrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 69 of file online-feat-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

                                                                {
  KALDI_ASSERT(A.NumRows() == B.NumRows()&&A.NumCols() == B.NumCols());
  for (MatrixIndexT i = 0;i < A.NumRows();i++)
    for (MatrixIndexT j = 0;j < A.NumCols();j++) {
      KALDI_ASSERT(std::abs(A(i, j)-B(i, j)) < tol*std::max(1.0, (double) (std::abs(A(i, j))+std::abs(B(i, j)))));
    }
}

AssertEqual() [8/12]

static void kaldi::AssertEqual ( const PackedMatrix< Real > &  A, const CuPackedMatrix< Real > &  B, float  tol = 0.001  )

static

Definition at line 89 of file cu-packed-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, PackedMatrix< Real >::NumRows(), and CuPackedMatrix< Real >::NumRows().

                                           {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
  for (MatrixIndexT i = 0; i < A.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      KALDI_ASSERT(std::abs(A(i, j) - B(i, j))
                   < tol * std::max(1.0, (double) (std::abs(A(i, j)) + std::abs(B(i, j)))));
}

AssertEqual() [9/12]

void kaldi::AssertEqual ( const CuSpMatrix< Real > &  A, const CuSpMatrix< Real > &  B, Real  tol = 0.001  )

inline

Definition at line 147 of file cu-sp-matrix.h.

References CuSpMatrix< Real >::ApproxEqual(), and KALDI_ASSERT.

                                                                     {
  KALDI_ASSERT(ApproxEqual(A, B, tol));
}

AssertEqual() [10/12]

static void kaldi::AssertEqual ( float  a, float  b, float  relative_tolerance = 0.001  )

inlinestatic

assert abs(a - b) <= relative_tolerance * (abs(a)+abs(b))

Definition at line 276 of file kaldi-math.h.

References ApproxEqual(), KALDI_ASSERT, rnnlm::n, and RoundUpToNearestPowerOfTwo().

Referenced by AddToClustersOptimized(), CholeskyUnitTestTr(), CuCompressedMatrixTestSign(), CuVectorUnitTestAddColSumMat(), CuVectorUnitTestAddDiagMat2(), CuVectorUnitTestAddDiagMatMat(), CuVectorUnitTestAddMatVec(), CuVectorUnitTestAddRowSumMat(), CuVectorUnitTestAddSpVec(), CuVectorUnitTestAddVec(), CuVectorUnitTestAddVecCross(), CuVectorUnitTestAddVecExtra(), CuVectorUnitTestAddVecVec(), CuVectorUnitTestApplyCeiling(), CuVectorUnitTestApplyCeilingNoCount(), CuVectorUnitTestApplyFloor(), CuVectorUnitTestApplyFloorNoCount(), CuVectorUnitTestApplyPow(), CuVectorUnitTestApplySoftMax(), CuVectorUnitTestCopyCross(), CuVectorUnitTestCopyCross2(), CuVectorUnitTestCopyDiagFromMat(), CuVectorUnitTestCopyElements(), CuVectorUnitTestInvertElements(), CuVectorUnitTestVecVec(), RegressionTree::GatherStats(), PldaEstimator::GetOutput(), fst::LatticeWeightTest(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), test_flags_driven_update(), test_io(), TestAddToClusters(), TestAddToClustersOptimized(), TestAmDiagGmmAccsIO(), TestAmDiagGmmIO(), TestComponentAcc(), fst::TestContextFst(), TestCuMatrixCopyFromSp(), TestCuMatrixCopyFromTp(), TestCuMatrixCopyLowerToUpper(), TestCuMatrixCopyUpperToLower(), TestCuMatrixTransposeCross(), TestDistance(), TestMllrAccsIO(), TestObjfMinus(), TestObjfPlus(), TestOnlineMatrixCacheFeature(), TestOnlineMatrixInput(), TestOnlineMfcc(), TestOnlinePlp(), TestOnlineTransform(), TestRefineClusters(), TestSgmm2AccsIO(), TestSgmm2FmllrAccsIO(), TestSgmm2IncreaseDim(), TestSgmm2Init(), TestSgmm2IO(), TestSgmm2Substates(), kaldi::nnet3::TestSimpleComponentPropagateProperties(), TestSplitStates(), TestSum(), TestSumObjfAndSumNormalizer(), TestXformMean(), UnitTestAddDiagMat2(), UnitTestAddDiagMatMat(), UnitTestAddDiagVecMat(), UnitTestAddMat2(), UnitTestAddMat2Sp(), UnitTestAddMatDiagVec(), UnitTestAddMatMatElements(), UnitTestAddMatSelf(), UnitTestAddMatSmat(), UnitTestAddOuterProductPlusMinus(), UnitTestAddRows(), UnitTestAddSp(), UnitTestAddToDiag(), UnitTestAddToDiagMatrix(), UnitTestAddToRows(), UnitTestAddVec2Sp(), UnitTestAddVecCross(), UnitTestAddVecToCols(), UnitTestAddVecToRows(), UnitTestAddVecVec(), UnitTestApplyExpSpecial(), UnitTestAssertFunc(), kaldi::nnet3::attention::UnitTestAttentionDotProductAndAddScales(), UnitTestAxpy(), UnitTestBackpropLstmNonlinearity(), UnitTestCholesky(), UnitTestComplexFft(), UnitTestComplexFt(), UnitTestComplexPower(), UnitTestCompressedMatrix(), kaldi::nnet1::UnitTestConvolutionalComponent3x3(), kaldi::nnet1::UnitTestConvolutionalComponentUnity(), UnitTestCopyCols(), UnitTestCopyRows(), UnitTestCopySp(), UnitTestCopyToRows(), UnitTestCuArray(), UnitTestCuBlockMatrixAddMatBlock(), UnitTestCuBlockMatrixIO(), UnitTestCuDiffNormalizePerRow(), UnitTestCuMathComputeLstmNonlinearity(), UnitTestCuMathCopy(), UnitTestCuMathNormalizePerRow(), UnitTestCuMathNormalizePerRow_v2(), UnitTestCuMathRandomize(), UnitTestCuMathSplice(), UnitTestCuPackedMatrixConstructor(), UnitTestCuPackedMatrixCopy(), UnitTestCuPackedMatrixScale(), UnitTestCuPackedMatrixScaleDiag(), UnitTestCuPackedMatrixTrace(), UnitTestCuSparseMatrixConstructFromIndexes(), UnitTestCuSparseMatrixCopyToSmat(), UnitTestCuSparseMatrixFrobeniusNorm(), UnitTestCuSparseMatrixSelectRowsAndTranspose(), UnitTestCuSparseMatrixSwap(), UnitTestCuSparseMatrixTraceMatSmat(), UnitTestCuSpMatrixAddMat2(), UnitTestCuSpMatrixAddSp(), UnitTestCuSpMatrixAddToDiag(), UnitTestCuSpMatrixAddVec2(), UnitTestCuSpMatrixConstructor(), UnitTestCuSpMatrixInvert(), UnitTestCuSpMatrixIO(), UnitTestCuSpMatrixSetUnit(), UnitTestCuTpMatrixCopyFromMat(), UnitTestCuTpMatrixIO(), UnitTestCuVectorAddTp(), UnitTestCuVectorCopyFromVec(), UnitTestCuVectorIO(), UnitTestCuVectorMulTp(), UnitTestCuVectorReplaceValue(), UnitTestDeterminantSign(), UnitTestDiagGmm(), UnitTestDiagGmmGenerate(), kaldi::nnet1::UnitTestDropoutComponent(), UnitTestEig(), UnitTestEigSymmetric(), UnitTestEndless1(), UnitTestEndless2(), UnitTestEstimateDiagGmm(), UnitTestEstimateFullGmm(), UnitTestFFTbasedBlockConvolution(), UnitTestFFTbasedConvolution(), UnitTestFloorCeiling(), UnitTestFullGmm(), UnitTestGeneralMatrix(), UnitTestHtkIo(), UnitTestInnerProd(), UnitTestInvert(), UnitTestIo(), UnitTestIoCross(), UnitTestIoNew(), UnitTestIoPipe(), kaldi::nnet1::UnitTestLengthNorm(), UnitTestLinearResample2(), UnitTestMat2Vec(), UnitTestMatrixAddMatSmat(), UnitTestMatrixAddSmatMat(), UnitTestMatrixRandomizer(), UnitTestMax2(), UnitTestMaxAbsEig(), UnitTestMaxMin(), kaldi::nnet1::UnitTestMaxPoolingComponent(), UnitTestMmulSym(), UnitTestMono22K(), UnitTestMul(), UnitTestMulTp(), kaldi::nnet2::UnitTestNnetCompute(), kaldi::nnet2::UnitTestNnetComputeChunked(), UnitTestNonsymmetricPower(), UnitTestPca(), UnitTestPca2(), UnitTestPieces(), UnitTestPower(), UnitTestPowerAbs(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), UnitTestRankNUpdate(), UnitTestRealFft(), UnitTestReplaceValue(), UnitTestResize(), UnitTestResizeCopyDataDifferentStrideType(), UnitTestRow(), UnitTestScaleDiag(), UnitTestSearch(), UnitTestSetDiag(), UnitTestSigmoid(), UnitTestSimple(), UnitTestSimpleForMat(), UnitTestSimpleForVec(), kaldi::nnet1::UnitTestSimpleSentenceAveragingComponent(), UnitTestSnipEdges(), UnitTestSoftHinge(), UnitTestSolve(), UnitTestSpAddDiagVec(), UnitTestSpAddVecVec(), UnitTestSparseMatrixAddToMat(), UnitTestSparseMatrixConstructor(), UnitTestSparseMatrixFrobeniusNorm(), UnitTestSparseMatrixSum(), UnitTestSparseMatrixTraceMatSmat(), UnitTestSparseVectorAddToVec(), UnitTestSparseVectorMax(), UnitTestSparseVectorSum(), UnitTestSpliceRows(), UnitTestSplitRadixComplexFft(), UnitTestSplitRadixRealFft(), UnitTestSpVec(), UnitTestStdVectorRandomizer(), UnitTestStereo8K(), UnitTestSubvector(), UnitTestSvd(), UnitTestSvdJustvec(), UnitTestSymAddMat2(), UnitTestTanh(), UnitTestTopEigs(), UnitTestTp2(), UnitTestTp2Sp(), UnitTestTrace(), UnitTestTraceSpSpLower(), UnitTestTranspose(), UnitTestTridiagonalize(), UnitTestTridiagonalizeAndQr(), UnitTestTriVecSolver(), UnitTestVecMatVec(), UnitTestVecmul(), UnitTestVector(), UnitTestVectorRandomizer(), UnitTestVtln(), FmllrSgmm2Accs::Update(), and AccumDiagGmm::variance_accumulator().

                                                                 {
  // a==b handles infinities.
  KALDI_ASSERT(ApproxEqual(a, b, relative_tolerance));
}

AssertEqual() [11/12]

void kaldi::AssertEqual ( const CuVectorBase< Real > &  a, const CuVectorBase< Real > &  b, Real  tol = 0.01  )

inline

Definition at line 370 of file cu-vector.h.

References KALDI_ASSERT.

                                                                      {
  KALDI_ASSERT(a.ApproxEqual(b, tol));
}

AssertEqual() [12/12]

void kaldi::AssertEqual ( const CuMatrixBase< Real > &  A, const CuMatrixBase< Real > &  B, float  tol = 0.01  )

inline

Definition at line 943 of file cu-matrix.h.

References KALDI_ASSERT.

                                                                       {
  KALDI_ASSERT(A.ApproxEqual(B, tol));
}

AttemptComplexPower() [1/2]

template bool kaldi::AttemptComplexPower	(	float *	x_re,
		float *	x_im,
		float	power
	)

AttemptComplexPower() [2/2]

template bool kaldi::AttemptComplexPower	(	double *	x_re,
		double *	x_im,
		double	power
	)

Referenced by AttemptComplexPower(), and MatrixBase< float >::Power().

AugmentGmmFlags()

GmmFlagsType AugmentGmmFlags

(

GmmFlagsType

f

)

Returns "augmented" version of flags: e.g.

if just updating means, need weights too.

Definition at line 52 of file model-common.cc.

References KALDI_ASSERT, KALDI_WARN, kGmmAll, kGmmMeans, kGmmVariances, and kGmmWeights.

Referenced by DiagGmmToStats(), AccumFullGmm::Resize(), and AccumDiagGmm::Resize().

                                                 {
KALDI_ASSERT((flags & ~kGmmAll) == 0);  // make sure only valid flags are present.
  if (flags & kGmmVariances) flags |= kGmmMeans;
  if (flags & kGmmMeans) flags |= kGmmWeights;
  if (!(flags & kGmmWeights)) {
    KALDI_WARN << "Adding in kGmmWeights (\"w\") to empty flags.";
    flags |= kGmmWeights; // Just add this in regardless:
    // if user wants no stats, this will stop programs from crashing due to dim mismatches.
  }
  return flags;
}

BiphoneContextDependencyFull()

ContextDependency* kaldi::BiphoneContextDependencyFull	(	std::vector< std::vector< int32 > >	phone_sets,
		const std::vector< int32 >	phone2num_pdf_classes,
		const std::vector< int32 > &	ci_phones_list,
		const std::vector< std::vector< int32 > > &	bi_counts,
		int32	biphone_min_count,
		const std::vector< int32 > &	mono_counts,
		int32	mono_min_count
	)

Definition at line 180 of file gmm-init-biphone.cc.

References GetFullBiphoneStubMap(), rnnlm::i, and rnnlm::j.

Referenced by main().

                                                   {
  // Remove all the CI phones from the phone sets
  std::set<int32> ci_phones;
  for (size_t i = 0; i < ci_phones_list.size(); i++)
    ci_phones.insert(ci_phones_list[i]);
  for (int32 i = phone_sets.size() - 1; i >= 0; i--) {
    for (int32 j = phone_sets[i].size() - 1; j >= 0; j--) {
      if (ci_phones.find(phone_sets[i][j]) != ci_phones.end()) {  // Delete it
        phone_sets[i].erase(phone_sets[i].begin() + j);
        if (phone_sets[i].empty())   // If empty, delete the whole entry
          phone_sets.erase(phone_sets.begin() + i);
      }
    }
  }

  std::vector<bool> share_roots(phone_sets.size(), false);  // Don't share roots
  // N is context size, P = position of central phone (must be 0).
  int32 P = 1, N = 2;
  EventMap *pdf_map = GetFullBiphoneStubMap(phone_sets,
                                            phone2num_pdf_classes,
                                            ci_phones_list, bi_counts,
                                            biphone_min_count, mono_counts,
                                            mono_min_count);
  return new ContextDependency(N, P, pdf_map);
}

BuildConstArpaLm()

bool BuildConstArpaLm	(	const ArpaParseOptions &	options,
		const std::string &	arpa_rxfilename,
		const std::string &	const_arpa_wxfilename
	)

Definition at line 1074 of file const-arpa-lm.cc.

References KALDI_LOG, ArpaFileParser::Read(), Input::Stream(), and WriteKaldiObject().

                                                              {
  ConstArpaLmBuilder lm_builder(options);
  KALDI_LOG << "Reading " << arpa_rxfilename;
  Input ki(arpa_rxfilename);
  lm_builder.Read(ki.Stream());
  WriteKaldiObject(lm_builder, const_arpa_wxfilename, true);
  return true;
}

CalBasisFmllrStepSize()

BaseFloat CalBasisFmllrStepSize ( const AffineXformStats &  spk_stats, const Matrix< BaseFloat > &  spk_stats_tmp_K, const std::vector< SpMatrix< BaseFloat > > &  spk_stats_tmp_G, const Matrix< BaseFloat > &  delta, const Matrix< BaseFloat > &  A, const Matrix< BaseFloat > &  S, int32  max_iters  )

static

This function takes the step direction (delta) of fMLLR matrix as argument, and optimize step size using Newton's method.

This is an iterative method, where each iteration should not decrease the auxiliary function. Note that the resulting step size should be close to 1. If <<1 or >>1, there maybe problems with preconditioning or the speaker stats.

Definition at line 374 of file basis-fmllr-diag-gmm.cc.

References MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddSpVec(), AffineXformStats::beta_, MatrixBase< Real >::CopyFromMat(), rnnlm::d, AffineXformStats::dim_, MatrixBase< Real >::InvertDouble(), KALDI_ASSERT, KALDI_WARN, kNoTrans, kTrans, MatrixBase< Real >::LogDet(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), TraceMat(), TraceMatMat(), and VecVec().

Referenced by BasisFmllrEstimate::ComputeTransform().

                   {

  int32 dim = spk_stats.dim_;
  KALDI_ASSERT(dim == delta.NumRows() && dim == S.NumRows());
  // The first D columns of delta_W
  SubMatrix<BaseFloat> delta_Dim(delta, 0, dim, 0, dim);
  // Eq. (46): b = tr(delta K^T) - tr(delta S^T)
  BaseFloat b = TraceMatMat(delta, spk_stats_tmp_K, kTrans)
                 - TraceMatMat(delta, S, kTrans);
  // Eq. (47): c = sum_d tr(delta_{d} G_{d} delta_{d})
  BaseFloat c = 0;
  Vector<BaseFloat> G_row_delta(dim + 1);
  for (int32 d = 0; d < dim; ++d) {
    G_row_delta.AddSpVec(1.0, spk_stats_tmp_G[d], delta.Row(d), 0.0);
    c += VecVec(G_row_delta, delta.Row(d));
  }

  // Sometimes, the change of step size, d1/d2, may get tiny
  // Due to numerical precision, we compute everything in double
  BaseFloat step_size = 0.0;
  BaseFloat obj_old, obj_new = 0.0;
  Matrix<BaseFloat> N(dim, dim);
  for (int32 iter_step = 1; iter_step <= max_iters; ++iter_step) {
    if (iter_step == 1) {
      // k = 0, auxf = beta logdet(A)
      obj_old = spk_stats.beta_ * A.LogDet();
    } else {
      obj_old = obj_new;
    }

    // Eq. (49): N = (A + k * delta_Dim)^{-1} delta_Dim
    // In case of bad condition, careful preconditioning should be done. Maybe safer
    // to use SolveQuadraticMatrixProblem. Future work for Yajie.
    Matrix<BaseFloat> tmp_A(A);
    tmp_A.AddMat(step_size, delta_Dim, kNoTrans);
    tmp_A.InvertDouble();
    N.AddMatMat(1.0, tmp_A, kNoTrans, delta_Dim, kNoTrans, 0.0);
    // first-order derivative w.r.t. k
    // Eq. (50): d1 = beta * trace(N) + b - k * c
    BaseFloat d1 = spk_stats.beta_ * TraceMat(N) + b - step_size * c;
    // second-order derivative w.r.t. k
    // Eq. (51): d2 = -beta * tr(N N) - c
    BaseFloat d2 = -c - spk_stats.beta_ * TraceMatMat(N, N, kNoTrans);
    d2 = std::min((double)d2, -c / 10.0);
    // convergence judgment from fmllr-sgmm.cc
    // it seems to work well, though not sure whether 1e-06 is appropriate
    // note from Dan: commenting this out after someone complained it was
    // causing a test to behave weirdly.  This doesn't dominate computation
    // anyway, I don't think.
    // if (std::fabs(d1 / d2) < 0.000001) { break; }

    // Eq. (52): update step_size
    BaseFloat step_size_change = -(d1 / d2);
    step_size += step_size_change;

    // Repeatedly check auxiliary function; halve step size change if auxf decreases.
    // According to the paper, we should limit the number of repetitions. The
    // following implementation seems to work well. But the termination condition/judgment
    // should be optimized later.
    do {
      // Eq. (48): auxf = beta * logdet(A + k * delta_Dim) + kb - 0.5 * k * k * c
      tmp_A.CopyFromMat(A);
      tmp_A.AddMat(step_size, delta_Dim, kNoTrans);
      obj_new = spk_stats.beta_ * tmp_A.LogDet() + step_size * b -
          0.5 * step_size * step_size * c;

      if (obj_new - obj_old < -1.0e-04 * spk_stats.beta_) {  // deal with numerical issues
        KALDI_WARN << "Objective function decreased (" << obj_old << "->"
                   << obj_new << "). Halving step size change ( step size "
                   << step_size << " -> " << (step_size - (step_size_change/2))
                   << ")";
        step_size_change /= 2;
        step_size -= step_size_change;
      }
    } while (obj_new - obj_old < -1.0e-04 * spk_stats.beta_ && step_size_change > 1e-05);
  }
  return step_size;
}

CalcFmllrStepSize()

static BaseFloat kaldi::CalcFmllrStepSize ( const AffineXformStats &  stats, const AmSgmm2 &  sgmm, const MatrixBase< BaseFloat > &  Delta, const MatrixBase< BaseFloat > &  A, const Matrix< BaseFloat > &  G, int32  max_iters  )

static

Definition at line 286 of file fmllr-sgmm2.cc.

References MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatMat(), AffineXformStats::beta_, MatrixBase< Real >::CopyFromMat(), rnnlm::d, AmSgmm2::FeatureDim(), AffineXformStats::G_, AmSgmm2::GetInvCovars(), rnnlm::i, MatrixBase< Real >::InvertDouble(), AffineXformStats::K_, KALDI_WARN, kNoTrans, kTrans, MatrixBase< Real >::LogDet(), rnnlm::n, AmSgmm2::NumGauss(), TraceMat(), TraceMatMat(), and TraceMatSpMatSp().

Referenced by FmllrSgmm2Accs::Update().

                                                    {
  int32 dim = sgmm.FeatureDim();
  Matrix<double> Delta_d(Delta);
  Matrix<double> G_d(G);
  SubMatrix<double> Delta_C(Delta_d, 0, dim, 0, dim);

  // Eq. (B.28): m = tr(\Delta K^T) - tr(\Delta S^T)
  BaseFloat m = TraceMatMat(Delta_d, stats.K_, kTrans)
                    - TraceMatMat(Delta_d, G_d, kTrans);
  // Eq. (B.29): n = \sum_i tr(\Delta \Sigma_{i}^{-1} \Delta S_{i})
  BaseFloat n = 0;
  SpMatrix<double> inv_covar;
  for (int32 i = 0, num_gauss = sgmm.NumGauss(); i < num_gauss; i++) {
    sgmm.GetInvCovars(i, &inv_covar);
    n += TraceMatSpMatSp(Delta_d, kTrans, inv_covar, Delta_d, kNoTrans,
                         stats.G_[i]);
  }

  BaseFloat step_size = 0.0;
  // initialize just to get rid of compile errors.
  BaseFloat obj_step_old, obj_step_new = 0.0;
  Matrix<double> new_A(dim, dim);
  Matrix<double> B(dim, dim);
  for (int32 iter_step = 0; iter_step < max_iters; iter_step++) {
    if (iter_step == 0) {
      obj_step_old = stats.beta_ * A.LogDet();  // Q_0 = \beta * log det(A)
    } else {
      obj_step_old = obj_step_new;
    }

    // Eq. (B.30); B = (A + k\Delta^{-C})^{-1} \Delta^{-C}
    new_A.CopyFromMat(A);
    new_A.AddMat(step_size, Delta_C, kNoTrans);
    new_A.InvertDouble();
    B.AddMatMat(1.0, new_A, kNoTrans, Delta_C, kNoTrans, 0.0);

    BaseFloat d = m - step_size * n + stats.beta_ * TraceMat(B);
    BaseFloat d2 = -n - stats.beta_ * TraceMatMat(B, B, kNoTrans);
    if (std::fabs(d / d2) < 0.000001) { break; }  // converged

    BaseFloat step_size_change = -(d / d2);
    step_size += step_size_change;  // Eq. (B.33)

    // Halve step size when the auxiliary function decreases.
    do {
      new_A.CopyFromMat(A);
      new_A.AddMat(step_size, Delta_C, kNoTrans);
      BaseFloat logdet = new_A.LogDet();
      obj_step_new = stats.beta_ * logdet + step_size * m -
          0.5 * step_size * step_size * n;

      if (obj_step_new - obj_step_old < -0.001) {
        KALDI_WARN << "Objective function decreased (" << obj_step_old << "->"
                   << obj_step_new << "). Halving step size change ("
                   << step_size << " -> " << (step_size - (step_size_change/2))
                   << ")";
        step_size_change /= 2;
        step_size -= step_size_change;  // take away half of our step
      }  // Facing numeric precision issues. Compute in double?
    } while (obj_step_new - obj_step_old < -0.001 && step_size_change > 1e-05);
  }
  return step_size;
}

cblas_Xasum() [1/2]

float kaldi::cblas_Xasum ( const int  N, const float *  X, const int  incX  )

inline

Definition at line 48 of file cblas-wrappers.h.

                                                                      {
  return cblas_sasum(N, X, incX);
}

cblas_Xasum() [2/2]

double kaldi::cblas_Xasum ( const int  N, const double *  X, const int  incX  )

inline

Definition at line 52 of file cblas-wrappers.h.

                                                                        {
  return cblas_dasum(N, X, incX);
}

cblas_Xaxpy() [1/2]

void kaldi::cblas_Xaxpy ( const int  N, const float  alpha, const float *  X, const int  incX, float *  Y, const int  incY  )

inline

Definition at line 74 of file cblas-wrappers.h.

Referenced by MatrixBase< float >::AddDiagVecMat(), MatrixBase< float >::AddMat(), MatrixBase< float >::AddMatSmat(), PackedMatrix< float >::AddPacked(), MatrixBase< float >::AddRows(), VectorBase< float >::AddRowSumMat(), MatrixBase< float >::AddSmatMat(), MatrixBase< float >::AddToRows(), VectorBase< float >::AddVec(), SpMatrix< float >::Tridiagonalize(), and Xgemv_sparsevec().

                                                                  {
  cblas_saxpy(N, alpha, X, incX, Y, incY);
}

cblas_Xaxpy() [2/2]

void kaldi::cblas_Xaxpy ( const int  N, const double  alpha, const double *  X, const int  incX, double *  Y, const int  incY  )

inline

Definition at line 78 of file cblas-wrappers.h.

                                                                   {
  cblas_daxpy(N, alpha, X, incX, Y, incY);
}

cblas_Xcopy() [1/2]

void kaldi::cblas_Xcopy ( const int  N, const float *  X, const int  incX, float *  Y, const int  incY  )

inline

Definition at line 37 of file cblas-wrappers.h.

Referenced by VectorBase< float >::CopyDiagFromMat(), MatrixBase< float >::CopyRows(), and MatrixBase< float >::CopyToRows().

                                        {
  cblas_scopy(N, X, incX, Y, incY);
}

cblas_Xcopy() [2/2]

void kaldi::cblas_Xcopy ( const int  N, const double *  X, const int  incX, double *  Y, const int  incY  )

inline

Definition at line 42 of file cblas-wrappers.h.

                                        {
  cblas_dcopy(N, X, incX, Y, incY);
}

cblas_Xdot() [1/2]

float kaldi::cblas_Xdot ( const int  N, const float *const  X, const int  incX, const float *const  Y, const int  incY  )

inline

Definition at line 64 of file cblas-wrappers.h.

Referenced by VectorBase< float >::AddDiagMat2(), VectorBase< float >::AddDiagMatMat(), TpMatrix< float >::Cholesky(), VectorBase< float >::Sum(), TraceMatMat(), TraceSpSp(), TraceSpSpLower(), SpMatrix< float >::Tridiagonalize(), and VecVec().

                                        {
  return cblas_sdot(N, X, incX, Y, incY);
}

cblas_Xdot() [2/2]

double kaldi::cblas_Xdot ( const int  N, const double *const  X, const int  incX, const double *const  Y, const int  incY  )

inline

Definition at line 69 of file cblas-wrappers.h.

                                        {
  return cblas_ddot(N, X, incX, Y, incY);
}

cblas_Xgbmv() [1/2]

void kaldi::cblas_Xgbmv ( MatrixTransposeType  trans, MatrixIndexT  num_rows, MatrixIndexT  num_cols, MatrixIndexT  num_below, MatrixIndexT  num_above, float  alpha, const float *  Mdata, MatrixIndexT  stride, const float *  xdata, MatrixIndexT  incX, float  beta, float *  ydata, MatrixIndexT  incY  )

inline

Definition at line 178 of file cblas-wrappers.h.

Referenced by VectorBase< float >::AddVecVec().

                                                                                        {
  cblas_sgbmv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,
              num_cols, num_below, num_above, alpha, Mdata, stride, xdata,
              incX, beta, ydata, incY);
}

cblas_Xgbmv() [2/2]

void kaldi::cblas_Xgbmv ( MatrixTransposeType  trans, MatrixIndexT  num_rows, MatrixIndexT  num_cols, MatrixIndexT  num_below, MatrixIndexT  num_above, double  alpha, const double *  Mdata, MatrixIndexT  stride, const double *  xdata, MatrixIndexT  incX, double  beta, double *  ydata, MatrixIndexT  incY  )

inline

Definition at line 187 of file cblas-wrappers.h.

                                                                                          {
  cblas_dgbmv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,
              num_cols, num_below, num_above, alpha, Mdata, stride, xdata,
              incX, beta, ydata, incY);
}

cblas_Xgemm() [1/2]

void kaldi::cblas_Xgemm ( const float  alpha, MatrixTransposeType  transA, const float *  Adata, MatrixIndexT  a_num_rows, MatrixIndexT  a_num_cols, MatrixIndexT  a_stride, MatrixTransposeType  transB, const float *  Bdata, MatrixIndexT  b_stride, const float  beta, float *  Mdata, MatrixIndexT  num_rows, MatrixIndexT  num_cols, MatrixIndexT  stride  )

inline

Definition at line 224 of file cblas-wrappers.h.

References kNoTrans.

Referenced by MatrixBase< float >::AddMatMat().

                                                                                          {
  cblas_sgemm(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(transA), 
              static_cast<CBLAS_TRANSPOSE>(transB),
              num_rows, num_cols, transA == kNoTrans ? a_num_cols : a_num_rows,
              alpha, Adata, a_stride, Bdata, b_stride,
              beta, Mdata, stride); 
}

cblas_Xgemm() [2/2]

void kaldi::cblas_Xgemm ( const double  alpha, MatrixTransposeType  transA, const double *  Adata, MatrixIndexT  a_num_rows, MatrixIndexT  a_num_cols, MatrixIndexT  a_stride, MatrixTransposeType  transB, const double *  Bdata, MatrixIndexT  b_stride, const double  beta, double *  Mdata, MatrixIndexT  num_rows, MatrixIndexT  num_cols, MatrixIndexT  stride  )

inline

Definition at line 239 of file cblas-wrappers.h.

References kNoTrans.

                                                                                          {
  cblas_dgemm(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(transA), 
              static_cast<CBLAS_TRANSPOSE>(transB),
              num_rows, num_cols, transA == kNoTrans ? a_num_cols : a_num_rows,
              alpha, Adata, a_stride, Bdata, b_stride,
              beta, Mdata, stride); 
}

cblas_Xgemv() [1/2]

void kaldi::cblas_Xgemv ( MatrixTransposeType  trans, MatrixIndexT  num_rows, MatrixIndexT  num_cols, float  alpha, const float *  Mdata, MatrixIndexT  stride, const float *  xdata, MatrixIndexT  incX, float  beta, float *  ydata, MatrixIndexT  incY  )

inline

Definition at line 162 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::AddMat2Sp(), VectorBase< float >::AddMatVec(), and SpMatrix< float >::Tridiagonalize().

                                                                                        {
  cblas_sgemv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,
              num_cols, alpha, Mdata, stride, xdata, incX, beta, ydata, incY);
}

cblas_Xgemv() [2/2]

void kaldi::cblas_Xgemv ( MatrixTransposeType  trans, MatrixIndexT  num_rows, MatrixIndexT  num_cols, double  alpha, const double *  Mdata, MatrixIndexT  stride, const double *  xdata, MatrixIndexT  incX, double  beta, double *  ydata, MatrixIndexT  incY  )

inline

Definition at line 169 of file cblas-wrappers.h.

                                                                                          {
  cblas_dgemv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,
              num_cols, alpha, Mdata, stride, xdata, incX, beta, ydata, incY);
}

cblas_Xger() [1/2]

void kaldi::cblas_Xger ( MatrixIndexT  num_rows, MatrixIndexT  num_cols, float  alpha, const float *  xdata, MatrixIndexT  incX, const float *  ydata, MatrixIndexT  incY, float *  Mdata, MatrixIndexT  stride  )

inline

Definition at line 275 of file cblas-wrappers.h.

Referenced by MatrixBase< float >::AddVecVec(), and SpMatrix< float >::Tridiagonalize().

                                                                             {
  cblas_sger(CblasRowMajor, num_rows, num_cols, alpha, xdata, 1, ydata, 1,
             Mdata, stride);
}

cblas_Xger() [2/2]

void kaldi::cblas_Xger ( MatrixIndexT  num_rows, MatrixIndexT  num_cols, double  alpha, const double *  xdata, MatrixIndexT  incX, const double *  ydata, MatrixIndexT  incY, double *  Mdata, MatrixIndexT  stride  )

inline

Definition at line 281 of file cblas-wrappers.h.

                                                                              {
  cblas_dger(CblasRowMajor, num_rows, num_cols, alpha, xdata, 1, ydata, 1,
             Mdata, stride);
}

cblas_Xrot() [1/2]

void kaldi::cblas_Xrot ( const int  N, float *  X, const int  incX, float *  Y, const int  incY, const float  c, const float  s  )

inline

Definition at line 56 of file cblas-wrappers.h.

Referenced by QrStep().

                                                                     {
  cblas_srot(N, X, incX, Y, incY, c, s);
}

cblas_Xrot() [2/2]

void kaldi::cblas_Xrot ( const int  N, double *  X, const int  incX, double *  Y, const int  incY, const double  c, const double  s  )

inline

Definition at line 60 of file cblas-wrappers.h.

                                                                       {
  cblas_drot(N, X, incX, Y, incY, c, s);
}

cblas_Xsbmv1() [1/2]

void kaldi::cblas_Xsbmv1 ( const MatrixIndexT  dim, const double *  A, const double  alpha, const double *  x, const double  beta, double *  y  )

inline

matrix-vector multiply using a banded matrix; we always call this with b = 1 meaning we're multiplying by a diagonal matrix.

This is used for elementwise multiplication. We miss some of the arguments out of this wrapper.

Definition at line 317 of file cblas-wrappers.h.

               {
  cblas_dsbmv(CblasRowMajor, CblasLower, dim, 0, alpha, A,
              1, x, 1, beta, y, 1);
}

cblas_Xsbmv1() [2/2]

void kaldi::cblas_Xsbmv1 ( const MatrixIndexT  dim, const float *  A, const float  alpha, const float *  x, const float  beta, float *  y  )

inline

Definition at line 328 of file cblas-wrappers.h.

              {
  cblas_ssbmv(CblasRowMajor, CblasLower, dim, 0, alpha, A,
              1, x, 1, beta, y, 1);
}

cblas_Xscal() [1/2]

void kaldi::cblas_Xscal ( const int  N, const float  alpha, float *  data, const int  inc  )

inline

Definition at line 82 of file cblas-wrappers.h.

Referenced by VectorBase< float >::AddRowSumMat(), HouseBackward(), MatrixBase< float >::MulRowsGroupMat(), PackedMatrix< float >::Scale(), MatrixBase< float >::Scale(), VectorBase< float >::Scale(), and Xgemv_sparsevec().

                                       {
  cblas_sscal(N, alpha, data, inc);
}

cblas_Xscal() [2/2]

void kaldi::cblas_Xscal ( const int  N, const double  alpha, double *  data, const int  inc  )

inline

Definition at line 86 of file cblas-wrappers.h.

                                       {
  cblas_dscal(N, alpha, data, inc);
}

cblas_Xspmv() [1/4]

void kaldi::cblas_Xspmv ( const float  alpha, const int  num_rows, const float *  Mdata, const float *  v, const int  v_inc, const float  beta, float *  y, const int  y_inc  )

inline

Definition at line 90 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::AddMat2Sp(), VectorBase< float >::AddSpVec(), SpMatrix< float >::Tridiagonalize(), UnitTestTridiagonalize(), UnitTestTridiagonalizeAndQr(), and VecSpVec().

                                                                     {
  cblas_sspmv(CblasRowMajor, CblasLower, num_rows, alpha, Mdata, v, v_inc, beta, y, y_inc);
}

cblas_Xspmv() [2/4]

void kaldi::cblas_Xspmv ( const double  alpha, const int  num_rows, const double *  Mdata, const double *  v, const int  v_inc, const double  beta, double *  y, const int  y_inc  )

inline

Definition at line 95 of file cblas-wrappers.h.

                                                                       {
  cblas_dspmv(CblasRowMajor, CblasLower, num_rows, alpha, Mdata, v, v_inc, beta, y, y_inc);
}

cblas_Xspmv() [3/4]

void kaldi::cblas_Xspmv ( MatrixIndexT  dim, float  alpha, const float *  Mdata, const float *  ydata, MatrixIndexT  ystride, float  beta, float *  xdata, MatrixIndexT  xstride  )

inline

Definition at line 124 of file cblas-wrappers.h.

                                                                        {
  cblas_sspmv(CblasRowMajor, CblasLower, dim, alpha, Mdata,
              ydata, ystride, beta, xdata, xstride);
}

cblas_Xspmv() [4/4]

void kaldi::cblas_Xspmv ( MatrixIndexT  dim, double  alpha, const double *  Mdata, const double *  ydata, MatrixIndexT  ystride, double  beta, double *  xdata, MatrixIndexT  xstride  )

inline

Definition at line 130 of file cblas-wrappers.h.

                                                                          {
  cblas_dspmv(CblasRowMajor, CblasLower, dim, alpha, Mdata,
              ydata, ystride, beta, xdata, xstride);
}

cblas_Xspr() [1/2]

void kaldi::cblas_Xspr ( MatrixIndexT  dim, float  alpha, const float *  Xdata, MatrixIndexT  incX, float *  Adata  )

inline

Definition at line 152 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::AddMat2Vec(), and SpMatrix< float >::AddVec2().

                                                        {
  cblas_sspr(CblasRowMajor, CblasLower, dim, alpha, Xdata, incX, Adata);
}

cblas_Xspr() [2/2]

void kaldi::cblas_Xspr ( MatrixIndexT  dim, double  alpha, const double *  Xdata, MatrixIndexT  incX, double *  Adata  )

inline

Definition at line 156 of file cblas-wrappers.h.

                                                         {
  cblas_dspr(CblasRowMajor, CblasLower, dim, alpha, Xdata, incX, Adata);
}

cblas_Xspr2() [1/2]

void kaldi::cblas_Xspr2 ( MatrixIndexT  dim, float  alpha, const float *  Xdata, MatrixIndexT  incX, const float *  Ydata, MatrixIndexT  incY, float *  Adata  )

inline

Definition at line 138 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::AddVecVec(), and SpMatrix< float >::Tridiagonalize().

                                        {
  cblas_sspr2(CblasRowMajor, CblasLower, dim, alpha, Xdata,
              incX, Ydata, incY, Adata);
}

cblas_Xspr2() [2/2]

void kaldi::cblas_Xspr2 ( MatrixIndexT  dim, double  alpha, const double *  Xdata, MatrixIndexT  incX, const double *  Ydata, MatrixIndexT  incY, double *  Adata  )

inline

Definition at line 144 of file cblas-wrappers.h.

                                       {
  cblas_dspr2(CblasRowMajor, CblasLower, dim, alpha, Xdata,
              incX, Ydata, incY, Adata);
}

cblas_Xsymm() [1/2]

void kaldi::cblas_Xsymm ( const float  alpha, MatrixIndexT  sz, const float *  Adata, MatrixIndexT  a_stride, const float *  Bdata, MatrixIndexT  b_stride, const float  beta, float *  Mdata, MatrixIndexT  stride  )

inline

Definition at line 256 of file cblas-wrappers.h.

Referenced by MatrixBase< float >::AddSpSp().

                                                           {
  cblas_ssymm(CblasRowMajor, CblasLeft, CblasLower, sz, sz, alpha, Adata,
              a_stride, Bdata, b_stride, beta, Mdata, stride);
}

cblas_Xsymm() [2/2]

void kaldi::cblas_Xsymm ( const double  alpha, MatrixIndexT  sz, const double *  Adata, MatrixIndexT  a_stride, const double *  Bdata, MatrixIndexT  b_stride, const double  beta, double *  Mdata, MatrixIndexT  stride  )

inline

Definition at line 265 of file cblas-wrappers.h.

                                                            {
  cblas_dsymm(CblasRowMajor, CblasLeft, CblasLower, sz, sz, alpha, Adata,
              a_stride, Bdata, b_stride, beta, Mdata, stride);
}

cblas_Xsyrk() [1/2]

void kaldi::cblas_Xsyrk ( const MatrixTransposeType  trans, const MatrixIndexT  dim_c, const MatrixIndexT  other_dim_a, const float  alpha, const float *  A, const MatrixIndexT  a_stride, const float  beta, float *  C, const MatrixIndexT  c_stride  )

inline

Definition at line 295 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::AddMat2(), and MatrixBase< float >::SymAddMat2().

                                 {
  cblas_ssyrk(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),
              dim_c, other_dim_a, alpha, A, a_stride, beta, C, c_stride);
}

cblas_Xsyrk() [2/2]

void kaldi::cblas_Xsyrk ( const MatrixTransposeType  trans, const MatrixIndexT  dim_c, const MatrixIndexT  other_dim_a, const double  alpha, const double *  A, const MatrixIndexT  a_stride, const double  beta, double *  C, const MatrixIndexT  c_stride  )

inline

Definition at line 304 of file cblas-wrappers.h.

                                 {
  cblas_dsyrk(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),
              dim_c, other_dim_a, alpha, A, a_stride, beta, C, c_stride);
}

cblas_Xtpmv() [1/2]

void kaldi::cblas_Xtpmv ( MatrixTransposeType  trans, const float *  Mdata, const int  num_rows, float *  y, const int  y_inc  )

inline

Definition at line 100 of file cblas-wrappers.h.

Referenced by VectorBase< float >::MulTp().

                                                                       {
  cblas_stpmv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),
              CblasNonUnit, num_rows, Mdata, y, y_inc);
}

cblas_Xtpmv() [2/2]

void kaldi::cblas_Xtpmv ( MatrixTransposeType  trans, const double *  Mdata, const int  num_rows, double *  y, const int  y_inc  )

inline

Definition at line 105 of file cblas-wrappers.h.

                                                                        {
  cblas_dtpmv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),
              CblasNonUnit, num_rows, Mdata, y, y_inc);
}

cblas_Xtpsv() [1/2]

void kaldi::cblas_Xtpsv ( MatrixTransposeType  trans, const float *  Mdata, const int  num_rows, float *  y, const int  y_inc  )

inline

Definition at line 112 of file cblas-wrappers.h.

Referenced by VectorBase< float >::Solve().

                                                                       {
  cblas_stpsv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),
              CblasNonUnit, num_rows, Mdata, y, y_inc);
}

cblas_Xtpsv() [2/2]

void kaldi::cblas_Xtpsv ( MatrixTransposeType  trans, const double *  Mdata, const int  num_rows, double *  y, const int  y_inc  )

inline

Definition at line 117 of file cblas-wrappers.h.

                                                                        {
  cblas_dtpsv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),
              CblasNonUnit, num_rows, Mdata, y, y_inc);
}

CharToString()

std::string CharToString

(

const char &

c

)

Definition at line 36 of file kaldi-utils.cc.

Referenced by SequentialTableReaderArchiveImpl< Holder >::Next(), BasicHolder< BasicType >::Read(), EventMap::Read(), TokenHolder::Read(), ReadBasicType< bool >(), RandomAccessTableReaderArchiveImplBase< Holder >::ReadNextObject(), ReadToken(), TreeRenderer::RenderSubTree(), StringToGmmFlags(), StringToSgmmUpdateFlags(), StringToSgmmWriteFlags(), UnitTestTableRandomBothDouble(), UnitTestTableRandomBothDoubleMatrix(), UnitTestTableSequentialBaseFloatVectorBoth(), UnitTestTableSequentialBool(), UnitTestTableSequentialDouble(), UnitTestTableSequentialDoubleBoth(), UnitTestTableSequentialDoubleMatrixBoth(), UnitTestTableSequentialInt32(), UnitTestTableSequentialInt32PairVectorBoth(), UnitTestTableSequentialInt32VectorBoth(), and UnitTestTableSequentialInt32VectorVectorBoth().

                                      {
  char buf[20];
  if (std::isprint(c))
    snprintf(buf, sizeof(buf), "\'%c\'", c);
  else
    snprintf(buf, sizeof(buf), "[character %d]", static_cast<int>(c));
  return (std::string) buf;
}

CheckFst()

bool kaldi::CheckFst	(	const fst::StdVectorFst &	fst,
		string	name,
		string	key
	)

Definition at line 151 of file lattice-oracle.cc.

Referenced by main().

                                                                   {
#ifdef DEBUG
  fst::StdArc::StateId numstates = fst.NumStates();
  std::cerr << " " << name << " has " << numstates << " states" << std::endl;
  std::stringstream ss;
  ss << name << key << ".fst";
  fst.Write(ss.str());
  return(fst.Start() == fst::kNoStateId);
#else
  return true;
#endif
}

CheckToken()

void kaldi::CheckToken

(

const char *

token

)

Definition at line 122 of file io-funcs.cc.

References KALDI_ERR.

Referenced by ExpectToken(), and WriteToken().

                                   {
  if (*token == '\0')
    KALDI_ERR << "Token is empty (not a valid token)";
  const char *orig_token = token;
  while (*token != '\0') {
    if (::isspace(*token))
      KALDI_ERR << "Token is not a valid token (contains space): '"
                << orig_token << "'";
    token++;
  }
}

CholeskyUnitTestTr()

static void kaldi::CholeskyUnitTestTr ( )

static

Definition at line 140 of file matrix-lib-test.cc.

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatMat(), AssertEqual(), TpMatrix< Real >::Cholesky(), rnnlm::i, InitRandNonsingular(), TpMatrix< Real >::Invert(), MatrixBase< Real >::Invert(), MatrixBase< Real >::IsUnit(), KALDI_ASSERT, kNoTrans, and Rand().

                                                         {
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = 2 + Rand() % 10;
    Matrix<Real> M(dimM, dimM);
    InitRandNonsingular(&M);
    SpMatrix<Real> S(dimM);
    S.AddMat2(1.0, M, kNoTrans, 0.0);
    TpMatrix<Real> C(dimM);
    C.Cholesky(S);
    Matrix<Real> CM(C);
    TpMatrix<Real> Cinv(C);
    Cinv.Invert();
    {
      Matrix<Real> A(C), B(Cinv), AB(dimM, dimM);
      AB.AddMatMat(1.0, A, kNoTrans, B, kNoTrans, 0.0);
      KALDI_ASSERT(AB.IsUnit());
    }
    SpMatrix<Real> S2(dimM);
    S2.AddMat2(1.0, CM, kNoTrans, 0.0);
    AssertEqual(S, S2);
    C.Invert();
    Matrix<Real> CM2(C);
    CM2.Invert();
    SpMatrix<Real> S3(dimM);
    S3.AddMat2(1.0, CM2, kNoTrans, 0.0);
    AssertEqual(S, S3);
  }
}

clapack_Xgesvd() [1/2]

void kaldi::clapack_Xgesvd ( char *  v, char *  u, KaldiBlasInt *  num_cols, KaldiBlasInt *  num_rows, float *  Mdata, KaldiBlasInt *  stride, float *  sv, float *  Vdata, KaldiBlasInt *  vstride, float *  Udata, KaldiBlasInt *  ustride, float *  p_work, KaldiBlasInt *  l_work, KaldiBlasInt *  result  )

inline

Definition at line 415 of file cblas-wrappers.h.

Referenced by MatrixBase< float >::LapackGesvd().

                                                                       {
  sgesvd_(v, u,
          num_cols, num_rows, Mdata, stride,
          sv, Vdata, vstride, Udata, ustride, 
          p_work, l_work, result); 
}

clapack_Xgesvd() [2/2]

void kaldi::clapack_Xgesvd ( char *  v, char *  u, KaldiBlasInt *  num_cols, KaldiBlasInt *  num_rows, double *  Mdata, KaldiBlasInt *  stride, double *  sv, double *  Vdata, KaldiBlasInt *  vstride, double *  Udata, KaldiBlasInt *  ustride, double *  p_work, KaldiBlasInt *  l_work, KaldiBlasInt *  result  )

inline

Definition at line 425 of file cblas-wrappers.h.

                                                                       {
  dgesvd_(v, u,
          num_cols, num_rows, Mdata, stride,
          sv, Vdata, vstride, Udata, ustride,
          p_work, l_work, result); 
}

clapack_Xgetrf2() [1/2]

void kaldi::clapack_Xgetrf2 ( KaldiBlasInt *  num_rows, KaldiBlasInt *  num_cols, float *  Mdata, KaldiBlasInt *  stride, KaldiBlasInt *  pivot, KaldiBlasInt *  result  )

inline

Definition at line 392 of file cblas-wrappers.h.

Referenced by MatrixBase< float >::Invert().

                                                  {
  sgetrf_(num_rows, num_cols, Mdata, stride, pivot, result);
}

clapack_Xgetrf2() [2/2]

void kaldi::clapack_Xgetrf2 ( KaldiBlasInt *  num_rows, KaldiBlasInt *  num_cols, double *  Mdata, KaldiBlasInt *  stride, KaldiBlasInt *  pivot, KaldiBlasInt *  result  )

inline

Definition at line 397 of file cblas-wrappers.h.

                                                  {
  dgetrf_(num_rows, num_cols, Mdata, stride, pivot, result);
}

clapack_Xgetri2() [1/2]

void kaldi::clapack_Xgetri2 ( KaldiBlasInt *  num_rows, float *  Mdata, KaldiBlasInt *  stride, KaldiBlasInt *  pivot, float *  p_work, KaldiBlasInt *  l_work, KaldiBlasInt *  result  )

inline

Definition at line 404 of file cblas-wrappers.h.

Referenced by MatrixBase< float >::Invert().

                                                                       {
  sgetri_(num_rows, Mdata, stride, pivot, p_work, l_work, result);
}

clapack_Xgetri2() [2/2]

void kaldi::clapack_Xgetri2 ( KaldiBlasInt *  num_rows, double *  Mdata, KaldiBlasInt *  stride, KaldiBlasInt *  pivot, double *  p_work, KaldiBlasInt *  l_work, KaldiBlasInt *  result  )

inline

Definition at line 409 of file cblas-wrappers.h.

                                                                       {
  dgetri_(num_rows, Mdata, stride, pivot, p_work, l_work, result);
}

clapack_Xsptrf() [1/2]

void kaldi::clapack_Xsptrf ( KaldiBlasInt *  num_rows, float *  Mdata, KaldiBlasInt *  ipiv, KaldiBlasInt *  result  )

inline

Definition at line 445 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::Invert().

                                                                     {
  ssptrf_(const_cast<char *>("U"), num_rows, Mdata, ipiv, result);
}

clapack_Xsptrf() [2/2]

void kaldi::clapack_Xsptrf ( KaldiBlasInt *  num_rows, double *  Mdata, KaldiBlasInt *  ipiv, KaldiBlasInt *  result  )

inline

Definition at line 449 of file cblas-wrappers.h.

                                                                     {
  dsptrf_(const_cast<char *>("U"), num_rows, Mdata, ipiv, result);
}

clapack_Xsptri() [1/2]

void kaldi::clapack_Xsptri ( KaldiBlasInt *  num_rows, float *  Mdata, KaldiBlasInt *  ipiv, float *  work, KaldiBlasInt *  result  )

inline

Definition at line 436 of file cblas-wrappers.h.

Referenced by SpMatrix< float >::Invert().

                                                                                  {
  ssptri_(const_cast<char *>("U"), num_rows, Mdata, ipiv, work, result);
}

clapack_Xsptri() [2/2]

void kaldi::clapack_Xsptri ( KaldiBlasInt *  num_rows, double *  Mdata, KaldiBlasInt *  ipiv, double *  work, KaldiBlasInt *  result  )

inline

Definition at line 440 of file cblas-wrappers.h.

                                                                                   {
  dsptri_(const_cast<char *>("U"), num_rows, Mdata, ipiv, work, result);
}

clapack_Xtptri() [1/2]

void kaldi::clapack_Xtptri ( KaldiBlasInt *  num_rows, float *  Mdata, KaldiBlasInt *  result  )

inline

Definition at line 385 of file cblas-wrappers.h.

Referenced by TpMatrix< float >::Invert().

                                                                                       {
  stptri_(const_cast<char *>("U"), const_cast<char *>("N"), num_rows, Mdata, result);
}

clapack_Xtptri() [2/2]

void kaldi::clapack_Xtptri ( KaldiBlasInt *  num_rows, double *  Mdata, KaldiBlasInt *  result  )

inline

Definition at line 388 of file cblas-wrappers.h.

                                                                                        {
  dtptri_(const_cast<char *>("U"), const_cast<char *>("N"), num_rows, Mdata, result);
}

ClusterEventMapRestrictedHelper()

static int32 kaldi::ClusterEventMapRestrictedHelper ( const EventMap &  e_in, const BuildTreeStatsType &  stats, BaseFloat  thresh, std::vector< EventKeyType >  keys, std::vector< EventMap *> *  leaf_mapping  )

static

Definition at line 803 of file build-tree-utils.cc.

References ClusterEventMapGetMapping(), rnnlm::i, and SplitStatsByKey().

Referenced by ClusterEventMapRestrictedByKeys().

                                                                                 {
  if (keys.size() == 0) {
    return ClusterEventMapGetMapping(e_in, stats, thresh, leaf_mapping);
  } else {  // split on the key.
    int32 ans = 0;
    std::vector<BuildTreeStatsType> split_stats;
    SplitStatsByKey(stats, keys.back(), &split_stats);
    keys.pop_back();
    for (size_t i = 0; i< split_stats.size(); i++)
      if (split_stats[i].size() != 0)
        ans += ClusterEventMapRestrictedHelper(e_in, split_stats[i], thresh, keys, leaf_mapping);
    return ans;
  }
}

ClusterKMeansOnce()

BaseFloat kaldi::ClusterKMeansOnce	(	const std::vector< Clusterable *> &	points,
		int32	num_clust,
		std::vector< Clusterable *> *	clusters_out,
		std::vector< int32 > *	assignments_out,
		ClusterKMeansOptions &	cfg
	)

ClusterKMeansOnce is called internally by ClusterKMeans; it is equivalent to calling ClusterKMeans with cfg.num_tries == 1.

It returns the objective function improvement versus everything being in one cluster.

Definition at line 918 of file cluster-utils.cc.

References count, Gcd(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, KALDI_WARN, ClusterKMeansOptions::num_iters, Clusterable::Objf(), Rand(), ClusterKMeansOptions::refine_cfg, RefineClusters(), SumClusterable(), SumClusterableNormalizer(), SumClusterableObjf(), and ClusterKMeansOptions::verbose.

Referenced by ClusterKMeans().

                                                       {
  std::vector<int32> my_assignments;
  int32 num_points = points.size();
  KALDI_ASSERT(clusters_out != NULL);
  KALDI_ASSERT(num_points != 0);
  KALDI_ASSERT(num_clust <= num_points);

  KALDI_ASSERT(clusters_out->empty());  // or we wouldn't know what to do with pointers in there.
  clusters_out->resize(num_clust, (Clusterable*)NULL);
  assignments_out->resize(num_points);

  {  // This block assigns points to clusters.
    // This is done pseudo-randomly using Rand() so that
    // if we call ClusterKMeans multiple times we get different answers (so we can choose
    // the best if we want).
    int32 skip;  // randomly choose a "skip" that's coprime to num_points.
    if (num_points == 1) {
      skip = 1;
    } else {
      skip = 1 + (Rand() % (num_points-1));  // a number between 1 and num_points-1.
      while (Gcd(skip, num_points) != 1) {  // while skip is not coprime to num_points...
        if (skip == num_points-1) skip = 0;
        skip++;  // skip is now still betweeen 1 and num_points-1.  will cycle through
        // all of 1...num_points-1.
      }
    }
    int32 i, j, count = 0;
    for (i = 0, j = 0; count != num_points;i = (i+skip)%num_points, j = (j+1)%num_clust, count++) {
      // i cycles pseudo-randomly through all points; j skips ahead by 1 each time
      // modulo num_points.
      // assign point i to cluster j.
      if ((*clusters_out)[j] == NULL) (*clusters_out)[j] = points[i]->Copy();
      else (*clusters_out)[j]->Add(*(points[i]));
      (*assignments_out)[i] = j;
    }
  }


  BaseFloat normalizer = SumClusterableNormalizer(*clusters_out);
  BaseFloat ans;
  {  // work out initial value of "ans" (objective function improvement).
    Clusterable *all_stats = SumClusterable(*clusters_out);
    ans = SumClusterableObjf(*clusters_out) - all_stats->Objf();  // improvement just from the random
    // initialization.
    if (ans < -0.01 && ans < -0.01 * fabs(all_stats->Objf())) {  // something bad happend.
      KALDI_WARN << "ClusterKMeans: objective function after random assignment to clusters is worse than in single cluster: "<< (all_stats->Objf()) << " changed by " << ans << ".  Perhaps your stats class has the wrong properties?";
    }
    delete all_stats;
  }
  for (int32 iter = 0;iter < cfg.num_iters;iter++) {
    // Keep refining clusters by reassigning points.
    BaseFloat objf_before;
    if (cfg.verbose) objf_before =SumClusterableObjf(*clusters_out);
    BaseFloat impr = RefineClusters(points, clusters_out, assignments_out, cfg.refine_cfg);
    BaseFloat objf_after;
    if (cfg.verbose) objf_after = SumClusterableObjf(*clusters_out);
    ans += impr;
    if (cfg.verbose)
      KALDI_LOG << "ClusterKMeans: on iteration "<<(iter)<<", objf before = "<<(objf_before)<<", impr = "<<(impr)<<", objf after = "<<(objf_after)<<", normalized by "<<(normalizer)<<" = "<<(objf_after/normalizer);
    if (impr == 0) break;
  }
  return ans;
}

ClusterLattice()

bool ClusterLattice	(	CompactLattice *	clat,
		const std::vector< int32 > &	state_times
	)

Definition at line 40 of file kws-functions.cc.

References CompareInterval(), rnnlm::i, and Interval::Overlap().

Referenced by main().

                                                         {
  using namespace fst;
  typedef CompactLattice::StateId StateId;

  // Hashmap to store the cluster heads.
  unordered_map<StateId, std::vector<Interval> > head;

  // Step 1: Iterate over the lattice to get the arcs
  StateId max_id = 0;
  for (StateIterator<CompactLattice> siter(*clat); !siter.Done();
                                                    siter.Next()) {
    StateId state_id = siter.Value();
    for (ArcIterator<CompactLattice> aiter(*clat, state_id); !aiter.Done();
                                                             aiter.Next()) {
      CompactLatticeArc arc = aiter.Value();
      if (state_id >= state_times.size() || arc.nextstate >= state_times.size())
        return false;
      if (state_id > max_id)
        max_id = state_id;
      if (arc.nextstate > max_id)
        max_id = arc.nextstate;
      head[arc.ilabel].push_back(Interval(state_times[state_id],
                                          state_times[arc.nextstate]));
    }
  }
  // Check if alignments and the states match
  if (state_times.size() != max_id+1)
    return false;

  // Step 2: Iterates over the hashmap to get the cluster heads.
  //   We sort all the words on their start-time, and the process for getting
  //   the cluster heads is to take the first one as a cluster head; then go
  //   till we find the next one that doesn't overlap in time with the current
  //   cluster head, and so on.
  unordered_map<StateId, std::vector<Interval> >::iterator iter;
  for (iter = head.begin(); iter != head.end(); ++iter) {
    // For this ilabel, sort all the arcs on time, from first to last.
    sort(iter->second.begin(), iter->second.end(), CompareInterval);
    std::vector<Interval> tmp;
    tmp.push_back(iter->second[0]);
    for (int32 i = 1; i < iter->second.size(); i++) {
      if (tmp.back().End() <= iter->second[i].Start())
        tmp.push_back(iter->second[i]);
    }
    iter->second = tmp;
  }

  // Step 3: Cluster arcs according to the maximum overlap: attach
  //   each arc to the cluster-head (as identified in Step 2) which
  //   has the most temporal overlap with the current arc.
  for (StateIterator<CompactLattice> siter(*clat); !siter.Done();
                                                   siter.Next()) {
    CompactLatticeArc::StateId state_id = siter.Value();
    for (MutableArcIterator<CompactLattice> aiter(clat, state_id);
                                            !aiter.Done(); aiter.Next()) {
      CompactLatticeArc arc = aiter.Value();
      // We don't cluster the epsilon arcs
      if (arc.ilabel == 0)
        continue;
      // We cluster the non-epsilon arcs
      Interval interval(state_times[state_id], state_times[arc.nextstate]);
      int32 max_overlap = 0;
      size_t olabel = 1;
      for (int32 i = 0; i < head[arc.ilabel].size(); i++) {
        int32 overlap = interval.Overlap(head[arc.ilabel][i]);
        if (overlap > max_overlap) {
          max_overlap = overlap;
          olabel = i + 1;  // need non-epsilon label.
        }
      }
      arc.olabel = olabel;
      aiter.SetValue(arc);
    }
  }

  return true;
}

CompactLatticeDepth()

BaseFloat CompactLatticeDepth	(	const CompactLattice &	clat,
		int32 *	num_frames
	)

Returns the depth of the lattice, defined as the average number of arcs crossing any given frame.

Returns the depth of the lattice, defined as the average number of arcs (or final-prob strings) crossing any given frame.

Returns 1 for empty lattices. Requires that input is topologically sorted.

Returns 1 for empty lattices. Requires that clat is topologically sorted!

Definition at line 628 of file lattice-functions.cc.

References CompactLatticeStateTimes(), and KALDI_ERR.

Referenced by main().

                                                 {
  typedef CompactLattice::Arc::StateId StateId;
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    KALDI_ERR << "Lattice input to CompactLatticeDepth was not topologically "
              << "sorted.";
  }
  if (clat.Start() == fst::kNoStateId) {
    *num_frames = 0;
    return 1.0;
  }
  size_t num_arc_frames = 0;
  int32 t;
  {
    vector<int32> state_times;
    t = CompactLatticeStateTimes(clat, &state_times);
  }
  if (num_frames != NULL)
    *num_frames = t;
  for (StateId s = 0; s < clat.NumStates(); s++) {
    for (fst::ArcIterator<CompactLattice> aiter(clat, s); !aiter.Done();
         aiter.Next()) {
      const CompactLatticeArc &arc = aiter.Value();
      num_arc_frames += arc.weight.String().size();
    }
    num_arc_frames += clat.Final(s).String().size();
  }
  return num_arc_frames / static_cast<BaseFloat>(t);
}

CompactLatticeDepthPerFrame()

void CompactLatticeDepthPerFrame	(	const CompactLattice &	clat,
		std::vector< int32 > *	depth_per_frame
	)

This function returns, for each frame, the number of arcs crossing that frame.

Definition at line 659 of file lattice-functions.cc.

References CompactLatticeStateTimes(), KALDI_ASSERT, and KALDI_ERR.

Referenced by main().

                                                                    {
  typedef CompactLattice::Arc::StateId StateId;
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    KALDI_ERR << "Lattice input to CompactLatticeDepthPerFrame was not "
              << "topologically sorted.";
  }
  if (clat.Start() == fst::kNoStateId) {
    depth_per_frame->clear();
    return;
  }
  vector<int32> state_times;
  int32 T = CompactLatticeStateTimes(clat, &state_times);

  depth_per_frame->clear();
  if (T <= 0) {
    return;
  } else {
    depth_per_frame->resize(T, 0);
    for (StateId s = 0; s < clat.NumStates(); s++) {
      int32 start_time = state_times[s];
      for (fst::ArcIterator<CompactLattice> aiter(clat, s); !aiter.Done();
           aiter.Next()) {
        const CompactLatticeArc &arc = aiter.Value();
        int32 len = arc.weight.String().size();
        for (int32 t = start_time; t < start_time + len; t++) {
          KALDI_ASSERT(t < T);
          (*depth_per_frame)[t]++;
        }
      }
      int32 final_len = clat.Final(s).String().size();
      for (int32 t = start_time; t < start_time + final_len; t++) {
        KALDI_ASSERT(t < T);
        (*depth_per_frame)[t]++;
      }
    }
  }
}

CompactLatticeLimitDepth()

void CompactLatticeLimitDepth	(	int32	max_arcs_per_frame,
		CompactLattice *	clat
	)

This function limits the depth of the lattice, per frame: that means, it does not allow more than a specified number of arcs active on any given frame.

This can be used to reduce the size of the "very deep" portions of the lattice.

Definition at line 532 of file lattice-functions.cc.

References LatticeArcRecord::arc, CompactLatticeStateTimes(), ComputeLatticeAlphasAndBetas(), fst::ConvertToCost(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, LatticeArcRecord::logprob, LatticeArcRecord::state, and TopSortCompactLatticeIfNeeded().

Referenced by main().

                                                    {
  typedef CompactLatticeArc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  if (clat->Start() == fst::kNoStateId) {
    KALDI_WARN << "Limiting depth of empty lattice.";
    return;
  }
  if (clat->Properties(fst::kTopSorted, true) == 0) {
    if (!TopSort(clat))
      KALDI_ERR << "Topological sorting of lattice failed.";
  }

  vector<int32> state_times;
  int32 T = CompactLatticeStateTimes(*clat, &state_times);

  // The alpha and beta quantities here are "viterbi" alphas and beta.
  std::vector<double> alpha;
  std::vector<double> beta;
  bool viterbi = true;
  double best_prob = ComputeLatticeAlphasAndBetas(*clat, viterbi,
                                                  &alpha, &beta);

  std::vector<std::vector<LatticeArcRecord> > arc_records(T);

  StateId num_states = clat->NumStates();
  for (StateId s = 0; s < num_states; s++) {
    for (fst::ArcIterator<CompactLattice> aiter(*clat, s); !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      LatticeArcRecord arc_record;
      arc_record.state = s;
      arc_record.arc = aiter.Position();
      arc_record.logprob =
          (alpha[s] + beta[arc.nextstate] - ConvertToCost(arc.weight))
           - best_prob;
      KALDI_ASSERT(arc_record.logprob < 0.1); // Should be zero or negative.
      int32 num_frames = arc.weight.String().size(), start_t = state_times[s];
      for (int32 t = start_t; t < start_t + num_frames; t++) {
        KALDI_ASSERT(t < T);
        arc_records[t].push_back(arc_record);
      }
    }
  }
  StateId dead_state = clat->AddState(); // A non-coaccesible state which we use
                                         // to remove arcs (make them end
                                         // there).
  size_t max_depth = max_depth_per_frame;
  for (int32 t = 0; t < T; t++) {
    size_t size = arc_records[t].size();
    if (size > max_depth) {
      // we sort from worst to best, so we keep the later-numbered ones,
      // and delete the lower-numbered ones.
      size_t cutoff = size - max_depth;
      std::nth_element(arc_records[t].begin(),
                       arc_records[t].begin() + cutoff,
                       arc_records[t].end());
      for (size_t index = 0; index < cutoff; index++) {
        LatticeArcRecord record(arc_records[t][index]);
        fst::MutableArcIterator<CompactLattice> aiter(clat, record.state);
        aiter.Seek(record.arc);
        Arc arc = aiter.Value();
        if (arc.nextstate != dead_state) { // not already killed.
          arc.nextstate = dead_state;
          aiter.SetValue(arc);
        }
      }
    }
  }
  Connect(clat);
  TopSortCompactLatticeIfNeeded(clat);
}

CompactLatticeNormalize()

bool kaldi::CompactLatticeNormalize	(	CompactLattice *	clat,
		BaseFloat	weight
	)

Definition at line 54 of file lattice-combine.cc.

References ComputeCompactLatticeBetas(), KALDI_WARN, Log(), LatticeWeightTpl< FloatType >::SetValue1(), CompactLatticeWeightTpl< WeightType, IntType >::SetWeight(), LatticeWeightTpl< FloatType >::Value1(), and CompactLatticeWeightTpl< WeightType, IntType >::Weight().

Referenced by main().

                                                                     {
  if (weight <= 0.0) {
    KALDI_WARN << "Weights must be positive; found: " << weight;
    return false;
  }

  if (clat->Properties(fst::kTopSorted, false) == 0) {
    if (fst::TopSort(clat) == false) {
      KALDI_WARN << "Cycles detected in lattice: cannot normalize.";
      return false;
    }
  }

  vector<double> beta;
  if (!ComputeCompactLatticeBetas(*clat, &beta)) {
    KALDI_WARN << "Failed to compute backward probabilities on lattice.";
    return false;
  }

  typedef CompactLattice::Arc::StateId StateId;
  StateId start = clat->Start();  // Should be 0
  BaseFloat total_backward_cost = beta[start];

  total_backward_cost -= Log(weight);

  for (fst::StateIterator<CompactLattice> sit(*clat); !sit.Done(); sit.Next()) {
    CompactLatticeWeight f = clat->Final(sit.Value());
    LatticeWeight w = f.Weight();
    w.SetValue1(w.Value1() + total_backward_cost);
    f.SetWeight(w);
    clat->SetFinal(sit.Value(), f);
  }
  return true;
}

CompactLatticeShortestPath()

void CompactLatticeShortestPath	(	const CompactLattice &	clat,
		CompactLattice *	shortest_path
	)

A form of the shortest-path/best-path algorithm that's specially coded for CompactLattice.

Requires that clat be acyclic.

Definition at line 1097 of file lattice-functions.cc.

References fst::ConvertToCost(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, and KALDI_WARN.

Referenced by DecodeUtteranceLatticeIncremental(), GetDiagnosticsAndPrintOutput(), LatticeToString(), and main().

                                                               {
  using namespace fst;
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    CompactLattice clat_copy(clat);
    if (!TopSort(&clat_copy))
      KALDI_ERR << "Was not able to topologically sort lattice (cycles found?)";
    CompactLatticeShortestPath(clat_copy, shortest_path);
    return;
  }
  // Now we can assume it's topologically sorted.
  shortest_path->DeleteStates();
  if (clat.Start() == kNoStateId) return;
  typedef CompactLatticeArc Arc;
  typedef Arc::StateId StateId;
  typedef CompactLatticeWeight Weight;
  vector<std::pair<double, StateId> > best_cost_and_pred(clat.NumStates() + 1);
  StateId superfinal = clat.NumStates();
  for (StateId s = 0; s <= clat.NumStates(); s++) {
    best_cost_and_pred[s].first = std::numeric_limits<double>::infinity();
    best_cost_and_pred[s].second = fst::kNoStateId;
  }
  best_cost_and_pred[clat.Start()].first = 0;
  for (StateId s = 0; s < clat.NumStates(); s++) {
    double my_cost = best_cost_and_pred[s].first;
    for (ArcIterator<CompactLattice> aiter(clat, s);
         !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_cost = ConvertToCost(arc.weight),
          next_cost = my_cost + arc_cost;
      if (next_cost < best_cost_and_pred[arc.nextstate].first) {
        best_cost_and_pred[arc.nextstate].first = next_cost;
        best_cost_and_pred[arc.nextstate].second = s;
      }
    }
    double final_cost = ConvertToCost(clat.Final(s)),
        tot_final = my_cost + final_cost;
    if (tot_final < best_cost_and_pred[superfinal].first) {
      best_cost_and_pred[superfinal].first = tot_final;
      best_cost_and_pred[superfinal].second = s;
    }
  }
  std::vector<StateId> states; // states on best path.
  StateId cur_state = superfinal, start_state = clat.Start();
  while (cur_state != start_state) {
    StateId prev_state = best_cost_and_pred[cur_state].second;
    if (prev_state == kNoStateId) {
      KALDI_WARN << "Failure in best-path algorithm for lattice (infinite costs?)";
      return; // return empty best-path.
    }
    states.push_back(prev_state);
    KALDI_ASSERT(cur_state != prev_state && "Lattice with cycles");
    cur_state = prev_state;
  }
  std::reverse(states.begin(), states.end());
  for (size_t i = 0; i < states.size(); i++)
    shortest_path->AddState();
  for (StateId s = 0; static_cast<size_t>(s) < states.size(); s++) {
    if (s == 0) shortest_path->SetStart(s);
    if (static_cast<size_t>(s + 1) < states.size()) { // transition to next state.
      bool have_arc = false;
      Arc cur_arc;
      for (ArcIterator<CompactLattice> aiter(clat, states[s]);
           !aiter.Done();
           aiter.Next()) {
        const Arc &arc = aiter.Value();
        if (arc.nextstate == states[s+1]) {
          if (!have_arc ||
              ConvertToCost(arc.weight) < ConvertToCost(cur_arc.weight)) {
            cur_arc = arc;
            have_arc = true;
          }
        }
      }
      KALDI_ASSERT(have_arc && "Code error.");
      shortest_path->AddArc(s, Arc(cur_arc.ilabel, cur_arc.olabel,
                                   cur_arc.weight, s+1));
    } else { // final-prob.
      shortest_path->SetFinal(s, clat.Final(states[s]));
    }
  }
}

CompactLatticeStateTimes() [1/2]

int32 kaldi::CompactLatticeStateTimes	(	const CompactLattice &	clat,
		std::vector< int32 > *	times
	)

As LatticeStateTimes, but in the CompactLattice format.

Note: must be topologically sorted. Returns length of the utterance in frames, which might not be the same as the maximum time in the lattice, due to frames in the final-prob.

Definition at line 111 of file lattice-functions.cc.

References KALDI_ASSERT, KALDI_ERR, KALDI_WARN, and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by DiscriminativeNnetExample::Check(), CompactLatticeDepth(), CompactLatticeDepthPerFrame(), CompactLatticeLimitDepth(), kaldi::nnet2::LatticeToDiscriminativeExample(), main(), ArcPosteriorComputer::OutputPosteriors(), MinimumBayesRisk::PrepareLatticeAndInitStats(), and RescoreCompactLatticeInternal().

                                                                                {
  if (!lat.Properties(fst::kTopSorted, true))
    KALDI_ERR << "Input lattice must be topologically sorted.";
  KALDI_ASSERT(lat.Start() == 0);
  int32 num_states = lat.NumStates();
  times->clear();
  times->resize(num_states, -1);
  (*times)[0] = 0;
  int32 utt_len = -1;
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = (*times)[state];
    for (fst::ArcIterator<CompactLattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      const CompactLatticeArc &arc = aiter.Value();
      int32 arc_len = static_cast<int32>(arc.weight.String().size());
      if ((*times)[arc.nextstate] == -1)
        (*times)[arc.nextstate] = cur_time + arc_len;
      else
        KALDI_ASSERT((*times)[arc.nextstate] == cur_time + arc_len);
    }
    if (lat.Final(state) != CompactLatticeWeight::Zero()) {
      int32 this_utt_len = (*times)[state] + lat.Final(state).String().size();
      if (utt_len == -1) utt_len = this_utt_len;
      else {
        if (this_utt_len != utt_len) {
          KALDI_WARN << "Utterance does not "
              "seem to have a consistent length.";
          utt_len = std::max(utt_len, this_utt_len);
        }
      }
    }
  }
  if (utt_len == -1) {
    KALDI_WARN << "Utterance does not have a final-state.";
    return 0;
  }
  return utt_len;
}

CompactLatticeStateTimes() [2/2]

int32 kaldi::CompactLatticeStateTimes	(	const CompactLattice &	clat,
		std::vector< int32 > *	times
	)

As LatticeStateTimes, but in the CompactLattice format.

Note: must be topologically sorted. Returns length of the utterance in frames, which might not be the same as the maximum time in the lattice, due to frames in the final-prob.

Definition at line 111 of file lattice-functions.cc.

References KALDI_ASSERT, KALDI_ERR, KALDI_WARN, and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by DiscriminativeNnetExample::Check(), CompactLatticeDepth(), CompactLatticeDepthPerFrame(), CompactLatticeLimitDepth(), kaldi::nnet2::LatticeToDiscriminativeExample(), main(), ArcPosteriorComputer::OutputPosteriors(), MinimumBayesRisk::PrepareLatticeAndInitStats(), and RescoreCompactLatticeInternal().

                                                                                {
  if (!lat.Properties(fst::kTopSorted, true))
    KALDI_ERR << "Input lattice must be topologically sorted.";
  KALDI_ASSERT(lat.Start() == 0);
  int32 num_states = lat.NumStates();
  times->clear();
  times->resize(num_states, -1);
  (*times)[0] = 0;
  int32 utt_len = -1;
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = (*times)[state];
    for (fst::ArcIterator<CompactLattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      const CompactLatticeArc &arc = aiter.Value();
      int32 arc_len = static_cast<int32>(arc.weight.String().size());
      if ((*times)[arc.nextstate] == -1)
        (*times)[arc.nextstate] = cur_time + arc_len;
      else
        KALDI_ASSERT((*times)[arc.nextstate] == cur_time + arc_len);
    }
    if (lat.Final(state) != CompactLatticeWeight::Zero()) {
      int32 this_utt_len = (*times)[state] + lat.Final(state).String().size();
      if (utt_len == -1) utt_len = this_utt_len;
      else {
        if (this_utt_len != utt_len) {
          KALDI_WARN << "Utterance does not "
              "seem to have a consistent length.";
          utt_len = std::max(utt_len, this_utt_len);
        }
      }
    }
  }
  if (utt_len == -1) {
    KALDI_WARN << "Utterance does not have a final-state.";
    return 0;
  }
  return utt_len;
}

CompactLatticeToWordAlignment()

bool CompactLatticeToWordAlignment	(	const CompactLattice &	clat,
		std::vector< int32 > *	words,
		std::vector< int32 > *	begin_times,
		std::vector< int32 > *	lengths
	)

This function takes a CompactLattice that should only contain a single linear sequence (e.g.

derived from lattice-1best), and that should have been processed so that the arcs in the CompactLattice align correctly with the word boundaries (e.g. by lattice-align-words). It outputs 3 vectors of the same size, which give, for each word in the lattice (in sequence), the word label and the begin time and length in frames. This is done even for zero (epsilon) words, generally corresponding to optional silence– if you don't want them, just ignore them in the output. This function will print a warning and return false, if the lattice did not have the correct format (e.g. if it is empty or it is not linear).

Definition at line 975 of file lattice-functions.cc.

References KALDI_WARN.

Referenced by main().

                                                              {
  words->clear();
  begin_times->clear();
  lengths->clear();
  typedef CompactLattice::Arc Arc;
  typedef Arc::Label Label;
  typedef CompactLattice::StateId StateId;
  typedef CompactLattice::Weight Weight;
  using namespace fst;
  StateId state = clat.Start();
  int32 cur_time = 0;
  if (state == kNoStateId) {
    KALDI_WARN << "Empty lattice.";
    return false;
  }
  while (1) {
    Weight final = clat.Final(state);
    size_t num_arcs = clat.NumArcs(state);
    if (final != Weight::Zero()) {
      if (num_arcs != 0) {
        KALDI_WARN << "Lattice is not linear.";
        return false;
      }
      if (! final.String().empty()) {
        KALDI_WARN << "Lattice has alignments on final-weight: probably "
            "was not word-aligned (alignments will be approximate)";
      }
      return true;
    } else {
      if (num_arcs != 1) {
        KALDI_WARN << "Lattice is not linear: num-arcs = " << num_arcs;
        return false;
      }
      fst::ArcIterator<CompactLattice> aiter(clat, state);
      const Arc &arc = aiter.Value();
      Label word_id = arc.ilabel; // Note: ilabel==olabel, since acceptor.
      // Also note: word_id may be zero; we output it anyway.
      int32 length = arc.weight.String().size();
      words->push_back(word_id);
      begin_times->push_back(cur_time);
      lengths->push_back(length);
      cur_time += length;
      state = arc.nextstate;
    }
  }
}

CompactLatticeToWordProns()

bool CompactLatticeToWordProns	(	const TransitionModel &	tmodel,
		const CompactLattice &	clat,
		std::vector< int32 > *	words,
		std::vector< int32 > *	begin_times,
		std::vector< int32 > *	lengths,
		std::vector< std::vector< int32 > > *	prons,
		std::vector< std::vector< int32 > > *	phone_lengths
	)

This function takes a CompactLattice that should only contain a single linear sequence (e.g.

derived from lattice-1best), and that should have been processed so that the arcs in the CompactLattice align correctly with the word boundaries (e.g. by lattice-align-words). It outputs 4 vectors of the same size, which give, for each word in the lattice (in sequence), the word label, the begin time and length in frames, and the pronunciation (sequence of phones). This is done even for zero words, corresponding to optional silences – if you don't want them, just ignore them in the output. This function will print a warning and return false, if the lattice did not have the correct format (e.g. if it is empty or it is not linear).

Definition at line 1026 of file lattice-functions.cc.

References rnnlm::i, KALDI_ASSERT, KALDI_WARN, SplitToPhones(), and TransitionModel::TransitionIdToPhone().

Referenced by main().

                                                 {
  words->clear();
  begin_times->clear();
  lengths->clear();
  prons->clear();
  phone_lengths->clear();
  typedef CompactLattice::Arc Arc;
  typedef Arc::Label Label;
  typedef CompactLattice::StateId StateId;
  typedef CompactLattice::Weight Weight;
  using namespace fst;
  StateId state = clat.Start();
  int32 cur_time = 0;
  if (state == kNoStateId) {
    KALDI_WARN << "Empty lattice.";
    return false;
  }
  while (1) {
    Weight final = clat.Final(state);
    size_t num_arcs = clat.NumArcs(state);
    if (final != Weight::Zero()) {
      if (num_arcs != 0) {
        KALDI_WARN << "Lattice is not linear.";
        return false;
      }
      if (! final.String().empty()) {
        KALDI_WARN << "Lattice has alignments on final-weight: probably "
            "was not word-aligned (alignments will be approximate)";
      }
      return true;
    } else {
      if (num_arcs != 1) {
        KALDI_WARN << "Lattice is not linear: num-arcs = " << num_arcs;
        return false;
      }
      fst::ArcIterator<CompactLattice> aiter(clat, state);
      const Arc &arc = aiter.Value();
      Label word_id = arc.ilabel; // Note: ilabel==olabel, since acceptor.
      // Also note: word_id may be zero; we output it anyway.
      int32 length = arc.weight.String().size();
      words->push_back(word_id);
      begin_times->push_back(cur_time);
      lengths->push_back(length);
      const std::vector<int32> &arc_alignment = arc.weight.String();
      std::vector<std::vector<int32> > split_alignment;
      SplitToPhones(tmodel, arc_alignment, &split_alignment);
      std::vector<int32> phones(split_alignment.size());
      std::vector<int32> plengths(split_alignment.size());
      for (size_t i = 0; i < split_alignment.size(); i++) {
        KALDI_ASSERT(!split_alignment[i].empty());
        phones[i] = tmodel.TransitionIdToPhone(split_alignment[i][0]);
        plengths[i] = split_alignment[i].size();
      }
      prons->push_back(phones);
      phone_lengths->push_back(plengths);

      cur_time += length;
      state = arc.nextstate;
    }
  }
}

CompareInterval()

bool CompareInterval	(	const Interval &	i1,
		const Interval &	i2
	)

Definition at line 33 of file kws-functions.cc.

References Interval::End(), and Interval::Start().

Referenced by ClusterLattice().

                                         {
  return (i1.Start() < i2.Start() ? true :
          i1.Start() > i2.Start() ? false:
          i1.End() < i2.End() ? true: false);
}

Compile()

ArpaLmCompiler* kaldi::Compile	(	bool	seps,
		const std::string &	infile
	)

Definition at line 75 of file arpa-lm-compiler-test.cc.

References ArpaParseOptions::bos_symbol, ArpaParseOptions::eos_symbol, ArpaParseOptions::kAddToSymbols, kBos, kDisambig, kEos, kEps, ArpaParseOptions::oov_handling, ArpaFileParser::Read(), and Input::Stream().

Referenced by CoverageTest(), ScoringTest(), and ThrowsExceptionTest().

                                                            {
  ArpaParseOptions options;
  fst::SymbolTable symbols;
  // Use spaces on special symbols, so we rather fail than read them by mistake.
  symbols.AddSymbol(" <eps>", kEps);
  symbols.AddSymbol(" #0", kDisambig);
  options.bos_symbol = symbols.AddSymbol("<s>", kBos);
  options.eos_symbol = symbols.AddSymbol("</s>", kEos);
  options.oov_handling = ArpaParseOptions::kAddToSymbols;

  // Tests in this form cannot be run with epsilon substitution, unless every
  // random path is also fitted with a #0-transducing self-loop.
  ArpaLmCompiler* lm_compiler =
      new ArpaLmCompiler(options,
                         seps ? kDisambig : 0,
                         &symbols);
  {
    Input ki(infile);
    lm_compiler->Read(ki.Stream());
  }
  return lm_compiler;
}

ComplexFft() [1/2]

template void kaldi::ComplexFft	(	VectorBase< float > *	v,
		bool	forward,
		Vector< float > *	tmp_in
	)

ComplexFft() [2/2]

template void kaldi::ComplexFft	(	VectorBase< double > *	v,
		bool	forward,
		Vector< double > *	tmp_in
	)

ComplexFftRecursive()

void kaldi::ComplexFftRecursive	(	Real *	data,
		int	nffts,
		int	N,
		const int *	factor_begin,
		const int *	factor_end,
		bool	forward,
		Vector< Real > *	tmp_vec
	)

ComplexFftRecursive is a recursive function that computes the complex FFT of size N.

The "nffts" arguments specifies how many separate FFTs to compute in parallel (we assume the data for each one is consecutive in memory). The "forward argument" specifies whether to do the FFT (true) or IFFT (false), although note that we do not include the factor of 1/N (the user should do this if required. The iterators factor_begin and factor_end point to the beginning and end (i.e. one past the last element) of an array of small factors of N (typically prime factors). See the comments below this code for the detailed equations of the recursion.

Definition at line 97 of file matrix-functions.cc.

References ComplexAddProduct(), ComplexImExp(), ComplexMul(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), KALDI_ASSERT, KALDI_COMPLEXFFT_BLOCKSIZE, M_2PI, rnnlm::n, and Vector< Real >::Resize().

Referenced by ComplexFft().

                                                 {
  if (factor_begin == factor_end) {
    KALDI_ASSERT(N == 1);
    return;
  }

  {  // an optimization: compute in smaller blocks.
    // this block of code could be removed and it would still work.
    MatrixIndexT size_perblock = N * 2 * sizeof(Real);
    if (nffts > 1 && size_perblock*nffts > KALDI_COMPLEXFFT_BLOCKSIZE) {  // can break it up...
      // Break up into multiple blocks.  This is an optimization.  We make
      // no progress on the FFT when we do this.
      int block_skip = KALDI_COMPLEXFFT_BLOCKSIZE / size_perblock;  // n blocks per call
      if (block_skip == 0) block_skip = 1;
      if (block_skip < nffts) {
        int blocks_left = nffts;
        while (blocks_left > 0) {
          int skip_now = std::min(blocks_left, block_skip);
          ComplexFftRecursive(data, skip_now, N, factor_begin, factor_end, forward, tmp_vec);
          blocks_left -= skip_now;
          data += skip_now * N*2;
        }
        return;
      } // else do the actual algorithm.
    } // else do the actual algorithm.
  }

  int P = *factor_begin;
  KALDI_ASSERT(P > 1);
  int Q = N / P;


  if (P > 1 && Q > 1) {  // Do the rearrangement.   C.f. eq. (8) below.  Transform
    // (a) to (b).
    Real *data_thisblock = data;
    if (tmp_vec->Dim() < (MatrixIndexT)N) tmp_vec->Resize(N);
    Real *data_tmp = tmp_vec->Data();
    for (int thisfft = 0; thisfft < nffts; thisfft++, data_thisblock+=N*2) {
      for (int offset = 0; offset < 2; offset++) {  // 0 == real, 1 == im.
        for (int p = 0; p < P; p++) {
          for (int q = 0; q < Q; q++) {
            int aidx = q*P + p, bidx = p*Q + q;
            data_tmp[bidx] = data_thisblock[2*aidx+offset];
          }
        }
        for (int n = 0;n < P*Q;n++) data_thisblock[2*n+offset] = data_tmp[n];
      }
    }
  }

  {  // Recurse.
    ComplexFftRecursive(data, nffts*P, Q, factor_begin+1, factor_end, forward, tmp_vec);
  }

  int exp_sign = (forward ? -1 : 1);
  Real rootN_re, rootN_im;  // Nth root of unity.
  ComplexImExp(static_cast<Real>(exp_sign * M_2PI / N), &rootN_re, &rootN_im);

  Real rootP_re, rootP_im;  // Pth root of unity.
  ComplexImExp(static_cast<Real>(exp_sign * M_2PI / P), &rootP_re, &rootP_im);

  {  // Do the multiplication
    // could avoid a bunch of complex multiplies by moving the loop over data_thisblock
    // inside.
    if (tmp_vec->Dim() < (MatrixIndexT)(P*2)) tmp_vec->Resize(P*2);
    Real *temp_a = tmp_vec->Data();

    Real *data_thisblock = data, *data_end = data+(N*2*nffts);
    for (; data_thisblock != data_end; data_thisblock += N*2) {  // for each separate fft.
      Real qd_re = 1.0, qd_im = 0.0;  // 1^(q'/N)
      for (int qd = 0; qd < Q; qd++) {
        Real pdQ_qd_re = qd_re, pdQ_qd_im = qd_im;  // 1^((p'Q+q') / N) == 1^((p'/P) + (q'/N))
                                              // Initialize to q'/N, corresponding to p' == 0.
        for (int pd = 0; pd < P; pd++) {  // pd == p'
          {  // This is the p = 0 case of the loop below [an optimization].
            temp_a[pd*2] = data_thisblock[qd*2];
            temp_a[pd*2 + 1] = data_thisblock[qd*2 + 1];
          }
          {  // This is the p = 1 case of the loop below [an optimization]
            // **** MOST OF THE TIME (>60% I think) gets spent here. ***
            ComplexAddProduct(pdQ_qd_re, pdQ_qd_im,
                              data_thisblock[(qd+Q)*2], data_thisblock[(qd+Q)*2 + 1],
                              &(temp_a[pd*2]), &(temp_a[pd*2 + 1]));
          }
          if (P > 2) {
            Real p_pdQ_qd_re = pdQ_qd_re, p_pdQ_qd_im = pdQ_qd_im;  // 1^(p(p'Q+q')/N)
            for (int p = 2; p < P; p++) {
              ComplexMul(pdQ_qd_re, pdQ_qd_im, &p_pdQ_qd_re, &p_pdQ_qd_im);  // p_pdQ_qd *= pdQ_qd.
              int data_idx = p*Q + qd;
              ComplexAddProduct(p_pdQ_qd_re, p_pdQ_qd_im,
                                data_thisblock[data_idx*2], data_thisblock[data_idx*2 + 1],
                                &(temp_a[pd*2]), &(temp_a[pd*2 + 1]));
            }
          }
          if (pd != P-1)
            ComplexMul(rootP_re, rootP_im, &pdQ_qd_re, &pdQ_qd_im);  // pdQ_qd *= (rootP == 1^{1/P})
          // (using 1/P == Q/N)
        }
        for (int pd = 0; pd < P; pd++) {
          data_thisblock[(pd*Q + qd)*2] = temp_a[pd*2];
          data_thisblock[(pd*Q + qd)*2 + 1] = temp_a[pd*2 + 1];
        }
        ComplexMul(rootN_re, rootN_im, &qd_re, &qd_im);  // qd *= rootN.
      }
    }
  }
}

ComplexFt() [1/2]

template void kaldi::ComplexFt	(	const VectorBase< float > &	in,
		VectorBase< float > *	out,
		bool	forward
	)

ComplexFt() [2/2]

template void kaldi::ComplexFt	(	const VectorBase< double > &	in,
		VectorBase< double > *	out,
		bool	forward
	)

ComposeCompactLatticeDeterministic()

void ComposeCompactLatticeDeterministic	(	const CompactLattice &	clat,
		fst::DeterministicOnDemandFst< fst::StdArc > *	det_fst,
		CompactLattice *	composed_clat
	)

This function Composes a CompactLattice format lattice with a DeterministicOnDemandFst<fst::StdFst> format fst, and outputs another CompactLattice format lattice.

The first element (the one that corresponds to LM weight) in CompactLatticeWeight is used for composition.

Note that the DeterministicOnDemandFst interface is not "const", therefore we cannot use "const" for <det_fst>.

Definition at line 1528 of file lattice-functions.cc.

References DeterministicOnDemandFst< Arc >::Final(), DeterministicOnDemandFst< Arc >::GetArc(), KALDI_ASSERT, and DeterministicOnDemandFst< Arc >::Start().

Referenced by main().

                                   {
  // StdFst::Arc and CompactLatticeArc has the same StateId type.
  typedef fst::StdArc::StateId StateId;
  typedef fst::StdArc::Weight Weight1;
  typedef CompactLatticeArc::Weight Weight2;
  typedef std::pair<StateId, StateId> StatePair;
  typedef unordered_map<StatePair, StateId, PairHasher<StateId> > MapType;
  typedef MapType::iterator IterType;

  // Empties the output FST.
  KALDI_ASSERT(composed_clat != NULL);
  composed_clat->DeleteStates();

  MapType state_map;
  std::queue<StatePair> state_queue;

  // Sets start state in <composed_clat>.
  StateId start_state = composed_clat->AddState();
  StatePair start_pair(clat.Start(), det_fst->Start());
  composed_clat->SetStart(start_state);
  state_queue.push(start_pair);
  std::pair<IterType, bool> result =
      state_map.insert(std::make_pair(start_pair, start_state));
  KALDI_ASSERT(result.second == true);

  // Starts composition here.
  while (!state_queue.empty()) {
    // Gets the first state in the queue.
    StatePair s = state_queue.front();
    StateId s1 = s.first;
    StateId s2 = s.second;
    state_queue.pop();


    Weight2 clat_final = clat.Final(s1);
    if (clat_final.Weight().Value1() !=
        std::numeric_limits<BaseFloat>::infinity()) {
      // Test for whether the final-prob of state s1 was zero.
      Weight1 det_fst_final = det_fst->Final(s2);
      if (det_fst_final.Value() !=
          std::numeric_limits<BaseFloat>::infinity()) {
        // Test for whether the final-prob of state s2 was zero.  If neither
        // source-state final prob was zero, then we should create final state
        // in fst_composed. We compute the product manually since this is more
        // efficient.
        Weight2 final_weight(LatticeWeight(clat_final.Weight().Value1() +
                                           det_fst_final.Value(),
                                           clat_final.Weight().Value2()),
                             clat_final.String());
        // we can assume final_weight is not Zero(), since neither of
        // the sources was zero.
        KALDI_ASSERT(state_map.find(s) != state_map.end());
        composed_clat->SetFinal(state_map[s], final_weight);
      }
    }

    // Loops over pair of edges at s1 and s2.
    for (fst::ArcIterator<CompactLattice> aiter(clat, s1);
         !aiter.Done(); aiter.Next()) {
      const CompactLatticeArc& arc1 = aiter.Value();
      fst::StdArc arc2;
      StateId next_state1 = arc1.nextstate, next_state2;
      bool matched = false;

      if (arc1.olabel == 0) {
        // If the symbol on <arc1> is <epsilon>, we transit to the next state
        // for <clat>, but keep <det_fst> at the current state.
        matched = true;
        next_state2 = s2;
      } else {
        // Otherwise try to find the matched arc in <det_fst>.
        matched = det_fst->GetArc(s2, arc1.olabel, &arc2);
        if (matched) {
          next_state2 = arc2.nextstate;
        }
      }

      // If matched arc is found in <det_fst>, then we have to add new arcs to
      // <composed_clat>.
      if (matched) {
        StatePair next_state_pair(next_state1, next_state2);
        IterType siter = state_map.find(next_state_pair);
        StateId next_state;

        // Adds composed state to <state_map>.
        if (siter == state_map.end()) {
          // If the composed state has not been created yet, create it.
          next_state = composed_clat->AddState();
          std::pair<const StatePair, StateId> next_state_map(next_state_pair,
                                                             next_state);
          std::pair<IterType, bool> result = state_map.insert(next_state_map);
          KALDI_ASSERT(result.second);
          state_queue.push(next_state_pair);
        } else {
          // If the composed state is already in <state_map>, we can directly
          // use that.
          next_state = siter->second;
        }

        // Adds arc to <composed_clat>.
        if (arc1.olabel == 0) {
          composed_clat->AddArc(state_map[s],
                                CompactLatticeArc(arc1.ilabel, 0,
                                                  arc1.weight, next_state));
        } else {
          Weight2 composed_weight(
              LatticeWeight(arc1.weight.Weight().Value1() +
                            arc2.weight.Value(),
                            arc1.weight.Weight().Value2()),
              arc1.weight.String());
          composed_clat->AddArc(state_map[s],
                                CompactLatticeArc(arc1.ilabel, arc2.olabel,
                                                  composed_weight, next_state));
        }
      }
    }
  }
  fst::Connect(composed_clat);
}

ComposeCompactLatticePruned()

void ComposeCompactLatticePruned	(	const ComposeLatticePrunedOptions &	opts,
		const CompactLattice &	clat,
		fst::DeterministicOnDemandFst< fst::StdArc > *	det_fst,
		CompactLattice *	composed_clat
	)

Does pruned composition of a lattice 'clat' with a DeterministicOnDemandFst 'det_fst'; implements LM rescoring.

Parameters

[in]	opts	Class containing options
[in]	clat	The input lattice, which is expected to already have a reasonable acoustic scale applied (e.g. 0.1 if it's a normal cross-entropy system, but 1.0 for a chain system); this scale affects the pruning.
[in]	det_fst	The on-demand FST that we are composing with; its ilabels will correspond to words and it should be an acceptor in practice (ilabel == olabel). Will often contain a weighted difference of language model scores, with scores of the form alpha * new - alpha * old, where alpha is the interpolation weight for the 'new' language model (e.g. 0.5 or 0.8). It's non-const because 'det_fst' is on-demand.
[out]	composed_clat	The output, which is a result of composing 'clat' with '*det_fst'. Notionally, '*det_fst' is on the right, although both are acceptors so it doesn't really matter in practice. Although the two FSTs are of different types, the code manually does the conversion. The weights in '*det_fst' will be interpreted as graph weights (Value1()) in the lattice semiring.

Definition at line 946 of file compose-lattice-pruned.cc.

References PrunedCompactLatticeComposer::Compose().

Referenced by main(), and ComposeLatticePrunedOptions::Register().

                                   {
  PrunedCompactLatticeComposer composer(opts, clat, det_fst, composed_clat);
  composer.Compose();
}

ComposeTransforms()

bool ComposeTransforms	(	const Matrix< BaseFloat > &	a,
		const Matrix< BaseFloat > &	b,
		bool	b_is_affine,
		Matrix< BaseFloat > *	c
	)

Definition at line 132 of file transform-common.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::CopyFromMat(), KALDI_ERR, KALDI_WARN, kNoTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by AffineXformStats::AffineXformStats(), LinearVtln::ComputeTransform(), and main().

                                             {
  if (b.NumRows() == 0 || a.NumCols() == 0) {
    KALDI_WARN  << "Empty matrix in ComposeTransforms";
    return false;
  }
  if (a.NumCols() == b.NumRows()) {
    c->Resize(a.NumRows(), b.NumCols());
    c->AddMatMat(1.0, a, kNoTrans, b, kNoTrans, 0.0);  // c = a * b.
    return true;
  } else if (a.NumCols() == b.NumRows()+1) {  // a is affine.
    if (b_is_affine) {  // append 0 0 0 0 ... 1 to b and multiply.
      Matrix<BaseFloat> b_ext(b.NumRows()+1, b.NumCols());
      SubMatrix<BaseFloat> b_part(b_ext, 0, b.NumRows(), 0, b.NumCols());
      b_part.CopyFromMat(b);
      b_ext(b.NumRows(), b.NumCols()-1) = 1.0;  // so the last row is 0 0 0 0 ... 0 1
      c->Resize(a.NumRows(), b.NumCols());
      c->AddMatMat(1.0, a, kNoTrans, b_ext, kNoTrans, 0.0);  // c = a * b_ext.
    } else {  // extend b by 1 row and column with all zeros except a 1 on diagonal.
      Matrix<BaseFloat> b_ext(b.NumRows()+1, b.NumCols()+1);
      SubMatrix<BaseFloat> b_part(b_ext, 0, b.NumRows(), 0, b.NumCols());
      b_part.CopyFromMat(b);
      b_ext(b.NumRows(), b.NumCols()) = 1.0;  // so the last row is 0 0 0 0 ... 0 1;
      // rest of last column is zero (this is the offset term)
      c->Resize(a.NumRows(), b.NumCols()+1);
      c->AddMatMat(1.0, a, kNoTrans, b_ext, kNoTrans, 0.0);  // c = a * b_ext.
    }
    return true;
  } else {
    KALDI_ERR << "ComposeTransforms: mismatched dimensions, a has " << a.NumCols()
              << " columns and b has " << b.NumRows() << " rows.";  // this is fatal.
    return false;
  }
}

ComputeAcousticScoresMap()

void ComputeAcousticScoresMap	(	const Lattice &	lat,
		unordered_map< std::pair< int32, int32 >, std::pair< BaseFloat, int32 >, PairHasher< int32 > > *	acoustic_scores
	)

This function computes the mapping from the pair (frame-index, transition-id) to the pair (sum-of-acoustic-scores, num-of-occurences) over all occurences of the transition-id in that frame.

frame-index in the lattice. This function is useful for retaining the acoustic scores in a non-compact lattice after a process like determinization where the frame-level acoustic scores are typically lost. The function ReplaceAcousticScoresFromMap is used to restore the acoustic scores computed by this function.

Parameters

[in]	lat	Input lattice. Expected to be top-sorted. Otherwise the function will crash.
[out]	acoustic_scores	Pointer to a map from the pair (frame-index, transition-id) to a pair (sum-of-acoustic-scores, num-of-occurences). Usually the acoustic scores for a pdf-id (and hence transition-id) on a frame will be the same for all the occurences of the pdf-id in that frame. But if not, we will take the average of the acoustic scores. Hence, we store both the sum-of-acoustic-scores and the num-of-occurences of the transition-id in that frame.

Definition at line 1652 of file lattice-functions.cc.

References KALDI_ASSERT, KALDI_VLOG, LatticeStateTimes(), LatticeWeightTpl< FloatType >::Value2(), and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by main().

                                                                              {
  // typedef the arc, weight types
  typedef Lattice::Arc Arc;
  typedef Arc::Weight LatticeWeight;
  typedef Arc::StateId StateId;

  acoustic_scores->clear();

  std::vector<int32> state_times;
  LatticeStateTimes(lat, &state_times);   // Assumes the input is top sorted

  KALDI_ASSERT(lat.Start() == 0);

  for (StateId s = 0; s < lat.NumStates(); s++) {
    int32 t = state_times[s];
    for (fst::ArcIterator<Lattice> aiter(lat, s); !aiter.Done();
          aiter.Next()) {
      const Arc &arc = aiter.Value();
      const LatticeWeight &weight = arc.weight;

      int32 tid = arc.ilabel;

      if (tid != 0) {
        unordered_map<std::pair<int32, int32>, std::pair<BaseFloat, int32>,
          PairHasher<int32> >::iterator it = acoustic_scores->find(std::make_pair(t, tid));
        if (it == acoustic_scores->end()) {
          acoustic_scores->insert(std::make_pair(std::make_pair(t, tid),
                                          std::make_pair(weight.Value2(), 1)));
        } else {
          if (it->second.second == 2
                && it->second.first / it->second.second != weight.Value2()) {
            KALDI_VLOG(2) << "Transitions on the same frame have different "
                          << "acoustic costs for tid " << tid << "; "
                          << it->second.first / it->second.second
                          << " vs " << weight.Value2();
          }
          it->second.first += weight.Value2();
          it->second.second++;
        }
      } else {
        // Arcs with epsilon input label (tid) must have 0 acoustic cost
        KALDI_ASSERT(weight.Value2() == 0);
      }
    }

    LatticeWeight f = lat.Final(s);
    if (f != LatticeWeight::Zero()) {
      // Final acoustic cost must be 0 as we are reading from
      // non-determinized, non-compact lattice
      KALDI_ASSERT(f.Value2() == 0.0);
    }
  }
}

ComputeAmGmmFeatureDeriv()

BaseFloat ComputeAmGmmFeatureDeriv	(	const AmDiagGmm &	am_gmm,
		const TransitionModel &	trans_model,
		const Posterior &	posterior,
		const MatrixBase< BaseFloat > &	features,
		Matrix< BaseFloat > *	direct_deriv,
		const AccumAmDiagGmm *	model_diff = NULL,
		Matrix< BaseFloat > *	indirect_deriv = NULL
	)

Computes derivatives of the likelihood of these states (weighted), w.r.t.

the feature values. Used in fMPE training. Note, the weights "posterior" may be positive or negative– for MMI, MPE, etc., they will typically be of both signs. Will resize "deriv". Returns the sum of (GMM likelihood * weight), which may be used as an approximation to the objective function. Last two parameters are optional. See GetStatsDerivative() for or fMPE paper (ICASSP, 2005) more info on indirect derivative. Caution: if you supply the last two parameters, this function only works in the MMI case as it assumes the stats with positive weight are numerator == ml stats– this is only the same thing in the MMI case, not fMPE.

Definition at line 522 of file fmpe.cc.

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::AddVec(), VectorBase< Real >::AddVecVec(), DiagGmm::ComponentPosteriors(), AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), rnnlm::i, DiagGmm::inv_vars(), rnnlm::j, KALDI_ASSERT, kTrans, AccumDiagGmm::mean_accumulator(), DiagGmm::means_invvars(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), VectorBase< Real >::Scale(), TransitionModel::TransitionIdToPdf(), and AccumDiagGmm::variance_accumulator().

Referenced by main().

                                                                      {
  KALDI_ASSERT((model_diff != NULL) == (indirect_deriv != NULL));
  BaseFloat ans = 0.0;
  KALDI_ASSERT(posterior.size() == static_cast<size_t>(features.NumRows()));
  direct_deriv->Resize(features.NumRows(), features.NumCols());
  if (indirect_deriv != NULL)
    indirect_deriv->Resize(features.NumRows(), features.NumCols());
  Vector<BaseFloat> temp_vec(features.NumCols());
  Vector<double> temp_vec_dbl(features.NumCols());
  for (size_t i = 0; i < posterior.size(); i++) {
    for (size_t j = 0; j < posterior[i].size(); j++) {
      int32 tid = posterior[i][j].first,  // transition identifier.
          pdf_id = trans_model.TransitionIdToPdf(tid);
      BaseFloat weight = posterior[i][j].second;
      const DiagGmm &gmm = am_gmm.GetPdf(pdf_id);
      Vector<BaseFloat> gauss_posteriors;
      SubVector<BaseFloat> this_feat(features, i);
      SubVector<BaseFloat> this_direct_deriv(*direct_deriv, i);
      ans += weight * 
          gmm.ComponentPosteriors(this_feat, &gauss_posteriors);
      
      gauss_posteriors.Scale(weight);
      // The next line does: to i'th row of deriv, add
      // means_invvars^T * gauss_posteriors,
      // where each row of means_invvars is the mean times
      // diagonal inverse covariance... after transposing,
      // this becomes a weighted of these rows, weighted by
      // the posteriors.  This comes from the term
      //  feat^T * inv_var * mean
      // in the objective function.
      this_direct_deriv.AddMatVec(1.0, gmm.means_invvars(), kTrans,
                                  gauss_posteriors, 1.0);      

      // next line does temp_vec == inv_vars^T * gauss_posteriors,
      // which sets temp_vec to a weighted sum of the inv_vars,
      // weighed by Gaussian posterior.
      temp_vec.AddMatVec(1.0, gmm.inv_vars(), kTrans,
                         gauss_posteriors, 0.0);
      // Add to the derivative, -(this_feat .* temp_vec),
      // which is the term that comes from the -0.5 * inv_var^T feat_sq,
      // in the objective function (where inv_var is a vector, and feat_sq
      // is a vector of squares of the feature values).
      // Note: we have to do some messing about with double-precision here
      // because the stats only come in double precision.
      this_direct_deriv.AddVecVec(-1.0, this_feat, temp_vec, 1.0);
      if (model_diff != NULL && weight > 0.0) { // We need to get the indirect diff.
        // This "weight > 0.0" checks that this is the numerator stats, as the
        // fMPE indirect diff applies only to the ML stats-- CAUTION, this
        // code will only work as-is for fMMI (and the stats should not be
        // canceled), due to the assumption that ML stats == num stats.
        Vector<double> gauss_posteriors_dbl(gauss_posteriors);
        const AccumDiagGmm &deriv_acc = model_diff->GetAcc(pdf_id);
        // part of the derivative.  Note: we could just store the direct and
        // indirect derivatives together in one matrix, but it makes it easier
        // to accumulate certain diagnostics if we store them separately.
        SubVector<BaseFloat> this_indirect_deriv(*indirect_deriv, i);
        // note: deriv_acc.mean_accumulator() contains the derivative of
        // the objective function w.r.t. the "x stats" accumulated for
        // this GMM.  variance_accumulator() is the same for the "x^2 stats".
        temp_vec_dbl.AddMatVec(1.0, deriv_acc.mean_accumulator(), kTrans,
                               gauss_posteriors_dbl, 0.0);
        this_indirect_deriv.AddVec(1.0, temp_vec_dbl);
        temp_vec_dbl.AddMatVec(1.0, deriv_acc.variance_accumulator(), kTrans,
                               gauss_posteriors_dbl, 0.0);
        temp_vec.CopyFromVec(temp_vec_dbl); // convert to float.
        // next line because d(x^2 stats for Gaussian)/d(feature) =
        // 2 * (gaussian posterior) * feature.
        this_indirect_deriv.AddVecVec(2.0, this_feat, temp_vec, 1.0);
      }
    }
  }
  return ans;
}

ComputeAndSubtractMean()

void kaldi::ComputeAndSubtractMean	(	std::map< std::string, Vector< BaseFloat > *>	utt2ivector,
		Vector< BaseFloat > *	mean_out
	)

Definition at line 186 of file ivector-compute-lda.cc.

References VectorBase< Real >::AddVec(), VectorBase< Real >::CopyFromVec(), and Vector< Real >::Resize().

Referenced by main().

                                 {
  int32 dim = utt2ivector.begin()->second->Dim();
  size_t num_ivectors = utt2ivector.size();
  Vector<double> mean(dim);
  std::map<std::string, Vector<BaseFloat> *>::iterator iter;
  for (iter = utt2ivector.begin(); iter != utt2ivector.end(); ++iter)
    mean.AddVec(1.0 / num_ivectors, *(iter->second));
  mean_out->Resize(dim);
  mean_out->CopyFromVec(mean);
  for (iter = utt2ivector.begin(); iter != utt2ivector.end(); ++iter)
    iter->second->AddVec(-1.0, *mean_out);
}

ComputeCompactLatticeAlphas() [1/2]

bool kaldi::ComputeCompactLatticeAlphas	(	const CompactLattice &	lat,
		std::vector< double > *	alpha
	)

Definition at line 150 of file lattice-functions.cc.

References KALDI_WARN, kLogZeroDouble, and LogAdd().

Referenced by CreateFactorTransducer(), and ArcPosteriorComputer::OutputPosteriors().

                                                        {
  using namespace fst;

  // typedef the arc, weight types
  typedef CompactLattice::Arc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  //Make sure the lattice is topologically sorted.
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    KALDI_WARN << "Input lattice must be topologically sorted.";
    return false;
  }
  if (clat.Start() != 0) {
    KALDI_WARN << "Input lattice must start from state 0.";
    return false;
  }

  int32 num_states = clat.NumStates();
  (*alpha).resize(0);
  (*alpha).resize(num_states, kLogZeroDouble);

  // Now propagate alphas forward. Note that we don't acount the weight of the
  // final state to alpha[final_state] -- we acount it to beta[final_state];
  (*alpha)[0] = 0.0;
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = (*alpha)[s];
    for (ArcIterator<CompactLattice> aiter(clat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -(arc.weight.Weight().Value1() + arc.weight.Weight().Value2());
      (*alpha)[arc.nextstate] = LogAdd((*alpha)[arc.nextstate], this_alpha + arc_like);
    }
  }

  return true;
}

ComputeCompactLatticeAlphas() [2/2]

bool kaldi::ComputeCompactLatticeAlphas	(	const CompactLattice &	clat,
		vector< double > *	alpha
	)

Definition at line 150 of file lattice-functions.cc.

References KALDI_WARN, kLogZeroDouble, and LogAdd().

Referenced by CreateFactorTransducer(), and ArcPosteriorComputer::OutputPosteriors().

                                                        {
  using namespace fst;

  // typedef the arc, weight types
  typedef CompactLattice::Arc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  //Make sure the lattice is topologically sorted.
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    KALDI_WARN << "Input lattice must be topologically sorted.";
    return false;
  }
  if (clat.Start() != 0) {
    KALDI_WARN << "Input lattice must start from state 0.";
    return false;
  }

  int32 num_states = clat.NumStates();
  (*alpha).resize(0);
  (*alpha).resize(num_states, kLogZeroDouble);

  // Now propagate alphas forward. Note that we don't acount the weight of the
  // final state to alpha[final_state] -- we acount it to beta[final_state];
  (*alpha)[0] = 0.0;
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = (*alpha)[s];
    for (ArcIterator<CompactLattice> aiter(clat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -(arc.weight.Weight().Value1() + arc.weight.Weight().Value2());
      (*alpha)[arc.nextstate] = LogAdd((*alpha)[arc.nextstate], this_alpha + arc_like);
    }
  }

  return true;
}

ComputeCompactLatticeBetas() [1/2]

bool kaldi::ComputeCompactLatticeBetas	(	const CompactLattice &	lat,
		std::vector< double > *	beta
	)

Definition at line 188 of file lattice-functions.cc.

References KALDI_WARN, kLogZeroDouble, and LogAdd().

Referenced by CompactLatticeNormalize(), CreateFactorTransducer(), and ArcPosteriorComputer::OutputPosteriors().

                                                      {
  using namespace fst;

  // typedef the arc, weight types
  typedef CompactLattice::Arc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  // Make sure the lattice is topologically sorted.
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    KALDI_WARN << "Input lattice must be topologically sorted.";
    return false;
  }
  if (clat.Start() != 0) {
    KALDI_WARN << "Input lattice must start from state 0.";
    return false;
  }

  int32 num_states = clat.NumStates();
  (*beta).resize(0);
  (*beta).resize(num_states, kLogZeroDouble);

  // Now propagate betas backward. Note that beta[final_state] contains the
  // weight of the final state in the lattice -- compare that with alpha.
  for (StateId s = num_states-1; s >= 0; s--) {
    Weight f = clat.Final(s);
    double this_beta = -(f.Weight().Value1()+f.Weight().Value2());
    for (ArcIterator<CompactLattice> aiter(clat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -(arc.weight.Weight().Value1()+arc.weight.Weight().Value2());
      double arc_beta = (*beta)[arc.nextstate] + arc_like;
      this_beta = LogAdd(this_beta, arc_beta);
    }
    (*beta)[s] = this_beta;
  }

  return true;
}

ComputeCompactLatticeBetas() [2/2]

bool kaldi::ComputeCompactLatticeBetas	(	const CompactLattice &	clat,
		vector< double > *	beta
	)

Definition at line 188 of file lattice-functions.cc.

References KALDI_WARN, kLogZeroDouble, and LogAdd().

Referenced by CompactLatticeNormalize(), CreateFactorTransducer(), and ArcPosteriorComputer::OutputPosteriors().

                                                      {
  using namespace fst;

  // typedef the arc, weight types
  typedef CompactLattice::Arc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  // Make sure the lattice is topologically sorted.
  if (clat.Properties(fst::kTopSorted, true) == 0) {
    KALDI_WARN << "Input lattice must be topologically sorted.";
    return false;
  }
  if (clat.Start() != 0) {
    KALDI_WARN << "Input lattice must start from state 0.";
    return false;
  }

  int32 num_states = clat.NumStates();
  (*beta).resize(0);
  (*beta).resize(num_states, kLogZeroDouble);

  // Now propagate betas backward. Note that beta[final_state] contains the
  // weight of the final state in the lattice -- compare that with alpha.
  for (StateId s = num_states-1; s >= 0; s--) {
    Weight f = clat.Final(s);
    double this_beta = -(f.Weight().Value1()+f.Weight().Value2());
    for (ArcIterator<CompactLattice> aiter(clat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -(arc.weight.Weight().Value1()+arc.weight.Weight().Value2());
      double arc_beta = (*beta)[arc.nextstate] + arc_like;
      this_beta = LogAdd(this_beta, arc_beta);
    }
    (*beta)[s] = this_beta;
  }

  return true;
}

ComputeCorrelation()

void kaldi::ComputeCorrelation	(	const VectorBase< BaseFloat > &	wave,
		int32	first_lag,
		int32	last_lag,
		int32	nccf_window_size,
		VectorBase< BaseFloat > *	inner_prod,
		VectorBase< BaseFloat > *	norm_prod
	)

This function computes some dot products that are required while computing the NCCF.

For each integer lag from start to end-1, this function outputs to (*inner_prod)(lag - start), the dot-product of a window starting at 0 with a window starting at lag. All windows are of length nccf_window_size. It outputs to (*norm_prod)(lag - start), e1 * e2, where e1 is the dot-product of the un-shifted window with itself, and d2 is the dot-product of the window shifted by "lag" with itself.

Definition at line 102 of file pitch-functions.cc.

References VectorBase< Real >::Add(), VectorBase< Real >::Sum(), and VecVec().

Referenced by OnlinePitchFeatureImpl::AcceptWaveform().

                                                          {
  Vector<BaseFloat> zero_mean_wave(wave);
  // TODO: possibly fix this, the mean normalization is done in a strange way.
  SubVector<BaseFloat> wave_part(wave, 0, nccf_window_size);
  // subtract mean-frame from wave
  zero_mean_wave.Add(-wave_part.Sum() / nccf_window_size);
  BaseFloat e1, e2, sum;
  SubVector<BaseFloat> sub_vec1(zero_mean_wave, 0, nccf_window_size);
  e1 = VecVec(sub_vec1, sub_vec1);
  for (int32 lag = first_lag; lag <= last_lag; lag++) {
    SubVector<BaseFloat> sub_vec2(zero_mean_wave, lag, nccf_window_size);
    e2 = VecVec(sub_vec2, sub_vec2);
    sum = VecVec(sub_vec1, sub_vec2);
    (*inner_prod)(lag - first_lag) = sum;
    (*norm_prod)(lag - first_lag) = e1 * e2;
  }
}

ComputeDctMatrix() [1/2]

template void kaldi::ComputeDctMatrix

(

Matrix< float > *

M

)

ComputeDctMatrix() [2/2]

template void kaldi::ComputeDctMatrix

(

Matrix< double > *

M

)

ComputeEarlyReverbEnergy()

BaseFloat kaldi::ComputeEarlyReverbEnergy	(	const Vector< BaseFloat > &	rir,
		const Vector< BaseFloat > &	signal,
		BaseFloat	samp_freq
	)

Definition at line 64 of file wav-reverberate.cc.

References VectorBase< Real >::Dim(), FFTbasedBlockConvolveSignals(), KALDI_VLOG, VectorBase< Real >::Max(), VectorBase< Real >::Range(), and VecVec().

Referenced by DoReverberation().

                                                        {
  int32 peak_index = 0;
  rir.Max(&peak_index);
  KALDI_VLOG(1) << "peak index is " << peak_index;

  const float sec_before_peak = 0.001;
  const float sec_after_peak = 0.05;
  int32 early_rir_start_index = peak_index - sec_before_peak * samp_freq;
  int32 early_rir_end_index = peak_index + sec_after_peak * samp_freq;
  if (early_rir_start_index < 0) early_rir_start_index = 0;
  if (early_rir_end_index > rir.Dim()) early_rir_end_index = rir.Dim();

  int32 duration = early_rir_end_index - early_rir_start_index;
  Vector<BaseFloat> early_rir(rir.Range(early_rir_start_index, duration));
  Vector<BaseFloat> early_reverb(signal);
  FFTbasedBlockConvolveSignals(early_rir, &early_reverb);

  // compute the energy
  return VecVec(early_reverb, early_reverb) / early_reverb.Dim();
}

ComputeEer()

BaseFloat kaldi::ComputeEer	(	std::vector< BaseFloat > *	target_scores,
		std::vector< BaseFloat > *	nontarget_scores,
		BaseFloat *	threshold
	)

ComputeEer computes the Equal Error Rate (EER) for the given scores and returns it as a proportion beween 0 and 1.

If we set the threshold at x, then the target error-rate is the proportion of target_scores below x; and the non-target error-rate is the proportion of non-target scores above x. We seek a threshold x for which these error rates are the same; this error rate is the EER.

We compute this by iterating over the positions in target_scores: 0, 1, 2, and so on, and for each position consider whether the cutoff could be here. For each of these position we compute the corresponding position in nontarget_scores where the cutoff would be if the EER were the same. For instance, if the vectors had the same length, this would be position length() - 1, length() - 2, and so on. As soon as the value at that position in nontarget_scores at that position is less than the value from target_scores, we have our EER.

In coding this we weren't particularly careful about edge cases or making sure whether it's actually n + 1 instead of n.

Definition at line 48 of file compute-eer.cc.

References KALDI_ASSERT.

Referenced by main().

                                           {
  KALDI_ASSERT(!target_scores->empty() && !nontarget_scores->empty());
  std::sort(target_scores->begin(), target_scores->end());
  std::sort(nontarget_scores->begin(), nontarget_scores->end());
  
  size_t target_position = 0,
      target_size = target_scores->size();
  for (; target_position + 1 < target_size; target_position++) {
    ssize_t nontarget_size = nontarget_scores->size(),
        nontarget_n = nontarget_size * target_position * 1.0 / target_size,
        nontarget_position = nontarget_size - 1 - nontarget_n;
    if (nontarget_position  < 0)
      nontarget_position = 0;
    if ((*nontarget_scores)[nontarget_position] <
        (*target_scores)[target_position])
      break;
  }
  *threshold = (*target_scores)[target_position];
  BaseFloat eer = target_position * 1.0 / target_size;
  return eer;
}

ComputeFeatureNormalizingTransform()

void ComputeFeatureNormalizingTransform	(	const FullGmm &	gmm,
		Matrix< BaseFloat > *	xform
	)

Computes the inverse of an LDA transform (without dimensionality reduction) The computed transform is used in initializing the phonetic and speaker subspaces, as well as while increasing the dimensions of those spaces.

Definition at line 1297 of file am-sgmm2.cc.

References SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::AddSp(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2(), TpMatrix< Real >::Cholesky(), MatrixBase< Real >::CopyFromTp(), VectorBase< Real >::CopyFromVec(), FullGmm::Dim(), SpMatrix< Real >::Eig(), FullGmm::GetCovarsAndMeans(), rnnlm::i, TpMatrix< Real >::InvertDouble(), MatrixBase< Real >::InvertDouble(), KALDI_ASSERT, KALDI_WARN, kNoTrans, kTrans, FullGmm::NumGauss(), Matrix< Real >::Resize(), MatrixBase< Real >::Row(), PackedMatrix< Real >::Scale(), VectorBase< Real >::Scale(), SortSvd(), and FullGmm::weights().

Referenced by AmSgmm2::GetVarScaledSubstateSpeakerMean(), AmSgmm2::InitializeFromFullGmm(), main(), and TestSgmm2IncreaseDim().

                                                                                      {
  int32 dim = gmm.Dim();
  int32 num_gauss = gmm.NumGauss();
  SpMatrix<BaseFloat> within_class_covar(dim);
  SpMatrix<BaseFloat> between_class_covar(dim);
  Vector<BaseFloat> global_mean(dim);

  // Accumulate LDA statistics from the GMM parameters.
  {
    BaseFloat total_weight = 0.0;
    Vector<BaseFloat> tmp_weight(num_gauss);
    Matrix<BaseFloat> tmp_means;
    std::vector< SpMatrix<BaseFloat> > tmp_covars;
    tmp_weight.CopyFromVec(gmm.weights());
    gmm.GetCovarsAndMeans(&tmp_covars, &tmp_means);
    for (int32 i = 0; i < num_gauss; i++) {
      BaseFloat w_i = tmp_weight(i);
      total_weight += w_i;
      within_class_covar.AddSp(w_i, tmp_covars[i]);
      between_class_covar.AddVec2(w_i, tmp_means.Row(i));
      global_mean.AddVec(w_i, tmp_means.Row(i));
    }
    KALDI_ASSERT(total_weight > 0);
    if (fabs(total_weight - 1.0) > 0.001) {
      KALDI_WARN << "Total weight across the GMMs is " << (total_weight)
          << ", renormalizing.";
      global_mean.Scale(1.0 / total_weight);
      within_class_covar.Scale(1.0 / total_weight);
      between_class_covar.Scale(1.0 / total_weight);
    }
    between_class_covar.AddVec2(-1.0, global_mean);
  }

  TpMatrix<BaseFloat> chol(dim);
  chol.Cholesky(within_class_covar);  // Sigma_W = L L^T
  TpMatrix<BaseFloat> chol_inv(chol);
  chol_inv.InvertDouble();
  Matrix<BaseFloat> chol_full(dim, dim);
  chol_full.CopyFromTp(chol_inv);
  SpMatrix<BaseFloat> LBL(dim);
  // LBL = L^{-1} \Sigma_B L^{-T}
  LBL.AddMat2Sp(1.0, chol_full, kNoTrans, between_class_covar, 0.0);
  Vector<BaseFloat> Dvec(dim);
  Matrix<BaseFloat> U(dim, dim);
  LBL.Eig(&Dvec, &U);
  SortSvd(&Dvec, &U);

  xform->Resize(dim, dim);
  chol_full.CopyFromTp(chol);
  // T := L U, eq (23)
  xform->AddMatMat(1.0, chol_full, kNoTrans, U, kNoTrans, 0.0);

#ifdef KALDI_PARANOID
  Matrix<BaseFloat> inv_xform(*xform);
  inv_xform.InvertDouble();
  {  // Check that T*within_class_covar*T' = I.
    Matrix<BaseFloat> wc_covar_full(dim, dim), tmp(dim, dim);
    wc_covar_full.CopyFromSp(within_class_covar);
    tmp.AddMatMat(1.0, inv_xform, kNoTrans, wc_covar_full, kNoTrans, 0.0);
    wc_covar_full.AddMatMat(1.0, tmp, kNoTrans, inv_xform, kTrans, 0.0);
    KALDI_ASSERT(wc_covar_full.IsUnit(0.01));
  }
  {  // Check that T*between_class_covar*T' = diagonal.
    Matrix<BaseFloat> bc_covar_full(dim, dim), tmp(dim, dim);
    bc_covar_full.CopyFromSp(between_class_covar);
    tmp.AddMatMat(1.0, inv_xform, kNoTrans, bc_covar_full, kNoTrans, 0.0);
    bc_covar_full.AddMatMat(1.0, tmp, kNoTrans, inv_xform, kTrans, 0.0);
    KALDI_ASSERT(bc_covar_full.IsDiagonal(0.01));
  }
#endif
}

ComputeFmllrDiagGmm()

BaseFloat kaldi::ComputeFmllrDiagGmm	(	const FmllrDiagGmmAccs &	accs,
		const FmllrOptions &	opts,
		Matrix< BaseFloat > *	out_fmllr,
		BaseFloat *	logdet
	)

Referenced by InitFmllr().

ComputeFmllrLogDet()

BaseFloat kaldi::ComputeFmllrLogDet ( const Matrix< BaseFloat > &  fmllr_mat )

inline

Definition at line 176 of file fmllr-diag-gmm.h.

References ApplyFeatureTransformToStats(), ApplyModelTransformToStats(), ComputeFmllrMatrixDiagGmm(), ComputeFmllrMatrixDiagGmmDiagonal(), ComputeFmllrMatrixDiagGmmDiagonal2(), ComputeFmllrMatrixDiagGmmFull(), ComputeFmllrMatrixDiagGmmOffset(), FmllrAuxfGradient(), FmllrAuxFuncDiagGmm(), FmllrInnerUpdate(), KALDI_ASSERT, MatrixBase< Real >::LogDet(), FmllrOptions::num_iters, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

                                                                        {
  KALDI_ASSERT(fmllr_mat.NumRows() != 0 && fmllr_mat.NumCols() == fmllr_mat.NumRows()+1);
  SubMatrix<BaseFloat> tmp(fmllr_mat,
                           0, fmllr_mat.NumRows(),
                           0, fmllr_mat.NumRows());
  return tmp.LogDet();
}

ComputeFmllrMatrixDiagGmm()

BaseFloat ComputeFmllrMatrixDiagGmm	(	const MatrixBase< BaseFloat > &	in_xform,
		const AffineXformStats &	stats,
		std::string	fmllr_type,
		int32	num_iters,
		MatrixBase< BaseFloat > *	out_xform
	)

This function internally calls ComputeFmllrMatrixDiagGmm{Full, Diagonal, Offset}, depending on "fmllr_type".

Definition at line 169 of file fmllr-diag-gmm.cc.

References ComputeFmllrMatrixDiagGmmDiagonal(), ComputeFmllrMatrixDiagGmmFull(), ComputeFmllrMatrixDiagGmmOffset(), MatrixBase< Real >::IsUnit(), KALDI_ERR, KALDI_WARN, and MatrixBase< Real >::SetUnit().

Referenced by ComputeFmllrLogDet(), and LinearVtln::ComputeTransform().

                                                                      {
  if (fmllr_type == "full") {
    return ComputeFmllrMatrixDiagGmmFull(in_xform, stats, num_iters, out_xform);
  } else if (fmllr_type == "diag") {
    return ComputeFmllrMatrixDiagGmmDiagonal(in_xform, stats, out_xform);
  } else if (fmllr_type == "offset") {
    return ComputeFmllrMatrixDiagGmmOffset(in_xform, stats, out_xform);
  } else if (fmllr_type == "none") {
    if (!in_xform.IsUnit())
      KALDI_WARN << "You set fMLLR type to \"none\" but your starting transform "
          "is not unit [this is strange, and diagnostics will be wrong].";
    out_xform->SetUnit();
    return 0.0;
  } else
    KALDI_ERR << "Unknown fMLLR update type " << fmllr_type
              << ", must be one of \"full\"|\"diag\"|\"offset\"|\"none\"";
  return 0.0;
}

ComputeFmllrMatrixDiagGmmDiagonal()

BaseFloat ComputeFmllrMatrixDiagGmmDiagonal	(	const MatrixBase< BaseFloat > &	in_xform,
		const AffineXformStats &	stats,
		MatrixBase< BaseFloat > *	out_xform
	)

This does diagonal fMLLR (i.e.

only estimate an offset and scale per dimension). The format of the output is the same as for the full case. Of course, these statistics are unnecessarily large for this case. Returns the objective function improvement, not normalized by number of frames.

Definition at line 275 of file fmllr-diag-gmm.cc.

References AffineXformStats::beta_, MatrixBase< Real >::CopyFromMat(), FmllrAuxFuncDiagGmm(), AffineXformStats::G_, rnnlm::i, AffineXformStats::K_, KALDI_ASSERT, KALDI_VLOG, KALDI_WARN, and MatrixBase< Real >::Range().

Referenced by ComputeFmllrLogDet(), ComputeFmllrMatrixDiagGmm(), FmllrDiagGmmAccs::Update(), and RegtreeFmllrDiagGmmAccs::Update().

                                                                              {
  // The "Diagonal" here means a diagonal fMLLR matrix, i.e. like W = [ A;  b] where
  // A is diagonal.
  // We re-derived the math (see exponential transform paper) to get a simpler
  // update rule.

  /*
  Write out_xform as D, which is a d x d+1 matrix (where d is the feature dimension).
  We are solving for s == d_{i,i}, and o == d_{i,d}  [assuming zero-based indexing];
      s is a scale, o is an offset.
  The stats are K (dimension d x d+1) and G_i for i=0..d-1 (dimension: d+1 x d+1),
    and the count beta.

 The auxf for the i'th row of the transform is (assuming zero-based indexing):

  s k_{i,i}  +  o k_{i,d}
  - \frac{1}{2} s^2 g_{i,i,i} - \frac{1}{2} o^2 g_{i,d,d} - s o g_{i,d,i}
   + \beta \log |s|

   Suppose we know s, we can solve for o:
      o = (k_{i,d} - s g_{i,d,i}) / g_{i,d,d}
   Substituting this expression for o into the auxf (and ignoring
   terms that don't vary with s), we have the auxf:

 \frac{1}{2} s^2 ( g_{i,d,i}^2 / g_{i,d,d}  -  g_{i,i,i} )
    +  s ( k_{i,i} - g_{i,d,i} k_{i,d} / g_{i,d,d} )
    + \beta \log |s|

  Differentiating w.r.t. s and assuming s is positive, we have
    a s + b + c/s = 0
 where
   a = (  g_{i,d,i}^2 / g_{i,d,d}  -  g_{i,i,i} ),
   b = ( k_{i,i} - g_{i,d,i} k_{i,d} / g_{i,d,d} )
   c = beta
 Multiplying by s, we have the equation
   a s^2 + b s + c = 0, where we assume s > 0.
 We solve it with:
  s = (-b - \sqrt{b^2 - 4ac}) / 2a
 [take the negative root because we know a is negative, and this gives
  the more positive solution for s; the other one would be negative].
 We then solve for o with the equation above, i.e.:
     o = (k_{i,d} - s g_{i,d,i}) / g_{i,d,d})
  */

  int32 dim = stats.G_.size();
  double beta = stats.beta_;
  out_xform->CopyFromMat(in_xform);
  if (beta == 0.0) {
    KALDI_WARN << "Computing diagonal fMLLR matrix: no stats [using original transform]";
    return 0.0;
  }
  BaseFloat old_obj = FmllrAuxFuncDiagGmm(*out_xform, stats);
  KALDI_ASSERT(out_xform->Range(0, dim, 0, dim).IsDiagonal()); // orig transform
  // must be diagonal.
  for(int32 i = 0; i < dim; i++) {
    double k_ii = stats.K_(i, i), k_id = stats.K_(i, dim),
        g_iii = stats.G_[i](i, i), g_idd = stats.G_[i](dim, dim),
        g_idi = stats.G_[i](dim, i);
    double a = g_idi*g_idi/g_idd - g_iii,
        b = k_ii - g_idi*k_id/g_idd,
        c = beta;
    double s = (-b - std::sqrt(b*b - 4*a*c)) / (2*a);
    KALDI_ASSERT(s > 0.0);
    double o = (k_id - s*g_idi) / g_idd;
    (*out_xform)(i, i) = s;
    (*out_xform)(i, dim) = o;
  }
  BaseFloat new_obj = FmllrAuxFuncDiagGmm(*out_xform, stats);
  KALDI_VLOG(2) << "fMLLR objective function improvement = "
                << (new_obj - old_obj);
  return new_obj - old_obj;
}

ComputeFmllrMatrixDiagGmmDiagonal2()

BaseFloat kaldi::ComputeFmllrMatrixDiagGmmDiagonal2	(	const MatrixBase< BaseFloat > &	in_xform,
		const AffineXformStats &	stats,
		MatrixBase< BaseFloat > *	out_xform
	)

Referenced by ComputeFmllrLogDet().

ComputeFmllrMatrixDiagGmmFull()

BaseFloat ComputeFmllrMatrixDiagGmmFull	(	const MatrixBase< BaseFloat > &	in_xform,
		const AffineXformStats &	stats,
		int32	num_iters,
		MatrixBase< BaseFloat > *	out_xform
	)

Updates the FMLLR matrix using Mark Gales' row-by-row update.

Uses full fMLLR matrix (no structure). Returns the objective function improvement, not normalized by number of frames.

Definition at line 236 of file fmllr-diag-gmm.cc.

References ApproxEqual(), AffineXformStats::beta_, MatrixBase< Real >::CopyFromMat(), rnnlm::d, FmllrAuxFuncDiagGmm(), FmllrInnerUpdate(), AffineXformStats::G_, AffineXformStats::K_, KALDI_LOG, KALDI_WARN, and kNoTrans.

Referenced by ComputeFmllrLogDet(), ComputeFmllrMatrixDiagGmm(), FmllrDiagGmmAccs::Update(), and RegtreeFmllrDiagGmmAccs::Update().

                                                                          {
  int32 dim = static_cast<int32>(stats.G_.size());

  // Compute the inverse matrices of second-order statistics
  vector< SpMatrix<double> > inv_g(dim);
  for (int32 d = 0; d < dim; d++) {
    inv_g[d].Resize(dim + 1);
    inv_g[d].CopyFromSp(stats.G_[d]);
    inv_g[d].Invert();
  }

  Matrix<double> old_xform(in_xform), new_xform(in_xform);
  BaseFloat old_objf = FmllrAuxFuncDiagGmm(old_xform, stats);
  
  for (int32 iter = 0; iter < num_iters; ++iter) {
    for (int32 d = 0; d < dim; d++) {
      SubVector<double> k_d(stats.K_, d);
      FmllrInnerUpdate(inv_g[d], k_d, stats.beta_, d, &new_xform);
    }  // end of looping over rows
  }  // end of iterations

  BaseFloat new_objf = FmllrAuxFuncDiagGmm(new_xform, stats),
      objf_improvement = new_objf - old_objf;
  KALDI_LOG << "fMLLR objf improvement is "
            << (objf_improvement / (stats.beta_ + 1.0e-10))
            << " per frame over " << stats.beta_ << " frames.";
  if (objf_improvement < 0.0 && !ApproxEqual(new_objf, old_objf)) {
    KALDI_WARN << "No applying fMLLR transform change because objective "
               << "function did not increase.";
    return 0.0;
  } else {
    out_xform->CopyFromMat(new_xform, kNoTrans);
    return objf_improvement;
  }
}

ComputeFmllrMatrixDiagGmmOffset()

BaseFloat ComputeFmllrMatrixDiagGmmOffset	(	const MatrixBase< BaseFloat > &	in_xform,
		const AffineXformStats &	stats,
		MatrixBase< BaseFloat > *	out_xform
	)

This does offset-only fMLLR, i.e. it only estimates an offset.

Definition at line 350 of file fmllr-diag-gmm.cc.

References MatrixBase< Real >::CopyFromMat(), AffineXformStats::G_, rnnlm::i, AffineXformStats::K_, KALDI_ASSERT, KALDI_WARN, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by ComputeFmllrLogDet(), ComputeFmllrMatrixDiagGmm(), FmllrDiagGmmAccs::Update(), and RegtreeFmllrDiagGmmAccs::Update().

                                                                            {
  int32 dim = stats.G_.size();
  KALDI_ASSERT(in_xform.NumRows() == dim && in_xform.NumCols() == dim+1);
  SubMatrix<BaseFloat> square_part(in_xform, 0, dim, 0, dim);
  KALDI_ASSERT(square_part.IsUnit());
  BaseFloat objf_impr = 0.0;
  out_xform->CopyFromMat(in_xform);
  for (int32 i = 0; i < dim; i++) {
    // auxf in this offset b_i is:
    //  -0.5 b_i^2 G_i(dim, dim) - b_i G_i(i, dim)*1.0 + b_i K(i, dim)  (1)
    // answer is:
    // b_i = [K(i, dim) - G_i(i, dim)] / G_i(dim, dim)
    // objf change is given by (1)
    BaseFloat b_i = (*out_xform)(i, dim);
    BaseFloat objf_before = -0.5 * b_i * b_i * stats.G_[i](dim, dim)
        - b_i * stats.G_[i](i, dim) + b_i * stats.K_(i, dim);
    b_i = (stats.K_(i, dim) - stats.G_[i](i, dim)) / stats.G_[i](dim, dim);
    (*out_xform)(i, dim) = b_i;
    BaseFloat objf_after = -0.5 * b_i * b_i * stats.G_[i](dim, dim)
        - b_i * stats.G_[i](i, dim) + b_i * stats.K_(i, dim);
    if (objf_after < objf_before)
      KALDI_WARN << "Objf decrease in offset estimation:"
                 << objf_after << " < " << objf_before;
    objf_impr += objf_after - objf_before;
  }
  return objf_impr;
}

ComputeGconsts()

static void kaldi::ComputeGconsts ( const VectorBase< BaseFloat > &  weights, const MatrixBase< BaseFloat > &  means, const MatrixBase< BaseFloat > &  inv_vars, VectorBase< BaseFloat > *  gconsts_out  )

static

Definition at line 112 of file decodable-am-diag-gmm-regtree.cc.

References rnnlm::d, VectorBase< Real >::Dim(), KALDI_ASSERT, KALDI_ERR, KALDI_ISINF, KALDI_ISNAN, KALDI_WARN, Log(), M_LOG_2PI, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by DecodableAmDiagGmmRegtreeMllr::GetXformedMeanInvVars().

                                                               {
  int32 num_gauss = weights.Dim();
  int32 dim = means.NumCols();
  KALDI_ASSERT(means.NumRows() == num_gauss
      && inv_vars.NumRows() == num_gauss && inv_vars.NumCols() == dim);
  KALDI_ASSERT(gconsts_out->Dim() == num_gauss);

  BaseFloat offset = -0.5 * M_LOG_2PI * dim;  // constant term in gconst.
  int32 num_bad = 0;

  for (int32 gauss = 0; gauss < num_gauss; gauss++) {
    KALDI_ASSERT(weights(gauss) >= 0);  // Cannot have negative weights.
    BaseFloat gc = Log(weights(gauss)) + offset;  // May be -inf if weights == 0
    for (int32 d = 0; d < dim; d++) {
      gc += 0.5 * Log(inv_vars(gauss, d)) - 0.5 * means(gauss, d)
        * means(gauss, d) * inv_vars(gauss, d);  // diff from DiagGmm version.
    }

    if (KALDI_ISNAN(gc)) {  // negative infinity is OK but NaN is not acceptable
      KALDI_ERR << "At component "  << gauss
                << ", not a number in gconst computation";
    }
    if (KALDI_ISINF(gc)) {
      num_bad++;
      // If positive infinity, make it negative infinity.
      // Want to make sure the answer becomes -inf in the end, not NaN.
      if (gc > 0) gc = -gc;
    }
    (*gconsts_out)(gauss) = gc;
  }
  if (num_bad > 0)
    KALDI_WARN << num_bad << " unusable components found while computing "
               << "gconsts.";
}

ComputeInitialSplit()

BaseFloat kaldi::ComputeInitialSplit	(	const std::vector< Clusterable *> &	summed_stats,
		const Questions &	q_opts,
		EventKeyType	key,
		std::vector< EventValueType > *	yes_set
	)

Definition at line 297 of file build-tree-utils.cc.

References AddToClustersOptimized(), DeletePointers(), Questions::GetQuestionsOf(), rnnlm::i, QuestionsForKey::initial_questions, KALDI_ASSERT, KALDI_WARN, Clusterable::Objf(), SumClusterable(), and SumClusterableObjf().

Referenced by FindBestSplitForKey().

                                                                  {
  KALDI_ASSERT(yes_set != NULL);
  yes_set->clear();
  const QuestionsForKey &key_opts = q_opts.GetQuestionsOf(key);

  // "total" needed for optimization in AddToClustersOptimized,
  // and also used to work otu total objf.
  Clusterable *total = SumClusterable(summed_stats);
  if (total == NULL) return 0.0;  // because there were no stats or non-NULL stats.
  BaseFloat unsplit_objf = total->Objf();

  const std::vector<std::vector<EventValueType> > &questions_of_this_key = key_opts.initial_questions;

  int32 best_idx = -1;
  BaseFloat best_objf_change = 0;

  for (size_t i = 0; i < questions_of_this_key.size(); i++) {
    const std::vector<EventValueType> &yes_set = questions_of_this_key[i];
    std::vector<int32> assignments(summed_stats.size(), 0);  // 0 is index of "no".
    std::vector<Clusterable*> clusters(2);  // no and yes clusters.
    for (std::vector<EventValueType>::const_iterator iter = yes_set.begin(); iter != yes_set.end(); ++iter) {
      KALDI_ASSERT(*iter>=0);
      if (*iter < (EventValueType)assignments.size()) assignments[*iter] = 1;
    }
    kaldi::AddToClustersOptimized(summed_stats, assignments, *total, &clusters);
    BaseFloat this_objf = SumClusterableObjf(clusters);

    if (this_objf < unsplit_objf- 0.001*std::abs(unsplit_objf)) {  // got worse; should never happen.
      // of course small differences can be caused by roundoff.
      KALDI_WARN << "Objective function got worse when building tree: "<< this_objf << " < " << unsplit_objf;
      KALDI_ASSERT(!(this_objf < unsplit_objf - 0.01*(200 + std::abs(unsplit_objf))));  // do assert on more stringent check.
    }

    BaseFloat this_objf_change = this_objf - unsplit_objf;
    if (this_objf_change > best_objf_change) {
      best_objf_change = this_objf_change;
      best_idx = i;
    }
    DeletePointers(&clusters);
  }
  delete total;
  if (best_idx != -1)
    *yes_set = questions_of_this_key[best_idx];
  return best_objf_change;
}

ComputeKaldiPitchFirstPass()

void kaldi::ComputeKaldiPitchFirstPass	(	const PitchExtractionOptions &	opts,
		const VectorBase< BaseFloat > &	wave,
		Matrix< BaseFloat > *	output
	)

This function is called from ComputeKaldiPitch when the user specifies opts.simulate_first_pass_online == true.

It gives the "first-pass" version of the features, which you would get on the first decoding pass in an online setting. These may differ slightly from the final features due to both the way the Viterbi traceback works (this is affected by opts.max_frames_latency), and the online way we compute the average signal energy.

Definition at line 1248 of file pitch-functions.cc.

References OnlinePitchFeature::AcceptWaveform(), VectorBase< Real >::Dim(), PitchExtractionOptions::frame_shift_ms, PitchExtractionOptions::frames_per_chunk, OnlinePitchFeature::GetFrame(), OnlinePitchFeature::InputFinished(), KALDI_ASSERT, KALDI_WARN, kCopyData, OnlinePitchFeature::NumFramesReady(), Matrix< Real >::Resize(), MatrixBase< Real >::RowRange(), and PitchExtractionOptions::samp_freq.

Referenced by ComputeKaldiPitch().

                               {

  int32 cur_rows = 100;
  Matrix<BaseFloat> feats(cur_rows, 2);

  OnlinePitchFeature pitch_extractor(opts);
  KALDI_ASSERT(opts.frames_per_chunk > 0 &&
               "--simulate-first-pass-online option does not make sense "
               "unless you specify --frames-per-chunk");

  int32 cur_offset = 0, cur_frame = 0, samp_per_chunk =
      opts.frames_per_chunk * opts.samp_freq * opts.frame_shift_ms / 1000.0f;

  while (cur_offset < wave.Dim()) {
    int32 num_samp = std::min(samp_per_chunk, wave.Dim() - cur_offset);
    SubVector<BaseFloat> wave_chunk(wave, cur_offset, num_samp);
    pitch_extractor.AcceptWaveform(opts.samp_freq, wave_chunk);
    cur_offset += num_samp;
    if (cur_offset == wave.Dim())
      pitch_extractor.InputFinished();
    // Get each frame as soon as it is ready.
    for (; cur_frame < pitch_extractor.NumFramesReady(); cur_frame++) {
      if (cur_frame >= cur_rows) {
        cur_rows *= 2;
        feats.Resize(cur_rows, 2, kCopyData);
      }
      SubVector<BaseFloat> row(feats, cur_frame);
      pitch_extractor.GetFrame(cur_frame, &row);
    }
  }
  if (cur_frame  == 0) {
    KALDI_WARN << "No features output since wave file too short";
    output->Resize(0, 0);
  } else {
    *output = feats.RowRange(0, cur_frame);
  }
}

ComputeLatticeAlphasAndBetas() [1/4]

double kaldi::ComputeLatticeAlphasAndBetas	(	const LatticeType &	lat,
		bool	viterbi,
		std::vector< double > *	alpha,
		std::vector< double > *	beta
	)

Definition at line 452 of file lattice-functions.cc.

References ApproxEqual(), ComputeLatticeAlphasAndBetas(), fst::ConvertToCost(), KALDI_ASSERT, KALDI_WARN, kLogZeroDouble, and LogAddOrMax().

Referenced by CompactLatticeLimitDepth(), ComputeLatticeAlphasAndBetas(), and DiscriminativeSupervisionSplitter::ComputeLatticeScores().

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

  StateId num_states = lat.NumStates();
  KALDI_ASSERT(lat.Properties(fst::kTopSorted, true) == fst::kTopSorted);
  KALDI_ASSERT(lat.Start() == 0);
  alpha->clear();
  beta->clear();
  alpha->resize(num_states, kLogZeroDouble);
  beta->resize(num_states, kLogZeroDouble);

  double tot_forward_prob = kLogZeroDouble;
  (*alpha)[0] = 0.0;
  // Propagate alphas forward.
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = (*alpha)[s];
    for (fst::ArcIterator<LatticeType> aiter(lat, s); !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight);
      (*alpha)[arc.nextstate] = LogAddOrMax(viterbi, (*alpha)[arc.nextstate],
                                                this_alpha + arc_like);
    }
    Weight f = lat.Final(s);
    if (f != Weight::Zero()) {
      double final_like = this_alpha - ConvertToCost(f);
      tot_forward_prob = LogAddOrMax(viterbi, tot_forward_prob, final_like);
    }
  }
  for (StateId s = num_states-1; s >= 0; s--) { // it's guaranteed signed.
    double this_beta = -ConvertToCost(lat.Final(s));
    for (fst::ArcIterator<LatticeType> aiter(lat, s); !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight),
          arc_beta = (*beta)[arc.nextstate] + arc_like;
      this_beta = LogAddOrMax(viterbi, this_beta, arc_beta);
    }
    (*beta)[s] = this_beta;
  }
  double tot_backward_prob = (*beta)[lat.Start()];
  if (!ApproxEqual(tot_forward_prob, tot_backward_prob, 1e-8)) {
    KALDI_WARN << "Total forward probability over lattice = " << tot_forward_prob
               << ", while total backward probability = " << tot_backward_prob;
  }
  // Split the difference when returning... they should be the same.
  return 0.5 * (tot_backward_prob + tot_forward_prob);
}

ComputeLatticeAlphasAndBetas() [2/4]

double kaldi::ComputeLatticeAlphasAndBetas	(	const LatticeType &	lat,
		bool	viterbi,
		vector< double > *	alpha,
		vector< double > *	beta
	)

Definition at line 452 of file lattice-functions.cc.

References ApproxEqual(), ComputeLatticeAlphasAndBetas(), fst::ConvertToCost(), KALDI_ASSERT, KALDI_WARN, kLogZeroDouble, and LogAddOrMax().

Referenced by CompactLatticeLimitDepth(), ComputeLatticeAlphasAndBetas(), and DiscriminativeSupervisionSplitter::ComputeLatticeScores().

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

  StateId num_states = lat.NumStates();
  KALDI_ASSERT(lat.Properties(fst::kTopSorted, true) == fst::kTopSorted);
  KALDI_ASSERT(lat.Start() == 0);
  alpha->clear();
  beta->clear();
  alpha->resize(num_states, kLogZeroDouble);
  beta->resize(num_states, kLogZeroDouble);

  double tot_forward_prob = kLogZeroDouble;
  (*alpha)[0] = 0.0;
  // Propagate alphas forward.
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = (*alpha)[s];
    for (fst::ArcIterator<LatticeType> aiter(lat, s); !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight);
      (*alpha)[arc.nextstate] = LogAddOrMax(viterbi, (*alpha)[arc.nextstate],
                                                this_alpha + arc_like);
    }
    Weight f = lat.Final(s);
    if (f != Weight::Zero()) {
      double final_like = this_alpha - ConvertToCost(f);
      tot_forward_prob = LogAddOrMax(viterbi, tot_forward_prob, final_like);
    }
  }
  for (StateId s = num_states-1; s >= 0; s--) { // it's guaranteed signed.
    double this_beta = -ConvertToCost(lat.Final(s));
    for (fst::ArcIterator<LatticeType> aiter(lat, s); !aiter.Done();
         aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight),
          arc_beta = (*beta)[arc.nextstate] + arc_like;
      this_beta = LogAddOrMax(viterbi, this_beta, arc_beta);
    }
    (*beta)[s] = this_beta;
  }
  double tot_backward_prob = (*beta)[lat.Start()];
  if (!ApproxEqual(tot_forward_prob, tot_backward_prob, 1e-8)) {
    KALDI_WARN << "Total forward probability over lattice = " << tot_forward_prob
               << ", while total backward probability = " << tot_backward_prob;
  }
  // Split the difference when returning... they should be the same.
  return 0.5 * (tot_backward_prob + tot_forward_prob);
}

ComputeLatticeAlphasAndBetas() [3/4]

template double kaldi::ComputeLatticeAlphasAndBetas	(	const Lattice &	lat,
		bool	viterbi,
		vector< double > *	alpha,
		vector< double > *	beta
	)

ComputeLatticeAlphasAndBetas() [4/4]

template double kaldi::ComputeLatticeAlphasAndBetas	(	const CompactLattice &	lat,
		bool	viterbi,
		vector< double > *	alpha,
		vector< double > *	beta
	)

ComputeLdaTransform()

void kaldi::ComputeLdaTransform	(	const std::map< std::string, Vector< BaseFloat > *> &	utt2ivector,
		const std::map< std::string, std::vector< std::string > > &	spk2utt,
		BaseFloat	total_covariance_factor,
		BaseFloat	covariance_floor,
		MatrixBase< BaseFloat > *	lda_out
	)

Definition at line 107 of file ivector-compute-lda.cc.

References CovarianceStats::AccStats(), SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::AddSp(), ComputeNormalizingTransform(), MatrixBase< Real >::CopyFromMat(), SpMatrix< Real >::Eig(), CovarianceStats::Empty(), CovarianceStats::GetTotalCovar(), CovarianceStats::GetWithinCovar(), CovarianceStats::Info(), KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, rnnlm::n, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Row(), CovarianceStats::SingularTotCovar(), and SortSvd().

Referenced by main().

                                    {
  KALDI_ASSERT(!utt2ivector.empty());
  int32 lda_dim = lda_out->NumRows(), dim = lda_out->NumCols();
  KALDI_ASSERT(dim == utt2ivector.begin()->second->Dim());
  KALDI_ASSERT(lda_dim > 0 && lda_dim <= dim);

  CovarianceStats stats(dim);

  std::map<std::string, std::vector<std::string> >::const_iterator iter;
  for (iter = spk2utt.begin(); iter != spk2utt.end(); ++iter) {
    const std::vector<std::string> &uttlist = iter->second;
    KALDI_ASSERT(!uttlist.empty());

    int32 N = uttlist.size(); // number of utterances.
    Matrix<double> utts_of_this_spk(N, dim);
    for (int32 n = 0; n < N; n++) {
      std::string utt = uttlist[n];
      KALDI_ASSERT(utt2ivector.count(utt) != 0);
      utts_of_this_spk.Row(n).CopyFromVec(
          *(utt2ivector.find(utt)->second));
    }
    stats.AccStats(utts_of_this_spk);
  }

  KALDI_LOG << "Stats have " << stats.Info();
  KALDI_ASSERT(!stats.Empty());
  KALDI_ASSERT(!stats.SingularTotCovar() &&
               "Too little data for iVector dimension.");


  SpMatrix<double> total_covar;
  stats.GetTotalCovar(&total_covar);
  SpMatrix<double> within_covar;
  stats.GetWithinCovar(&within_covar);


  SpMatrix<double> mat_to_normalize(dim);
  mat_to_normalize.AddSp(total_covariance_factor, total_covar);
  mat_to_normalize.AddSp(1.0 - total_covariance_factor, within_covar);

  Matrix<double> T(dim, dim);
  ComputeNormalizingTransform(mat_to_normalize,
    static_cast<double>(covariance_floor), &T);

  SpMatrix<double> between_covar(total_covar);
  between_covar.AddSp(-1.0, within_covar);

  SpMatrix<double> between_covar_proj(dim);
  between_covar_proj.AddMat2Sp(1.0, T, kNoTrans, between_covar, 0.0);

  Matrix<double> U(dim, dim);
  Vector<double> s(dim);
  between_covar_proj.Eig(&s, &U);
  bool sort_on_absolute_value = false; // any negative ones will go last (they
                                       // shouldn't exist anyway so doesn't
                                       // really matter)
  SortSvd(&s, &U, static_cast<Matrix<double>*>(NULL),
          sort_on_absolute_value);

  KALDI_LOG << "Singular values of between-class covariance after projecting "
            << "with interpolated [total/within] covariance with a weight of "
            << total_covariance_factor << " on the total covariance, are: " << s;

  // U^T is the transform that will diagonalize the between-class covariance.
  // U_part is just the part of U that corresponds to the kept dimensions.
  SubMatrix<double> U_part(U, 0, dim, 0, lda_dim);

  // We first transform by T and then by U_part^T.  This means T
  // goes on the right.
  Matrix<double> temp(lda_dim, dim);
  temp.AddMatMat(1.0, U_part, kTrans, T, kNoTrans, 0.0);
  lda_out->CopyFromMat(temp);
}

ComputeLocalCost()

void kaldi::ComputeLocalCost	(	const VectorBase< BaseFloat > &	nccf_pitch,
		const VectorBase< BaseFloat > &	lags,
		const PitchExtractionOptions &	opts,
		VectorBase< BaseFloat > *	local_cost
	)

This function computes the local-cost for the Viterbi computation, see eq.

(5) in the paper.

Parameters

opts	The options as provided by the user
nccf_pitch	The nccf as computed for the pitch computation (with ballast).
lags	The log-spaced lags at which nccf_pitch is sampled.
local_cost	We output the local-cost to here.

Definition at line 178 of file pitch-functions.cc.

References VectorBase< Real >::AddVec(), VectorBase< Real >::AddVecVec(), VectorBase< Real >::Dim(), KALDI_ASSERT, VectorBase< Real >::Set(), and PitchExtractionOptions::soft_min_f0.

Referenced by PitchFrameInfo::ComputeBacktraces().

                                                         {
  // from the paper, eq. 5, local_cost = 1 - Phi(t,i)(1 - soft_min_f0 L_i)
  // nccf is the nccf on this frame measured at the lags in "lags".
  KALDI_ASSERT(nccf_pitch.Dim() == local_cost->Dim() &&
               nccf_pitch.Dim() == lags.Dim());
  local_cost->Set(1.0);
  // add the term -Phi(t,i):
  local_cost->AddVec(-1.0, nccf_pitch);
  // add the term soft_min_f0 Phi(t,i) L_i
  local_cost->AddVecVec(opts.soft_min_f0, lags, nccf_pitch, 1.0);
}

ComputeMllrMatrix()

static void kaldi::ComputeMllrMatrix ( const Matrix< double > &  K, const vector< SpMatrix< double > > &  G, Matrix< BaseFloat > *  out  )

static

Definition at line 283 of file regtree-mllr-diag-gmm.cc.

References MatrixBase< Real >::CopyFromMat(), rnnlm::d, SpMatrix< Real >::Invert(), KALDI_WARN, kNoTrans, MatrixBase< Real >::Row(), and MatrixBase< Real >::SetUnit().

Referenced by RegtreeMllrDiagGmmAccs::Update().

                                                      {
  int32 dim = G.size();
  Matrix<double> tmp_out(dim, dim+1);
  for (int32 d = 0; d < dim; d++) {
    if (G[d].Cond() > 1.0e+9) {
      KALDI_WARN << "Dim " << d << ": Badly conditioned stats. Setting MLLR "
                 << "transform to unit.";
      tmp_out.SetUnit();
      break;
    }
    SpMatrix<double> inv_g(G[d]);
//    KALDI_LOG << "Dim " << d << ": G: max = " << inv_g.Max() << ", min = "
//              << inv_g.Min() << ", log det = " << inv_g.LogDet(NULL)
//              << ", cond = " << inv_g.Cond();
    inv_g.Invert();
//    KALDI_LOG << "Inv G: max = " << inv_g.Max() << ", min = " << inv_g.Min()
//              << ", log det = " << inv_g.LogDet(NULL) << ", cond = "
//              << inv_g.Cond();
    tmp_out.Row(d).AddSpVec(1.0, inv_g, K.Row(d), 0.0);
  }
  out->CopyFromMat(tmp_out, kNoTrans);
}

ComputeNccf()

void kaldi::ComputeNccf	(	const VectorBase< BaseFloat > &	inner_prod,
		const VectorBase< BaseFloat > &	norm_prod,
		BaseFloat	nccf_ballast,
		VectorBase< BaseFloat > *	nccf_vec
	)

Computes the NCCF as a fraction of the numerator term (a dot product between two vectors) and a denominator term which equals sqrt(e1*e2 + nccf_ballast) where e1 and e2 are both dot-products of bits of the wave with themselves, and e1*e2 is supplied as "norm_prod".

These quantities are computed by "ComputeCorrelation".

Definition at line 131 of file pitch-functions.cc.

References VectorBase< Real >::Dim(), and KALDI_ASSERT.

Referenced by OnlinePitchFeatureImpl::AcceptWaveform().

                                                  {
  KALDI_ASSERT(inner_prod.Dim() == norm_prod.Dim() &&
               inner_prod.Dim() == nccf_vec->Dim());
  for (int32 lag = 0; lag < inner_prod.Dim(); lag++) {
    BaseFloat numerator = inner_prod(lag),
        denominator = pow(norm_prod(lag) + nccf_ballast, 0.5),
        nccf;
    if (denominator != 0.0) {
      nccf = numerator / denominator;
    } else {
      KALDI_ASSERT(numerator == 0.0);
      nccf = 0.0;
    }
    KALDI_ASSERT(nccf < 1.01 && nccf > -1.01);
    (*nccf_vec)(lag) = nccf;
  }
}

ComputeNewPhoneLengths()

static bool kaldi::ComputeNewPhoneLengths ( const HmmTopology &  topology, const std::vector< int32 > &  mapped_phones, const std::vector< int32 > &  old_lengths, int32  conversion_shift, int32  subsample_factor, std::vector< int32 > *  new_lengths  )

static

This function, called from ConvertAlignmentInternal(), works out suitable new lengths of phones in the case where subsample_factor != 1.

The input vectors 'mapped_phones' and 'old_lengths' must be the same size– the length of the phone sequence. The 'topology' object and 'mapped_phones' are needed to work out the minimum length of each phone in the sequence. Returns false only if it could not assign lengths (because the topology was too long relative to the number of frames).

Parameters

topology	[in] The new phone lengths are computed with regard to this topology
mapped_phones	[in] The phones for which this function computes new lengths
old_lengths	[in] The old lengths
conversion_shift	[in] This will normally equal subsample_factor - 1 but may be less than that if the 'repeat_frames' option is true; it's used for generating 'frame-shifted' versions of alignments that we will later interpolate. This helps us keep the phone boundaries of the subsampled and interpolated alignments the same as the original alignment.
subsample_factor	[in] The frame subsampling factor... normally 1, but might be > 1 if we're converting to a reduced-frame-rate system.
new_lengths	[out] The vector for storing new lengths.

Definition at line 849 of file hmm-utils.cc.

References rnnlm::i, rnnlm::j, and HmmTopology::MinLength().

Referenced by ConvertAlignmentInternal().

                                                                  {
  int32 phone_sequence_length = old_lengths.size();
  std::vector<int32> min_lengths(phone_sequence_length);
  new_lengths->resize(phone_sequence_length);
  for (int32 i = 0; i < phone_sequence_length; i++)
    min_lengths[i] = topology.MinLength(mapped_phones[i]);
  int32 cur_time_elapsed = 0;
  for (int32 i = 0; i < phone_sequence_length; i++) {
    // Note: the '+ subsample_factor - 1' here is needed so that
    // the subsampled alignments have the same length as features
    // subsampled with 'subsample-feats'.
    int32 subsampled_time =
        (cur_time_elapsed + conversion_shift) / subsample_factor;
    cur_time_elapsed += old_lengths[i];
    int32 next_subsampled_time =
        (cur_time_elapsed + conversion_shift) / subsample_factor;
    (*new_lengths)[i] = next_subsampled_time - subsampled_time;
  }
  bool changed = true;
  while (changed) {
    changed = false;
    for (int32 i = 0; i < phone_sequence_length; i++) {
      if ((*new_lengths)[i] < min_lengths[i]) {
        changed = true;
        // we need at least one extra frame.. just try to get one frame for now.
        // Get it from the left or the right, depending which one has the closest
        // availability of a 'spare' frame.
        int32 min_distance = std::numeric_limits<int32>::max(),
            best_other_phone_index = -1,
            cur_distance = 0;
        // first try to the left.
        for (int32 j = i - 1; j >= 0; j--) {
          if ((*new_lengths)[j] > min_lengths[j]) {
            min_distance = cur_distance;
            best_other_phone_index = j;
            break;
          } else {
            cur_distance += (*new_lengths)[j];
          }
        }
        // .. now to the right.
        cur_distance = 0;
        for (int32 j = i + 1; j < phone_sequence_length; j++) {
          if ((*new_lengths)[j] > min_lengths[j]) {
            if (cur_distance < min_distance) {
              min_distance = cur_distance;
              best_other_phone_index = j;
            }
            break;
          } else {
            cur_distance += (*new_lengths)[j];
          }
        }
        if (best_other_phone_index == -1)
          return false;
        // assign an extra frame to this phone...
        (*new_lengths)[i]++;
        // and borrow it from the place that we found.
        (*new_lengths)[best_other_phone_index]--;
      }
    }
  }
  return true;
}

ComputeNormalizingTransform() [1/2]

static void kaldi::ComputeNormalizingTransform ( const SpMatrix< Real > &  covar, MatrixBase< Real > *  proj  )

static

This function computes a projection matrix that when applied makes the covariance unit (i.e.

all 1).

Definition at line 46 of file plda.cc.

References TpMatrix< Real >::Cholesky(), MatrixBase< Real >::CopyFromTp(), TpMatrix< Real >::Invert(), kNoTrans, and PackedMatrix< Real >::NumRows().

Referenced by Plda::ApplyTransform(), ComputeLdaTransform(), and PldaEstimator::GetOutput().

                                                                {
  int32 dim = covar.NumRows();
  TpMatrix<Real> C(dim);  // Cholesky of covar, covar = C C^T
  C.Cholesky(covar);
  C.Invert();  // The matrix that makes covar unit is C^{-1}, because
               // C^{-1} covar C^{-T} = C^{-1} C C^T C^{-T} = I.
  proj->CopyFromTp(C, kNoTrans);  // set "proj" to C^{-1}.
}

ComputeNormalizingTransform() [2/2]

void kaldi::ComputeNormalizingTransform	(	const SpMatrix< Real > &	covar,
		Real	floor,
		MatrixBase< Real > *	proj
	)

Definition at line 84 of file ivector-compute-lda.cc.

References MatrixBase< Real >::AddDiagVecMat(), VectorBase< Real >::ApplyFloor(), VectorBase< Real >::ApplyPow(), SpMatrix< Real >::Eig(), KALDI_WARN, kTrans, PackedMatrix< Real >::NumRows(), and SortSvd().

                                                         {
  int32 dim = covar.NumRows();
  Matrix<Real> U(dim, dim);
  Vector<Real> s(dim);
  covar.Eig(&s, &U);
  // Sort eigvenvalues from largest to smallest.
  SortSvd(&s, &U);
  // Floor eigenvalues to a small positive value.
  int32 num_floored;
  floor *= s(0); // Floor relative to the largest eigenvalue
  s.ApplyFloor(floor, &num_floored);
  if (num_floored > 0) {
    KALDI_WARN << "Floored " << num_floored << " eigenvalues of covariance "
               << "to " << floor;
  }
  // Next two lines computes projection proj, such that
  // proj * covar * proj^T = I.
  s.ApplyPow(-0.5);
  proj->AddDiagVecMat(1.0, s, U, kTrans, 0.0);
}

ComputePca() [1/2]

template void kaldi::ComputePca	(	const MatrixBase< float > &	X,
		MatrixBase< float > *	U,
		MatrixBase< float > *	A,
		bool	print_eigs,
		bool	exact
	)

ComputePca() [2/2]

template void kaldi::ComputePca	(	const MatrixBase< double > &	X,
		MatrixBase< double > *	U,
		MatrixBase< double > *	A,
		bool	print_eigs,
		bool	exact
	)

ComputeTreeMapping()

static void kaldi::ComputeTreeMapping ( const EventMap &  small_tree, const EventMap &  big_tree, const BuildTreeStatsType &  stats, std::vector< int32 > *  leaf_map  )

static

Definition at line 320 of file build-tree.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, EventMap::Map(), EventMap::MaxResult(), and SplitStatsByMap().

Referenced by BuildTreeTwoLevel().

                                                           {
  std::vector<BuildTreeStatsType> split_stats_small; // stats split by small tree
  int32 num_leaves_big = big_tree.MaxResult() + 1,
      num_leaves_small = small_tree.MaxResult() + 1;
  SplitStatsByMap(stats, small_tree, &split_stats_small);
  KALDI_ASSERT(static_cast<int32>(split_stats_small.size()) <=
               num_leaves_small);
  leaf_map->clear();
  leaf_map->resize(num_leaves_big, -1); // fill with -1.

  std::vector<int32> small_leaves_unseen; // a list of small leaves that had no stats..
  // this is used as a workaround for when there are no stats at leaves...
  // it's really an error condition and it will cause errors later (e.g. when
  // you initialize your model), but at this point we will try to handle it
  // gracefully.

  for (int32 i = 0; i < num_leaves_small; i++) {
    if (static_cast<size_t>(i) >= split_stats_small.size() ||
        split_stats_small[i].empty()) {
      KALDI_WARN << "No stats mapping to " << i << " in small tree. "
                 << "Continuing but this is a serious error.";
      small_leaves_unseen.push_back(i);
    } else {
      for (size_t j = 0; j < split_stats_small[i].size(); j++) {
        int32 leaf = 0; // = 0 to keep compiler happy.  Leaf in big tree.
        bool ok = big_tree.Map(split_stats_small[i][j].first, &leaf);
        if (!ok)
          KALDI_ERR << "Could not map stats with big tree: probable code error.";
        if (leaf < 0 || leaf >= num_leaves_big)
          KALDI_ERR << "Leaf out of range: " << leaf << " vs. " << num_leaves_big;
        if ((*leaf_map)[leaf] != -1 && (*leaf_map)[leaf] != i)
          KALDI_ERR << "Inconsistent mapping for big tree: "
                    << i << " vs. " << (*leaf_map)[leaf];
        (*leaf_map)[leaf] = i;
      }
    }
  }
  // Now make sure that all leaves in the big tree have a leaf in the small tree
  // assigned to them.  If not we try to clean up... this should never normally
  // happen and if it does it's due to trying to assign tree roots to unseen phones,
  // which will anyway cause an error in a later stage of system building.
  for (int32 leaf = 0; leaf < num_leaves_big; leaf++) {
    int32 small_leaf = (*leaf_map)[leaf];
    if (small_leaf == -1) {
      KALDI_WARN << "In ComputeTreeMapping, could not get mapping from leaf "
                 << leaf;
      if (!small_leaves_unseen.empty()) {
        small_leaf = small_leaves_unseen.back();
        KALDI_WARN << "Assigning it to unseen small-tree leaf " << small_leaf;
        small_leaves_unseen.pop_back();
        (*leaf_map)[leaf] = small_leaf;
      } else {
        KALDI_WARN << "Could not find any unseen small-tree leaf to assign "
                   << "it to.  Making it zero, but this is bad. ";
        (*leaf_map)[leaf] = 0;
      }
    } else if (small_leaf < 0 || small_leaf >= num_leaves_small)
      KALDI_ERR << "Leaf in leaf mapping out of range: for big-map leaf "
                << leaf << ", mapped to " << small_leaf << ", vs. "
                << num_leaves_small;
  }
}

ComputeVadEnergy()

void ComputeVadEnergy	(	const VadEnergyOptions &	opts,
		const MatrixBase< BaseFloat > &	input_features,
		Vector< BaseFloat > *	output_voiced
	)

Compute voice-activity vector for a file: 1 if we judge the frame as voiced, 0 otherwise.

There are no continuity constraints. This method is a very simple energy-based method which only looks at the first coefficient of "input_features", which is assumed to be a log-energy or something similar. A cutoff is set– we use a formula of the general type: cutoff = 5.0 + 0.5 * (average log-energy in this file), and for each frame the decision is based on the proportion of frames in a context window around the current frame, which are above this cutoff.

Definition at line 27 of file voice-activity-detection.cc.

References VectorBase< Real >::CopyColFromMat(), VectorBase< Real >::Data(), KALDI_ASSERT, KALDI_WARN, MatrixBase< Real >::NumRows(), Vector< Real >::Resize(), VectorBase< Real >::Sum(), VadEnergyOptions::vad_energy_mean_scale, VadEnergyOptions::vad_energy_threshold, VadEnergyOptions::vad_frames_context, and VadEnergyOptions::vad_proportion_threshold.

Referenced by main(), and VadEnergyOptions::Register().

                                                        {
  int32 T = feats.NumRows();
  output_voiced->Resize(T);
  if (T == 0) {
    KALDI_WARN << "Empty features";
    return;
  }
  Vector<BaseFloat> log_energy(T);
  log_energy.CopyColFromMat(feats, 0); // column zero is log-energy.
  
  BaseFloat energy_threshold = opts.vad_energy_threshold;
  if (opts.vad_energy_mean_scale != 0.0) {
    KALDI_ASSERT(opts.vad_energy_mean_scale > 0.0);
    energy_threshold += opts.vad_energy_mean_scale * log_energy.Sum() / T;
  }
  
  KALDI_ASSERT(opts.vad_frames_context >= 0);
  KALDI_ASSERT(opts.vad_proportion_threshold > 0.0 &&
               opts.vad_proportion_threshold < 1.0);
  for (int32 t = 0; t < T; t++) {
    const BaseFloat *log_energy_data = log_energy.Data();
    int32 num_count = 0, den_count = 0, context = opts.vad_frames_context;
    for (int32 t2 = t - context; t2 <= t + context; t2++) {
      if (t2 >= 0 && t2 < T) {
        den_count++;
        if (log_energy_data[t2] > energy_threshold)
          num_count++;
      }
    }
    if (num_count >= den_count * opts.vad_proportion_threshold)
      (*output_voiced)(t) = 1.0;
    else
      (*output_voiced)(t) = 0.0;
  }
}  

ConcatFeats()

void kaldi::ConcatFeats	(	const std::vector< Matrix< BaseFloat > > &	in,
		Matrix< BaseFloat > *	out
	)

Definition at line 35 of file concat-feats.cc.

References rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::Range(), and Matrix< Real >::Resize().

Referenced by main().

                                         {
  KALDI_ASSERT(in.size() >= 1);
  int32 tot_len = in[0].NumRows(),
      dim = in[0].NumCols();
  for (int32 i = 1; i < in.size(); i++) {
    KALDI_ASSERT(in[i].NumCols() == dim);
    tot_len += in[i].NumRows();
  }
  out->Resize(tot_len, dim);
  int32 len_offset = 0;
  for (int32 i = 0; i < in.size(); i++) {
    int32 this_len = in[i].NumRows();
    out->Range(len_offset, this_len, 0, dim).CopyFromMat(
        in[i]);
    len_offset += this_len;
  }
}

ContainsNullPointers()

bool kaldi::ContainsNullPointers

(

const std::vector< A *> &

v

)

Returns true if the vector of pointers contains NULL pointers.

Definition at line 197 of file stl-utils.h.

Referenced by ClusterBottomUp(), ClusterBottomUpCompartmentalized(), ClusterKMeans(), RefineClusters(), TestContainsNullPointers(), and TreeCluster().

                                                  {
  typename std::vector<A*>::const_iterator iter = v.begin(), end = v.end();
  for (; iter != end; ++iter)
    if (*iter == static_cast<A*> (NULL)) return true;
  return false;
}

ConvertAddShiftComponent()

nnet2::Component* kaldi::ConvertAddShiftComponent

(

const nnet1::Component &

nnet1_component

)

Definition at line 99 of file nnet1-to-raw-nnet.cc.

References AddShift::GetParams(), FixedBiasComponent::Init(), KALDI_ASSERT, and AddShift::NumParams().

Referenced by ConvertComponent().

                                           {
  const nnet1::AddShift *add_shift =
      dynamic_cast<const nnet1::AddShift*>(&nnet1_component);
  KALDI_ASSERT(add_shift != NULL);
  Vector<BaseFloat> bias(add_shift->NumParams());

  add_shift->GetParams(&bias);
  CuVector<BaseFloat> cu_bias(bias);

  nnet2::FixedBiasComponent *res = new nnet2::FixedBiasComponent();
  res->Init(cu_bias);
  return res;
}

ConvertAffineTransformComponent()

nnet2::Component* kaldi::ConvertAffineTransformComponent	(	const nnet1::Component &	nnet1_component,
		const bool	use_preconditioned_affine_component
	)

Definition at line 32 of file nnet1-to-raw-nnet.cc.

References AffineTransform::GetBias(), AffineTransform::GetLinearity(), and KALDI_ASSERT.

Referenced by ConvertComponent().

                                                    {
  const nnet1::AffineTransform *affine =
      dynamic_cast<const nnet1::AffineTransform*>(&nnet1_component);
  KALDI_ASSERT(affine != NULL);
  // default learning rate is 1.0e-05, you can use the --learning-rate or
  // --learning-rates option to nnet-am-copy to change it if you need.
  BaseFloat learning_rate = 1.0e-05;
  if (use_preconditioned_affine_component) {
    int32 rank_in = 20,
          rank_out = 80,
          update_period = 4;
    BaseFloat num_samples_history = 2000.,
              alpha = 4.;
    return new nnet2::AffineComponentPreconditionedOnline(
      nnet2::AffineComponent(affine->GetLinearity(),
        affine->GetBias(),
        learning_rate),
      rank_in,
      rank_out,
      update_period,
      num_samples_history,
      alpha);
  } else {
    return new nnet2::AffineComponent(affine->GetLinearity(),
      affine->GetBias(),
      learning_rate);
  }
}

ConvertAlignmentForPhone()

static void kaldi::ConvertAlignmentForPhone ( const TransitionModel &  old_trans_model, const TransitionModel &  new_trans_model, const ContextDependencyInterface &  new_ctx_dep, const std::vector< int32 > &  old_phone_alignment, const std::vector< int32 > &  new_phone_window, bool  old_is_reordered, bool  new_is_reordered, std::vector< int32 > *  new_phone_alignment  )

inlinestatic

This function is used internally inside ConvertAlignment; it converts the alignment for a single phone.

'new_phone_window' is the window of phones as required by the tree. The size of 'new_phone_alignment' is the length requested, which may not always equal 'old_phone_alignment' (in case the 'subsample' value is not 1).

Definition at line 742 of file hmm-utils.cc.

References ContextDependencyInterface::CentralPosition(), ChangeReorderingOfAlignment(), ContextDependencyInterface::Compute(), GetRandomAlignmentForPhone(), TransitionModel::GetTopo(), rnnlm::j, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, TransitionModel::PairToTransitionId(), HmmTopology::TopologyForPhone(), TransitionModel::TransitionIdToHmmState(), TransitionModel::TransitionIdToPhone(), TransitionModel::TransitionIdToTransitionIndex(), TransitionModel::TransitionIdToTransitionState(), TransitionModel::TransitionStateToForwardPdfClass(), TransitionModel::TransitionStateToSelfLoopPdfClass(), TransitionModel::TupleToTransitionState(), and WriteIntegerVector().

Referenced by ConvertAlignmentInternal().

                                           {
  int32 alignment_size = old_phone_alignment.size();
  static bool warned_topology = false;
  int32 P = new_ctx_dep.CentralPosition(),
      old_central_phone = old_trans_model.TransitionIdToPhone(
          old_phone_alignment[0]),
      new_central_phone = new_phone_window[P];
  const HmmTopology &old_topo = old_trans_model.GetTopo(),
      &new_topo = new_trans_model.GetTopo();

  bool topology_mismatch = !(old_topo.TopologyForPhone(old_central_phone) ==
                             new_topo.TopologyForPhone(new_central_phone));
  if (topology_mismatch) {
    if (!warned_topology) {
      warned_topology = true;
      KALDI_WARN << "Topology mismatch detected; automatically converting. "
                 << "Won't warn again.";
    }
  }
  bool length_mismatch =
      (new_phone_alignment->size() != old_phone_alignment.size());
  if (length_mismatch || topology_mismatch) {
    // We generate a random path from this FST, ignoring the
    // old alignment.
    GetRandomAlignmentForPhone(new_ctx_dep, new_trans_model,
                               new_phone_window, new_phone_alignment);
    if (new_is_reordered)
      ChangeReorderingOfAlignment(new_trans_model, new_phone_alignment);
    return;
  }

  KALDI_ASSERT(!old_phone_alignment.empty());

  int32 new_num_pdf_classes = new_topo.NumPdfClasses(new_central_phone);
  std::vector<int32> pdf_ids(new_num_pdf_classes);  // Indexed by pdf-class
  for (int32 pdf_class = 0; pdf_class < new_num_pdf_classes; pdf_class++) {
    if (!new_ctx_dep.Compute(new_phone_window, pdf_class,
                             &(pdf_ids[pdf_class]))) {
      std::ostringstream ss;
      WriteIntegerVector(ss, false, new_phone_window);
      KALDI_ERR << "tree did not succeed in converting phone window "
                << ss.str();
    }
  }

  // the topologies and lengths match -> we can directly transfer
  // the alignment.
  for (int32 j = 0; j < alignment_size; j++) {
    int32 old_tid = old_phone_alignment[j],
        old_tstate = old_trans_model.TransitionIdToTransitionState(old_tid);
    int32 forward_pdf_class =
        old_trans_model.TransitionStateToForwardPdfClass(old_tstate),
        self_loop_pdf_class =
        old_trans_model.TransitionStateToSelfLoopPdfClass(old_tstate);
    int32 hmm_state = old_trans_model.TransitionIdToHmmState(old_tid);
    int32 trans_idx = old_trans_model.TransitionIdToTransitionIndex(old_tid);
    int32 new_forward_pdf = pdf_ids[forward_pdf_class];
    int32 new_self_loop_pdf = pdf_ids[self_loop_pdf_class];
    int32 new_trans_state =
        new_trans_model.TupleToTransitionState(new_central_phone, hmm_state,
                                               new_forward_pdf, new_self_loop_pdf);
    int32 new_tid =
        new_trans_model.PairToTransitionId(new_trans_state, trans_idx);
    (*new_phone_alignment)[j] = new_tid;
  }

  if (new_is_reordered != old_is_reordered)
    ChangeReorderingOfAlignment(new_trans_model, new_phone_alignment);
}

ConvertAlignmentInternal()

static bool kaldi::ConvertAlignmentInternal ( const TransitionModel &  old_trans_model, const TransitionModel &  new_trans_model, const ContextDependencyInterface &  new_ctx_dep, const std::vector< int32 > &  old_alignment, int32  conversion_shift, int32  subsample_factor, bool  new_is_reordered, const std::vector< int32 > *  phone_map, std::vector< int32 > *  new_alignment  )

static

This function is the same as 'ConvertAligment', but instead of the 'repeat_frames' option it supports the 'conversion_shift' option; see the documentation of ComputeNewPhoneLengths() for what 'conversion_shift' is for.

Definition at line 926 of file hmm-utils.cc.

References ContextDependencyInterface::CentralPosition(), ComputeNewPhoneLengths(), ContextDependencyInterface::ContextWidth(), ConvertAlignmentForPhone(), TransitionModel::GetTopo(), rnnlm::i, IsReordered(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, SplitToPhones(), and TransitionModel::TransitionIdToPhone().

Referenced by ConvertAlignment().

                                                       {
  KALDI_ASSERT(0 <= conversion_shift && conversion_shift < subsample_factor);
  bool old_is_reordered = IsReordered(old_trans_model, old_alignment);
  KALDI_ASSERT(new_alignment != NULL);
  new_alignment->clear();
  new_alignment->reserve(old_alignment.size());
  std::vector<std::vector<int32> > old_split;  // split into phones.
  if (!SplitToPhones(old_trans_model, old_alignment, &old_split))
    return false;
  int32 phone_sequence_length = old_split.size();
  std::vector<int32> mapped_phones(phone_sequence_length);
  for (size_t i = 0; i < phone_sequence_length; i++) {
    KALDI_ASSERT(!old_split[i].empty());
    mapped_phones[i] = old_trans_model.TransitionIdToPhone(old_split[i][0]);
    if (phone_map != NULL) {  // Map the phone sequence.
      int32 sz = phone_map->size();
      if (mapped_phones[i] < 0 || mapped_phones[i] >= sz ||
          (*phone_map)[mapped_phones[i]] == -1)
        KALDI_ERR << "ConvertAlignment: could not map phone " << mapped_phones[i];
      mapped_phones[i] = (*phone_map)[mapped_phones[i]];
    }
  }

  // the sizes of each element of 'new_split' indicate the length of alignment
  // that we want for each phone in the new sequence.
  std::vector<std::vector<int32> > new_split(phone_sequence_length);
  if (subsample_factor == 1 &&
      old_trans_model.GetTopo() == new_trans_model.GetTopo()) {
    // we know the old phone lengths will be fine.
    for (size_t i = 0; i < phone_sequence_length; i++)
      new_split[i].resize(old_split[i].size());
  } else {
    // .. they may not be fine.
    std::vector<int32> old_lengths(phone_sequence_length), new_lengths;
    for (int32 i = 0; i < phone_sequence_length; i++)
      old_lengths[i] = old_split[i].size();
    if (!ComputeNewPhoneLengths(new_trans_model.GetTopo(),
                                mapped_phones, old_lengths, conversion_shift,
                                subsample_factor, &new_lengths)) {
      KALDI_WARN << "Failed to produce suitable phone lengths";
      return false;
    }
    for (int32 i = 0; i < phone_sequence_length; i++)
      new_split[i].resize(new_lengths[i]);
  }

  int32 N = new_ctx_dep.ContextWidth(),
      P = new_ctx_dep.CentralPosition();

  // by starting at -N and going to phone_sequence_length + N, we're
  // being generous and not bothering to work out the exact
  // array bounds.
  for (int32 win_start = -N;
       win_start < static_cast<int32>(phone_sequence_length + N);
       win_start++) {  // start of a context window.
    int32 central_pos = win_start + P;
    if (static_cast<size_t>(central_pos) < phone_sequence_length) {
      // i.e. if (central_pos >= 0 && central_pos < phone_sequence_length)
      std::vector<int32> new_phone_window(N, 0);
      for (int32 offset = 0; offset < N; offset++)
        if (static_cast<size_t>(win_start+offset) < phone_sequence_length)
          new_phone_window[offset] = mapped_phones[win_start+offset];
      const std::vector<int32> &old_alignment_for_phone = old_split[central_pos];
      std::vector<int32> &new_alignment_for_phone = new_split[central_pos];

      ConvertAlignmentForPhone(old_trans_model, new_trans_model, new_ctx_dep,
                               old_alignment_for_phone, new_phone_window,
                               old_is_reordered, new_is_reordered,
                               &new_alignment_for_phone);
      new_alignment->insert(new_alignment->end(),
                            new_alignment_for_phone.begin(),
                            new_alignment_for_phone.end());
    }
  }
  KALDI_ASSERT(new_alignment->size() ==
               (old_alignment.size() + conversion_shift)/subsample_factor);
  return true;
}

ConvertCompactLatticeToPhones()

void ConvertCompactLatticeToPhones	(	const TransitionModel &	trans_model,
		CompactLattice *	clat
	)

Given a lattice, and a transition model to map pdf-ids to phones, replace the sequences of transition-ids with sequences of phones.

Note that this is different from ConvertLatticeToPhones, in that we replace the transition-ids not the words.

Definition at line 700 of file lattice-functions.cc.

References TransitionModel::IsFinal(), and TransitionModel::TransitionIdToPhone().

Referenced by main().

                                                         {
  typedef CompactLatticeArc Arc;
  typedef Arc::Weight Weight;
  int32 num_states = clat->NumStates();
  for (int32 state = 0; state < num_states; state++) {
    for (fst::MutableArcIterator<CompactLattice> aiter(clat, state);
         !aiter.Done();
         aiter.Next()) {
      Arc arc(aiter.Value());
      std::vector<int32> phone_seq;
      const std::vector<int32> &tid_seq = arc.weight.String();
      for (std::vector<int32>::const_iterator iter = tid_seq.begin();
           iter != tid_seq.end(); ++iter) {
        if (trans.IsFinal(*iter))// note: there is one of these per phone...
          phone_seq.push_back(trans.TransitionIdToPhone(*iter));
      }
      arc.weight.SetString(phone_seq);
      aiter.SetValue(arc);
    } // end looping over arcs
    Weight f = clat->Final(state);
    if (f != Weight::Zero()) {
      std::vector<int32> phone_seq;
      const std::vector<int32> &tid_seq = f.String();
      for (std::vector<int32>::const_iterator iter = tid_seq.begin();
           iter != tid_seq.end(); ++iter) {
        if (trans.IsFinal(*iter))// note: there is one of these per phone...
          phone_seq.push_back(trans.TransitionIdToPhone(*iter));
      }
      f.SetString(phone_seq);
      clat->SetFinal(state, f);
    }
  }  // end looping over states
}

ConvertComponent()

nnet2::Component* kaldi::ConvertComponent	(	const nnet1::Component &	nnet1_component,
		const bool	use_preconditioned_affine_component
	)

Definition at line 130 of file nnet1-to-raw-nnet.cc.

References ConvertAddShiftComponent(), ConvertAffineTransformComponent(), ConvertRescaleComponent(), ConvertSigmoidComponent(), ConvertSoftmaxComponent(), ConvertSpliceComponent(), Component::GetType(), Component::kAddShift, Component::kAffineTransform, KALDI_ERR, Component::kRescale, Component::kSigmoid, Component::kSoftmax, Component::kSplice, and Component::TypeToMarker().

Referenced by ConvertNnet1ToNnet2().

                                                    {
  nnet1::Component::ComponentType type_in = nnet1_component.GetType();
  switch (type_in) {
    case nnet1::Component::kAffineTransform:
      return ConvertAffineTransformComponent(nnet1_component,
          use_preconditioned_affine_component);
    case nnet1::Component::kSoftmax:
      return ConvertSoftmaxComponent(nnet1_component);
    case nnet1::Component::kSigmoid:
      return ConvertSigmoidComponent(nnet1_component);
    case nnet1::Component::kSplice:
      return ConvertSpliceComponent(nnet1_component); // note, this will for now only handle the
      // special case nnet1::Component::where all splice indexes in nnet1_component are contiguous, e.g.
      // -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 .
    case nnet1::Component::kAddShift:
      return ConvertAddShiftComponent(nnet1_component); // convert to FixedBiasComponent
    case nnet1::Component::kRescale:
      return ConvertRescaleComponent(nnet1_component); // convert to FixedScaleComponent
    default: KALDI_ERR << "Un-handled nnet1 component type "
                       << nnet1::Component::TypeToMarker(type_in);
    return NULL;
  }
}

ConvertIntToString()

std::string kaldi::ConvertIntToString

(

const int &

number

)

Definition at line 38 of file pitch-functions-test.cc.

Referenced by UnitTestComputeGPE(), UnitTestDiffSampleRate(), UnitTestKeele(), UnitTestKeeleNccfBallast(), UnitTestPenaltyFactor(), UnitTestPitchExtractionSpeed(), UnitTestPitchExtractorCompareKeele(), and UnitTestProcess().

                                                {
  std::stringstream ss;  // create a stringstream
  ss << number;  // add number to the stream
  return ss.str();  // return a string with the contents of the stream
}

ConvertLatticeToPhones()

void ConvertLatticeToPhones	(	const TransitionModel &	trans_model,
		Lattice *	lat
	)

Given a lattice, and a transition model to map pdf-ids to phones, replace the output symbols (presumably words), with phones; we use the TransitionModel to work out the phone sequence.

Note that the phone labels are not exactly aligned with the phone boundaries. We put a phone label to coincide with any transition to the final, nonemitting state of a phone (this state always exists, we ensure this in HmmTopology::Check()). This would be the last transition-id in the phone if reordering is not done (but typically we do reorder). Also see PhoneAlignLattice, in phone-align-lattice.h.

Definition at line 423 of file lattice-functions.cc.

References TransitionModel::IsSelfLoop(), TransitionModel::TransitionIdToHmmState(), and TransitionModel::TransitionIdToPhone().

Referenced by main().

                                          {
  typedef LatticeArc Arc;
  int32 num_states = lat->NumStates();
  for (int32 state = 0; state < num_states; state++) {
    for (fst::MutableArcIterator<Lattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      Arc arc(aiter.Value());
      arc.olabel = 0; // remove any word.
      if ((arc.ilabel != 0) // has a transition-id on input..
          && (trans.TransitionIdToHmmState(arc.ilabel) == 0)
          && (!trans.IsSelfLoop(arc.ilabel))) {
         // && trans.IsFinal(arc.ilabel)) // there is one of these per phone...
        arc.olabel = trans.TransitionIdToPhone(arc.ilabel);
      }
      aiter.SetValue(arc);
    }  // end looping over arcs
  }  // end looping over states
}

ConvertLatticeToUnweightedAcceptor()

void kaldi::ConvertLatticeToUnweightedAcceptor	(	const kaldi::Lattice &	ilat,
		const LabelPairVector &	wildcards,
		fst::StdVectorFst *	ofst
	)

Definition at line 63 of file lattice-oracle.cc.

References fst::ConvertLattice().

Referenced by main().

                                                               {
  // first convert from  lattice to normal FST
  fst::ConvertLattice(ilat, ofst);
  // remove weights, project to output, sort according to input arg
  fst::Map(ofst, fst::RmWeightMapper<fst::StdArc>());
  fst::Project(ofst, fst::PROJECT_OUTPUT);  // The words are on the output side
  fst::Relabel(ofst, wildcards, wildcards);
  fst::RmEpsilon(ofst);   // Don't tolerate epsilons as they make it hard to
                          // tally errors
  fst::ArcSort(ofst, fst::StdILabelCompare());
}

ConvertNnet1ToNnet2()

nnet2::Nnet* kaldi::ConvertNnet1ToNnet2	(	const nnet1::Nnet &	nnet1,
		const bool	use_preconditioned_affine_component
	)

Definition at line 156 of file nnet1-to-raw-nnet.cc.

References ConvertComponent(), Nnet::GetComponent(), rnnlm::i, and Nnet::NumComponents().

Referenced by main().

                                                    {
  // get a vector of nnet2::Component pointers and initialize the nnet2::Nnet with it.
  size_t size = nnet1.NumComponents();
  std::vector<nnet2::Component*> *components = new std::vector<nnet2::Component*>();
  components->resize(size);
  for (size_t i = 0; i < size; i++) {
      (*components)[i] = ConvertComponent(nnet1.GetComponent(i),
          use_preconditioned_affine_component);
  }

  nnet2::Nnet *res = new nnet2::Nnet();
  res->Init(components);
  delete components;
  return res;
}

ConvertPostToGaussInfo()

static void kaldi::ConvertPostToGaussInfo ( const std::vector< std::vector< std::pair< int32, BaseFloat > > > &  gauss_post, std::unordered_map< int32, GaussInfo > *  gauss_info  )

static

Definition at line 594 of file ivector-extractor.cc.

References GaussInfo::frame_weights, and GaussInfo::tot_weight.

Referenced by OnlineIvectorEstimationStats::AccStats().

                                                    {
  int32 num_frames = gauss_post.size();
  for (int32 t = 0; t < num_frames; t++) {
    const std::vector<std::pair<int32, BaseFloat> > &this_post = gauss_post[t];
    auto iter = this_post.begin(), end = this_post.end();
    for (; iter != end; ++iter) {
      int32 gauss_idx = iter->first;
      GaussInfo &info = (*gauss_info)[gauss_idx];
      BaseFloat weight = iter->second;
      info.tot_weight += weight;
      info.frame_weights.push_back(std::pair<int32, BaseFloat>(t, weight));
    }
  }
}

ConvertRescaleComponent()

nnet2::Component* kaldi::ConvertRescaleComponent

(

const nnet1::Component &

nnet1_component

)

Definition at line 114 of file nnet1-to-raw-nnet.cc.

References Rescale::GetParams(), FixedScaleComponent::Init(), KALDI_ASSERT, and Rescale::NumParams().

Referenced by ConvertComponent().

                                           {
  const nnet1::Rescale *rescale =
      dynamic_cast<const nnet1::Rescale*>(&nnet1_component);
  KALDI_ASSERT(rescale != NULL);

  Vector<BaseFloat> scale(rescale->NumParams());
  rescale->GetParams(&scale);

  CuVector<BaseFloat> cu_scale(scale);

  nnet2::FixedScaleComponent *res = new nnet2::FixedScaleComponent();
  res->Init(cu_scale);
  return res;
}

ConvertSigmoidComponent()

nnet2::Component* kaldi::ConvertSigmoidComponent

(

const nnet1::Component &

nnet1_component

)

Definition at line 71 of file nnet1-to-raw-nnet.cc.

References Component::InputDim(), and KALDI_ASSERT.

Referenced by ConvertComponent().

                                           {
  const nnet1::Sigmoid *sigmoid =
      dynamic_cast<const nnet1::Sigmoid*>(&nnet1_component);
  KALDI_ASSERT(sigmoid != NULL);
  return new nnet2::SigmoidComponent(sigmoid->InputDim());
}

ConvertSoftmaxComponent()

nnet2::Component* kaldi::ConvertSoftmaxComponent

(

const nnet1::Component &

nnet1_component

)

Definition at line 63 of file nnet1-to-raw-nnet.cc.

References Component::InputDim(), and KALDI_ASSERT.

Referenced by ConvertComponent().

                                           {
  const nnet1::Softmax *softmax =
      dynamic_cast<const nnet1::Softmax*>(&nnet1_component);
  KALDI_ASSERT(softmax != NULL);
  return new nnet2::SoftmaxComponent(softmax->InputDim());
}

ConvertSpliceComponent()

nnet2::Component* kaldi::ConvertSpliceComponent

(

const nnet1::Component &

nnet1_component

)

Definition at line 79 of file nnet1-to-raw-nnet.cc.

References SpliceComponent::Init(), Component::InputDim(), KALDI_ASSERT, ReadIntegerVector(), and Splice::WriteData().

Referenced by ConvertComponent().

                                           {
  const nnet1::Splice *splice =
      dynamic_cast<const nnet1::Splice*>(&nnet1_component);
  KALDI_ASSERT(splice != NULL);
//  int32 low, high;
  std::vector<int32> frame_offsets;

  std::ostringstream ostr;
  splice->WriteData(ostr, false);

  std::istringstream istr(ostr.str());
  ReadIntegerVector(istr, false, &frame_offsets);

  nnet2::SpliceComponent *res = new nnet2::SpliceComponent();
  res->Init(splice->InputDim(), frame_offsets);
  return res;
}

ConvertStringToInteger()

bool kaldi::ConvertStringToInteger	(	const std::string &	str,
		Int *	out
	)

Converts a string into an integer via strtoll and returns false if there was any kind of problem (i.e.

the string was not an integer or contained extra non-whitespace junk, or the integer was too large to fit into the type it is being converted into). Only sets *out if everything was OK and it returns true.

Definition at line 118 of file text-utils.h.

References ConvertStringToReal(), rnnlm::i, IsLine(), IsToken(), KALDI_ASSERT_IS_INTEGER_TYPE, KALDI_STRTOLL, SplitStringOnFirstSpace(), StringsApproxEqual(), and Trim().

Referenced by ExampleMergingConfig::ComputeDerived(), ConfigLine::GetValue(), WordBoundaryInfo::Init(), MultiTaskLoss::InitFromString(), main(), GeneralDescriptor::ParseConst(), kaldi::nnet2::ParseFromString(), kaldi::nnet3::ProcessRangeFile(), ArpaFileParser::Read(), HmmTopology::Read(), fst::ReadFstKaldi(), kaldi::nnet3::ReadIntegerToken(), ReadPosterior(), LatticeReader::ReadText(), kaldi::nnet3::SelectFromExample(), Fmpe::SetContexts(), OffsetFileInputImpl::SplitFilename(), TestConvertStringToInteger(), ParseOptions::ToInt(), and ParseOptions::ToUint().

                                      {
  KALDI_ASSERT_IS_INTEGER_TYPE(Int);
  const char *this_str = str.c_str();
  char *end = NULL;
  errno = 0;
  int64 i = KALDI_STRTOLL(this_str, &end);
  if (end != this_str)
    while (isspace(*end)) end++;
  if (end == this_str || *end != '\0' || errno != 0)
    return false;
  Int iInt = static_cast<Int>(i);
  if (static_cast<int64>(iInt) != i ||
      (i < 0 && !std::numeric_limits<Int>::is_signed)) {
    return false;
  }
  *out = iInt;
  return true;
}

ConvertStringToReal() [1/3]

bool ConvertStringToReal	(	const std::string &	str,
		T *	out
	)

ConvertStringToReal converts a string into either float or double and returns false if there was any kind of problem (i.e.

the string was not a floating point number or contained extra non-whitespace junk). Be careful- this function will successfully read inf's or nan's.

Definition at line 238 of file text-utils.cc.

References rnnlm::i.

Referenced by ConvertStringToInteger(), kaldi::nnet3::DescriptorTokenize(), ConfigLine::GetValue(), MultiTaskLoss::InitFromString(), main(), GeneralDescriptor::ParseConst(), kaldi::nnet2::ParseFromString(), GeneralDescriptor::ParseScale(), ArpaFileParser::Read(), ReadCommaSeparatedCommand(), Fmpe::SetContexts(), SplitStringToFloats(), TestConvertStringToReal(), TestInf(), TestNan(), ParseOptions::ToDouble(), and ParseOptions::ToFloat().

                                 {
  std::istringstream iss(str);

  NumberIstream<T> i(iss);

  i >> *out;

  if (iss.fail()) {
    // Number conversion failed.
    return false;
  }

  return true;
}

ConvertStringToReal() [2/3]

template bool kaldi::ConvertStringToReal	(	const std::string &	str,
		float *	out
	)

ConvertStringToReal() [3/3]

template bool kaldi::ConvertStringToReal	(	const std::string &	str,
		double *	out
	)

ConvertToCompactLattice() [1/2]

CompactLattice* kaldi::ConvertToCompactLattice

(

fst::VectorFst< OrigWeightType > *

ifst

)

Converts lattice types if necessary, deleting its input.

Definition at line 29 of file kaldi-lattice.cc.

References fst::ConvertLattice().

Referenced by ReadCompactLattice(), and ReadCompactLatticeText().

                                                                            {
  if (!ifst) return NULL;
  CompactLattice *ofst = new CompactLattice();
  ConvertLattice(*ifst, ofst);
  delete ifst;
  return ofst;
}

ConvertToCompactLattice() [2/2]

CompactLattice* kaldi::ConvertToCompactLattice

(

CompactLattice *

ifst

)

Definition at line 40 of file kaldi-lattice.cc.

                                                              {
  return ifst;
}

ConvertToLattice() [1/2]

Lattice* kaldi::ConvertToLattice

(

fst::VectorFst< OrigWeightType > *

ifst

)

Converts lattice types if necessary, deleting its input.

Definition at line 46 of file kaldi-lattice.cc.

References fst::ConvertLattice().

Referenced by ReadLattice(), and ReadLatticeText().

                                                              {
  if (!ifst) return NULL;
  Lattice *ofst = new Lattice();
  ConvertLattice(*ifst, ofst);
  delete ifst;
  return ofst;
}

ConvertToLattice() [2/2]

Lattice* kaldi::ConvertToLattice

(

Lattice *

ifst

)

Definition at line 57 of file kaldi-lattice.cc.

                                         {
  return ifst;
}

ConvolveSignals()

void ConvolveSignals	(	const Vector< BaseFloat > &	filter,
		Vector< BaseFloat > *	signal
	)

Definition at line 34 of file signal.cc.

References VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), rnnlm::i, rnnlm::j, Vector< Real >::Resize(), and VectorBase< Real >::SetZero().

Referenced by UnitTestFFTbasedConvolution().

                                                                                 {
  int32 signal_length = signal->Dim();
  int32 filter_length = filter.Dim();
  int32 output_length = signal_length + filter_length - 1;
  Vector<BaseFloat> signal_padded(output_length);
  signal_padded.SetZero();
  for (int32 i = 0; i < signal_length; i++) {
    for (int32 j = 0; j < filter_length; j++) {
        signal_padded(i + j) += (*signal)(i) * filter(j);
    }
  }
  signal->Resize(output_length);
  signal->CopyFromVec(signal_padded);
}

CopyMapKeysToSet()

void kaldi::CopyMapKeysToSet	(	const std::map< A, B > &	m,
		std::set< A > *	s
	)

Copies the keys in a map to a set.

Definition at line 150 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by TestCopyMapKeysToSet(), and TestFindAllKeys().

                                                           {
  KALDI_ASSERT(s != NULL);
  s->clear();
  typename std::map<A, B>::const_iterator miter = m.begin(), mend = m.end();
  for (; miter != mend; ++miter) {
    s->insert(s->end(), miter->first);
  }
}

CopyMapKeysToVector()

void kaldi::CopyMapKeysToVector	(	const std::map< A, B > &	m,
		std::vector< A > *	v
	)

Copies the keys in a map to a vector.

Definition at line 126 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by Questions::GetKeysWithQuestions(), TestCopyMapKeysToSet(), and TestCopyMapKeysToVector().

                                                                 {
  KALDI_ASSERT(v != NULL);
  v->resize(m.size());
  typename std::map<A, B>::const_iterator miter = m.begin(), mend = m.end();
  typename std::vector<A>::iterator viter = v->begin();
  for (; miter != mend; ++miter, ++viter) {
    *viter = miter->first;
  }
}

CopyMapToVector()

void kaldi::CopyMapToVector	(	const std::map< A, B > &	m,
		std::vector< std::pair< A, B > > *	v
	)

Copies the (key, value) pairs in a map to a vector of pairs.

Definition at line 112 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by GenRandStats(), TestCopyMapToVector(), TestFindAllKeys(), and TestPossibleValues().

                                                   {
  KALDI_ASSERT(v != NULL);
  v->resize(m.size());
  typename std::map<A, B>::const_iterator miter = m.begin(), mend = m.end();
  typename std::vector<std::pair<A, B> >::iterator viter = v->begin();
  for (; miter != mend; ++miter, ++viter) {
    *viter = std::make_pair(miter->first, miter->second);
    // do it like this because of const casting.
  }
}

CopyMapValuesToSet()

void kaldi::CopyMapValuesToSet	(	const std::map< A, B > &	m,
		std::set< B > *	s
	)

Copies the values in a map to a set.

Definition at line 161 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by TestCopyMapValuesToSet().

                                                             {
  KALDI_ASSERT(s != NULL);
  s->clear();
  typename std::map<A, B>::const_iterator miter = m.begin(), mend = m.end();
  for (; miter != mend; ++miter)
    s->insert(s->end(), miter->second);
}

CopyMapValuesToVector()

void kaldi::CopyMapValuesToVector	(	const std::map< A, B > &	m,
		std::vector< B > *	v
	)

Copies the values in a map to a vector.

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

References KALDI_ASSERT.

Referenced by TestCopyMapValuesToSet(), and TestCopyMapValuesToVector().

                                                                   {
  KALDI_ASSERT(v != NULL);
  v->resize(m.size());
  typename std::map<A, B>::const_iterator miter = m.begin(), mend = m.end();
  typename std::vector<B>::iterator viter = v->begin();
  for (; miter != mend; ++miter, ++viter) {
    *viter = miter->second;
  }
}

CopySetToVector() [1/2]

void kaldi::CopySetToVector	(	const std::set< T > &	s,
		std::vector< T > *	v
	)

Copies the elements of a set to a vector.

Definition at line 86 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by ConstIntegerSet< EventValueType >::ConstIntegerSet(), fst::GetInputSymbols(), kaldi::nnet3::GetIoNames(), fst::GetOutputSymbols(), GetSeenPhones(), ConstIntegerSet< EventValueType >::Init(), PossibleValues(), RandomEventMap(), TestClusterEventMapRestricted(), fst::TestContextFst(), TestCopySetToVector(), TestEventMapIo(), TestFindAllKeys(), TestGenRandContextDependency(), TestMonophoneContextDependency(), TestPossibleValues(), TestQuestionsInitRand(), TestShareEventMapLeaves(), and TestSplitDecisionTree().

                                                          {
  // copies members of s into v, in sorted order from lowest to highest
  // (because the set was in sorted order).
  KALDI_ASSERT(v != NULL);
  v->resize(s.size());
  typename std::set<T>::const_iterator siter = s.begin(), send = s.end();
  typename std::vector<T>::iterator viter = v->begin();
  for (; siter != send; ++siter, ++viter) {
    *viter = *siter;
  }
}

CopySetToVector() [2/2]

void kaldi::CopySetToVector	(	const unordered_set< T > &	s,
		std::vector< T > *	v
	)

Definition at line 99 of file stl-utils.h.

References KALDI_ASSERT.

                                                                 {
  KALDI_ASSERT(v != NULL);
  v->resize(s.size());
  typename unordered_set<T>::const_iterator siter = s.begin(), send = s.end();
  typename std::vector<T>::iterator viter = v->begin();
  for (; siter != send; ++siter, ++viter) {
    *viter = *siter;
  }
}

CopySubsetLattices() [1/2]

int32 kaldi::CopySubsetLattices	(	std::string	filename,
		SequentialLatticeReader *	lattice_reader,
		LatticeWriter *	lattice_writer,
		bool	include = true,
		bool	ignore_missing = false,
		bool	sorted = false
	)

Definition at line 28 of file lattice-copy.cc.

References SequentialTableReader< Holder >::Done(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), SplitStringToVector(), Input::Stream(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                           {
    unordered_set<std::string, StringHasher> subset;
    std::set<std::string> subset_list;

    bool binary;
    Input ki(filename, &binary);
    KALDI_ASSERT(!binary);
    std::string line;
    while (std::getline(ki.Stream(), line)) {
      std::vector<std::string> split_line;
      SplitStringToVector(line, " \t\r", true, &split_line);
      if(split_line.empty()) {
        KALDI_ERR << "Unable to parse line \"" << line << "\" encountered in input in " << filename;
      }
      subset.insert(split_line[0]);
      subset_list.insert(split_line[0]);
    }

    int32 num_total = 0;
    size_t num_success = 0;
    for (; !lattice_reader->Done(); lattice_reader->Next(), num_total++) {
      if (include && sorted && subset_list.size() > 0
              && lattice_reader->Key() > *(subset_list.rbegin())) {
        KALDI_LOG << "The utterance " << lattice_reader->Key()
                  << " is larger than "
                  << "the last key in the include list. Not reading further.";
        KALDI_LOG << "Wrote " << num_success << " utterances";
        return 0;
      }

      if (include && subset.count(lattice_reader->Key()) > 0) {
        lattice_writer->Write(lattice_reader->Key(), lattice_reader->Value());
        num_success++;
      } else if (!include && subset.count(lattice_reader->Key()) == 0) {
        lattice_writer->Write(lattice_reader->Key(), lattice_reader->Value());
        num_success++;
      }
    }

    KALDI_LOG << "Wrote " << num_success << " out of " << num_total
      << " utterances.";

    if (ignore_missing) return 0;

    return (num_success != 0 ? 0 : 1);
  }

CopySubsetLattices() [2/2]

int32 kaldi::CopySubsetLattices	(	std::string	filename,
		SequentialCompactLatticeReader *	lattice_reader,
		CompactLatticeWriter *	lattice_writer,
		bool	include = true,
		bool	ignore_missing = false,
		bool	sorted = false
	)

Definition at line 79 of file lattice-copy.cc.

References SequentialTableReader< Holder >::Done(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), SplitStringToVector(), Input::Stream(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

                           {
    unordered_set<std::string, StringHasher> subset;
    std::set<std::string> subset_list;

    bool binary;
    Input ki(filename, &binary);
    KALDI_ASSERT(!binary);
    std::string line;
    while (std::getline(ki.Stream(), line)) {
      std::vector<std::string> split_line;
      SplitStringToVector(line, " \t\r", true, &split_line);
      if(split_line.empty()) {
        KALDI_ERR << "Unable to parse line \"" << line << "\" encountered in input in " << filename;
      }
      subset.insert(split_line[0]);
      subset_list.insert(split_line[0]);
    }

    int32 num_total = 0;
    size_t num_success = 0;
    for (; !lattice_reader->Done(); lattice_reader->Next(), num_total++) {
      if (include && sorted && subset_list.size() > 0
              && lattice_reader->Key() > *(subset_list.rbegin())) {
        KALDI_LOG << "The utterance " << lattice_reader->Key()
                  << " is larger than "
                  << "the last key in the include list. Not reading further.";
        KALDI_LOG << "Wrote " << num_success << " utterances";
        return 0;
      }

      if (include && subset.count(lattice_reader->Key()) > 0) {
        lattice_writer->Write(lattice_reader->Key(), lattice_reader->Value());
        num_success++;
      } else if (!include && subset.count(lattice_reader->Key()) == 0) {
        lattice_writer->Write(lattice_reader->Key(), lattice_reader->Value());
        num_success++;
      }
    }

    KALDI_LOG << " Wrote " << num_success << " out of " << num_total
      << " utterances.";

    if (ignore_missing) return 0;

    return (num_success != 0 ? 0 : 1);
  }

CopyVectorToSet()

void kaldi::CopyVectorToSet	(	const std::vector< A > &	v,
		std::set< A > *	s
	)

Copies the contents of a vector to a set.

Definition at line 172 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by kaldi::nnet3::ComputeCommandPairs(), TestCopyMapKeysToSet(), and TestCopyMapValuesToSet().

                                                          {
  KALDI_ASSERT(s != NULL);
  s->clear();
  typename std::vector<A>::const_iterator iter = v.begin(), end = v.end();
  for (; iter != end; ++iter)
    s->insert(s->end(), *iter);
  // s->end() is a hint in case v was sorted.  will work regardless.
}

CopyVectorToVector()

void kaldi::CopyVectorToVector	(	const std::vector< A > &	vec_in,
		std::vector< B > *	vec_out
	)

Copies the contents a vector of one type to a vector of another type.

Definition at line 207 of file stl-utils.h.

References rnnlm::i, and KALDI_ASSERT.

                                                                           {
  KALDI_ASSERT(vec_out != NULL);
  vec_out->resize(vec_in.size());
  for (size_t i = 0; i < vec_in.size(); i++)
    (*vec_out)[i] = static_cast<B> (vec_in[i]);
}

CountErrors()

void kaldi::CountErrors	(	const fst::StdVectorFst &	fst,
		int32 *	correct,
		int32 *	substitutions,
		int32 *	insertions,
		int32 *	deletions,
		int32 *	num_words
	)

Definition at line 114 of file lattice-oracle.cc.

References KALDI_ASSERT.

Referenced by main().

                                   {
  typedef fst::StdArc::StateId StateId;
  typedef fst::StdArc::Weight Weight;
  *correct = *substitutions = *insertions = *deletions = *num_words = 0;

  // go through the first complete path in fst (there should be only one)
  StateId src = fst.Start();
  while (fst.Final(src)== Weight::Zero()) {  // while not final
    for (fst::ArcIterator<fst::StdVectorFst> aiter(fst, src);
         !aiter.Done(); aiter.Next()) {
      fst::StdArc arc = aiter.Value();
      if (arc.ilabel == arc.olabel && arc.ilabel != 0) {
        (*correct)++;
        (*num_words)++;
      } else if (arc.ilabel == 0 && arc.olabel != 0) {
        (*deletions)++;
        (*num_words)++;
      } else if (arc.ilabel != 0 && arc.olabel == 0) {
        (*insertions)++;
      } else if (arc.ilabel != 0 && arc.olabel != 0) {
        (*substitutions)++;
        (*num_words)++;
      } else {
        KALDI_ASSERT(arc.ilabel == 0 && arc.olabel == 0);
      }
      src = arc.nextstate;
      continue;  // jump to next state
    }
  }
}

CoverageTest()

bool kaldi::CoverageTest	(	bool	seps,
		const std::string &	infile
	)

Definition at line 119 of file arpa-lm-compiler-test.cc.

References AddSelfLoops(), Compile(), CreateGenFst(), ArpaLmCompiler::Fst(), rnnlm::i, KALDI_WARN, kRandomSentences, and ArpaLmCompiler::MutableFst().

Referenced by RunAllTests().

                                                      {
  // Compile ARPA model.
  ArpaLmCompiler* lm_compiler = Compile(seps, infile);

  // Create an FST that generates any sequence of symbols taken from the model
  // output.
  fst::StdVectorFst* genFst =
      CreateGenFst(seps, lm_compiler->Fst().OutputSymbols());

  int num_successes = 0;
  for (int32 i = 0; i < kRandomSentences; ++i) {
    // Generate a random sentence FST.
    fst::StdVectorFst sentence;
    RandGen(*genFst, &sentence);
    if (seps)
      AddSelfLoops(&sentence);

    fst::ArcSort(lm_compiler->MutableFst(), fst::StdOLabelCompare());

    // The past must successfully compose with the LM FST.
    fst::StdVectorFst composition;
    Compose(sentence, lm_compiler->Fst(), &composition);
    if (composition.Start() != fst::kNoStateId)
      ++num_successes;
  }

  delete genFst;
  delete lm_compiler;

  bool ok = num_successes == kRandomSentences;
  if (!ok) {
    KALDI_WARN << "Coverage test failed on " << infile << ": composed "
               << num_successes << "/" << kRandomSentences;
  }
  return ok;
}

CreateEditDistance()

void kaldi::CreateEditDistance	(	const fst::StdVectorFst &	fst1,
		const fst::StdVectorFst &	fst2,
		fst::StdVectorFst *	pfst
	)

Definition at line 77 of file lattice-oracle.cc.

References fst::GetInputSymbols(), fst::GetOutputSymbols(), rnnlm::i, and rnnlm::j.

Referenced by main().

                                               {
  typedef fst::StdArc StdArc;
  typedef fst::StdArc::Weight Weight;
  typedef fst::StdArc::Label Label;
  Weight correct_cost(0.0);
  Weight substitution_cost(1.0);
  Weight insertion_cost(1.0);
  Weight deletion_cost(1.0);

  // create set of output symbols in fst1
  std::vector<Label> fst1syms, fst2syms;
  GetOutputSymbols(fst1, false /*no epsilons*/, &fst1syms);
  GetInputSymbols(fst2, false /*no epsilons*/, &fst2syms);

  pfst->AddState();
  pfst->SetStart(0);
  for (size_t i = 0; i < fst1syms.size(); i++)
    pfst->AddArc(0, StdArc(fst1syms[i], 0, deletion_cost, 0));  // deletions

  for (size_t i = 0; i < fst2syms.size(); i++)
    pfst->AddArc(0, StdArc(0, fst2syms[i], insertion_cost, 0));  // insertions

  // stupid implementation O(N^2)
  for (size_t i = 0; i < fst1syms.size(); i++) {
    Label label1 = fst1syms[i];
    for (size_t j = 0; j < fst2syms.size(); j++) {
      Label label2 = fst2syms[j];
      Weight cost(label1 == label2 ? correct_cost : substitution_cost);
      pfst->AddArc(0, StdArc(label1, label2, cost, 0));  // substitutions
    }
  }
  pfst->SetFinal(0, Weight::One());
  ArcSort(pfst, fst::StdOLabelCompare());
}

CreateEigenvalueMatrix() [1/2]

template void kaldi::CreateEigenvalueMatrix	(	const VectorBase< float > &	re,
		const VectorBase< float > &	im,
		MatrixBase< float > *	D
	)

CreateEigenvalueMatrix() [2/2]

template void kaldi::CreateEigenvalueMatrix	(	const VectorBase< double > &	re,
		const VectorBase< double > &	im,
		MatrixBase< double > *	D
	)

Referenced by CreateEigenvalueMatrix(), and MatrixBase< float >::Power().

CreateFactorTransducer()

bool CreateFactorTransducer	(	const CompactLattice &	clat,
		const std::vector< int32 > &	state_times,
		int32	utterance_id,
		KwsProductFst *	factor_transducer
	)

Definition at line 160 of file kws-functions.cc.

References ComputeCompactLatticeAlphas(), ComputeCompactLatticeBetas(), fst::ComputeStateInfo(), rnnlm::i, KALDI_WARN, fst::kStateHasEpsilonArcsEntering, fst::kStateHasEpsilonArcsLeaving, fst::kStateHasNonEpsilonArcsEntering, fst::kStateHasNonEpsilonArcsLeaving, and ArcticWeightTpl< T >::One().

Referenced by main().

                                                              {
  using namespace fst;
  typedef KwsProductArc::StateId StateId;

  // We first compute the alphas and betas
  bool success = false;
  std::vector<double> alpha;
  std::vector<double> beta;
  success = ComputeCompactLatticeAlphas(clat, &alpha);
  success = success && ComputeCompactLatticeBetas(clat, &beta);
  if (!success)
    return false;

  // Now we map the CompactLattice to VectorFst<KwsProductArc>. We drop the
  // alignment information and only keep the negated log-probs
  Map(clat, factor_transducer, CompactLatticeToKwsProductFstMapper());

  // Now do the weight pushing manually on the CompactLattice format. Note that
  // the alphas and betas in Kaldi are stored as the log-probs, not the negated
  // log-probs, so the equation for weight pushing is a little different from
  // the original algorithm (pay attention to the sign). We push the weight to
  // initial and remove the total weight, i.e., the sum of all the outgoing
  // transitions and final weight at any state is equal to One() (push only the
  // negated log-prob, not the alignments)
  for (StateIterator<KwsProductFst>
       siter(*factor_transducer); !siter.Done(); siter.Next()) {
    KwsProductArc::StateId state_id = siter.Value();
    for (MutableArcIterator<KwsProductFst>
         aiter(factor_transducer, state_id); !aiter.Done(); aiter.Next()) {
      KwsProductArc arc = aiter.Value();
      BaseFloat w = arc.weight.Value1().Value();
      w += beta[state_id] - beta[arc.nextstate];
      KwsProductWeight weight(w, arc.weight.Value2());
      arc.weight = weight;
      aiter.SetValue(arc);
    }
    // Weight of final state
    if (factor_transducer->Final(state_id) != KwsProductWeight::Zero()) {
      BaseFloat w = factor_transducer->Final(state_id).Value1().Value();
      w += beta[state_id];
      KwsProductWeight weight(w, factor_transducer->Final(state_id).Value2());
      factor_transducer->SetFinal(state_id, weight);
    }
  }

  // Modify the alphas and set betas to zero. After that, we get the alphas and
  // betas for the pushed FST. Since I will not use beta anymore, here I don't
  // set them to zero. This can be derived from the weight pushing formula.
  for (int32 s = 0; s < alpha.size(); s++) {
    alpha[s] += beta[s] - beta[0];

    if (alpha[s] > 0.1) {
      KALDI_WARN << "Positive alpha " << alpha[s];
    }
  }

  // to understand the next part, look at the comment in
  // ../kwsbin/lattice-to-kws-index.cc just above the call to
  // EnsureEpsilonProperty().  We use the bool has_epsilon_property mainly to
  // handle the case when someone comments out that call.  It should always be
  // true in the normal case.
  std::vector<char> state_properties;
  ComputeStateInfo(*factor_transducer, &state_properties);
  bool has_epsilon_property = true;
  for (size_t i = 0; i < state_properties.size(); i++) {
    char c = state_properties[i];
    if ((c & kStateHasEpsilonArcsEntering) != 0 &&
        (c & kStateHasNonEpsilonArcsEntering) != 0)
      has_epsilon_property = false;
    if ((c & kStateHasEpsilonArcsLeaving) != 0 &&
        (c & kStateHasNonEpsilonArcsLeaving) != 0)
      has_epsilon_property = false;
  }
  if (!has_epsilon_property) {
    KALDI_WARN << "Epsilon property does not hold, reverting to old behavior.";
  }

  // OK, after the above preparation, we finally come to the factor generation
  // step.
  StateId ns = factor_transducer->NumStates();
  StateId ss = factor_transducer->AddState();
  StateId fs = factor_transducer->AddState();
  factor_transducer->SetStart(ss);
  factor_transducer->SetFinal(fs, KwsProductWeight::One());

  for (StateId s = 0; s < ns; s++) {
    // Add arcs from initial state to current state
    if (!has_epsilon_property ||
        (state_properties[s] & kStateHasNonEpsilonArcsLeaving))
      factor_transducer->AddArc(ss, KwsProductArc(0, 0, KwsProductWeight(-alpha[s], StdXStdprimeWeight(state_times[s], ArcticWeight::One())), s));
    // Add arcs from current state to final state
    if (!has_epsilon_property ||
        (state_properties[s] & kStateHasNonEpsilonArcsEntering))
      factor_transducer->AddArc(s, KwsProductArc(0, utterance_id, KwsProductWeight(0, StdXStdprimeWeight(TropicalWeight::One(), state_times[s])), fs));
    // The old final state is not final any more
    if (factor_transducer->Final(s) != KwsProductWeight::Zero())
      factor_transducer->SetFinal(s, KwsProductWeight::Zero());
  }

  return true;
}

CreateGenFst()

static fst::StdVectorFst* kaldi::CreateGenFst ( bool  seps, const fst::SymbolTable *  pst  )

static

Definition at line 44 of file arpa-lm-compiler-test.cc.

References kBos, kDisambig, kEos, and kEps.

Referenced by CoverageTest().

                                                                           {
  fst::StdVectorFst* genFst = new fst::StdVectorFst;
  genFst->SetInputSymbols(pst);
  genFst->SetOutputSymbols(pst);

  fst::StdArc::StateId midId   = genFst->AddState();
  if (!seps) {
    fst::StdArc::StateId initId  = genFst->AddState();
    fst::StdArc::StateId finalId = genFst->AddState();
    genFst->SetStart(initId);
    genFst->SetFinal(finalId, fst::StdArc::Weight::One());
    genFst->AddArc(initId, fst::StdArc(kBos, kBos, 0, midId));
    genFst->AddArc(midId,  fst::StdArc(kEos, kEos, 0, finalId));
  } else {
    genFst->SetStart(midId);
    genFst->SetFinal(midId, fst::StdArc::Weight::One());
  }

  // Add a loop for each symbol in the table except the four special ones.
  fst::SymbolTableIterator si(*pst);
  for (si.Reset(); !si.Done(); si.Next()) {
    if (si.Value() == kBos || si.Value() == kEos ||
        si.Value() == kEps || si.Value() == kDisambig)
      continue;
    genFst->AddArc(midId, fst::StdArc(si.Value(), si.Value(),
                                      fst::StdArc::Weight::One(), midId));
  }
  return genFst;
}

CsvResult()

static void kaldi::CsvResult ( std::string  test, int  dim, BaseFloat  measure, std::string  units  )

static

Definition at line 34 of file matrix-lib-speed-test.cc.

                                                                                                           {
    std::cout << test << "," << (sizeof(Real) == 8 ? "double" : "float") << "," << dim << "," << measure << "," << units << "\n";
}

CuBlockMatrixUnitTest()

void kaldi::CuBlockMatrixUnitTest

(

)

Definition at line 173 of file cu-block-matrix-test.cc.

                                                     {
  UnitTestCuBlockMatrixIO<Real>();
  UnitTestCuBlockMatrixAddMatBlock<Real>();
  UnitTestCuBlockMatrixAddMatMat<Real>();
}

CuCompressedMatrixTestNonnegative()

void kaldi::CuCompressedMatrixTestNonnegative

(

)

Definition at line 54 of file cu-compressed-matrix-test.cc.

References CuMatrixBase< Real >::Add(), CuMatrixBase< Real >::AddMat(), CuCompressedMatrixBase::CopyFromMat(), CuCompressedMatrixBase::CopyToMat(), KALDI_ASSERT, kCompressedMatrixUint16, kCompressedMatrixUint8, kUndefined, CuMatrixBase< Real >::Max(), CuMatrixBase< Real >::Min(), NewCuCompressedMatrix(), RandInt(), CuMatrixBase< Real >::Scale(), and CuMatrixBase< Real >::SetRandUniform().

Referenced by main().

                                         {
  int32 num_rows = RandInt(80, 100),
      num_cols = RandInt(80, 100);
  CuMatrix<BaseFloat> M(num_rows, num_cols);
  M.SetRandUniform();

  BaseFloat range = 0.5 * RandInt(1, 5);
  M.Scale(range);

  CuCompressedMatrixType t = (RandInt(0, 1) == 0 ?
                              kCompressedMatrixUint8 :
                              kCompressedMatrixUint16);

  // since the input is in the correct range, truncating or not should make no
  // difference.
  bool truncate = (RandInt(0, 1) == 0);

  BaseFloat extra_error = 0.0;
  if (truncate && (RandInt(0, 1) == 0)) {
    // this tests that with truncate == true, adding a small offset, which would
    // take us outside the representable range, will not add too much extra
    // error.  (with truncate == false this would not be true because we wouldn't
    // round to the edges of the range, it would wrap around).
    extra_error = -0.01 * (RandInt(0, 1) == 0 ? 1.0 : -1.0);
    M.Add(extra_error);
  }

  CuCompressedMatrixBase *cm = NewCuCompressedMatrix(t, range, truncate);

  CuMatrix<BaseFloat> M2(num_rows, num_cols, kUndefined);

  cm->CopyFromMat(M);
  cm->CopyToMat(&M2);


  M2.AddMat(-1.0, M);

  BaseFloat diff_max = M2.Max(),
      diff_min = M2.Min();

  BaseFloat
      headroom = 1.1,
      max_expected_error = fabs(extra_error) + headroom * 0.5 *
         range / (t == kCompressedMatrixUint8 ? 255 : 65535);

  KALDI_ASSERT(diff_max < max_expected_error &&
               diff_min > -1.0 * max_expected_error);

  delete cm;
}

CuCompressedMatrixTestSign()

void kaldi::CuCompressedMatrixTestSign

(

)

Definition at line 34 of file cu-compressed-matrix-test.cc.

References AssertEqual(), CuCompressedMatrixBase::CopyFromMat(), CuCompressedMatrixBase::CopyToMat(), CuMatrixBase< Real >::Heaviside(), kCompressedMatrixUint8, kUndefined, NewCuCompressedMatrix(), RandInt(), and CuMatrixBase< Real >::SetRandn().

Referenced by main().

                                  {
  int32 num_rows = RandInt(80, 100),
      num_cols = RandInt(80, 100);
  CuMatrix<BaseFloat> M(num_rows, num_cols);
  M.SetRandn();

  CuMatrix<BaseFloat> M2(num_rows, num_cols, kUndefined);

  CuCompressedMatrixBase *cm = NewCuCompressedMatrix(kCompressedMatrixUint8, 0.0);

  // this just stores (M(i, j) > 0 ? 1 : 0).
  cm->CopyFromMat(M);
  cm->CopyToMat(&M2);

  M.Heaviside(M);

  AssertEqual(M, M2);
  delete cm;
}

CuCompressedMatrixTestSymmetric()

void kaldi::CuCompressedMatrixTestSymmetric

(

)

Definition at line 107 of file cu-compressed-matrix-test.cc.

References CuMatrixBase< Real >::Add(), CuMatrixBase< Real >::AddMat(), CuCompressedMatrixBase::CopyFromMat(), CuCompressedMatrixBase::CopyToMat(), KALDI_ASSERT, kCompressedMatrixInt16, kCompressedMatrixInt8, kUndefined, CuMatrixBase< Real >::Max(), CuMatrixBase< Real >::Min(), NewCuCompressedMatrix(), RandInt(), CuMatrixBase< Real >::Scale(), and CuMatrixBase< Real >::SetRandUniform().

Referenced by main().

                                       {
  int32 num_rows = RandInt(80, 100),
      num_cols = RandInt(80, 100);
  CuMatrix<BaseFloat> M(num_rows, num_cols);
  M.SetRandUniform();
  M.Scale(2.0);
  M.Add(-1.0);

  BaseFloat range = 0.5 * RandInt(1, 5);
  M.Scale(range);

  CuCompressedMatrixType t = (RandInt(0, 1) == 0 ?
                              kCompressedMatrixInt8 :
                              kCompressedMatrixInt16);

  // since the input is in the correct range, truncating or not should make no
  // difference.
  bool truncate = (RandInt(0, 1) == 0);

  BaseFloat extra_error = 0.0;
  if (truncate && (RandInt(0, 1) == 0)) {
    // this tests that with truncate == true, adding a small offset, which would
    // take us outside the representable range, will not add too much extra
    // error.  (with truncate == false this would not be true because we wouldn't
    // round to the edges of the range, it would wrap around).
    extra_error = -0.01 * (RandInt(0, 1) == 0 ? 1.0 : -1.0);
    M.Add(extra_error);
  }

  CuCompressedMatrixBase *cm = NewCuCompressedMatrix(t, range, truncate);

  CuMatrix<BaseFloat> M2(num_rows, num_cols, kUndefined);

  cm->CopyFromMat(M);
  cm->CopyToMat(&M2);


  M2.AddMat(-1.0, M);

  BaseFloat diff_max = M2.Max(),
      diff_min = M2.Min();

  BaseFloat
      headroom = 1.1,
      max_expected_error = fabs(extra_error) + headroom * 0.5 *
         range / (t == kCompressedMatrixInt8 ? 127 : 32767);

  KALDI_ASSERT(diff_max < max_expected_error &&
               diff_min > -1.0 * max_expected_error);

  delete cm;
}

CudaMathUnitTest()

void kaldi::CudaMathUnitTest

(

)

Definition at line 694 of file cu-math-test.cc.

References UnitTestLstmNonlinearity().

                                                {
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().DoublePrecisionSupported())
#endif

  UnitTestCuMathComputeLstmNonlinearity<Real>();
  UnitTestCuMathRandomize<Real>();
  UnitTestCuMathSplice<Real>();
  UnitTestCuMathCopy<Real>();
  UnitTestLstmNonlinearity();
  UnitTestEnsureNonzero<Real>();
  UnitTestBackpropLstmNonlinearity<Real>();
  UnitTestCuMathNormalizePerRow<Real>();
  UnitTestCuMathNormalizePerRow_v2<Real>();
  UnitTestCuDiffNormalizePerRow<Real>();
}

CudaMatrixResizeTest()

void kaldi::CudaMatrixResizeTest

(

)

Definition at line 81 of file cu-device-test.cc.

                            {
  std::vector<int32> sizes;
  sizes.push_back(1);
  sizes.push_back(2);
  sizes.push_back(4);
  sizes.push_back(8);
  sizes.push_back(16);
  //sizes.push_back(24);
  //sizes.push_back(32);
  //sizes.push_back(40);

  int32 ns = sizes.size();
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixResize<Real>(sizes[s]);
}

CudaMatrixSpeedTest()

void kaldi::CudaMatrixSpeedTest

(

)

Definition at line 1012 of file cu-matrix-speed-test.cc.

References kNoTrans, and kTrans.

                                                   {
  std::vector<int32> sizes;
  sizes.push_back(16);
  sizes.push_back(32);
  sizes.push_back(64);
  sizes.push_back(128);
  sizes.push_back(256);
  sizes.push_back(512);
  sizes.push_back(1024);
  int32 ns = sizes.size();
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixDivRowsVec<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixResize<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixAddMat<Real>(sizes[s], 3, 3);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixAddMatBlocks<Real>(sizes[s], 3, 3);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixMatMat<Real>(sizes[s]);
  for (int32 s = 0; s + 1 < ns; s++)
    TestCuMatrixMatMatBatched<Real>(sizes[s], 10);
  for (int32 s = 0; s < ns; s++) {
    TestCuMatrixAddDiagVecMat<Real>(sizes[s], kNoTrans);
    TestCuMatrixAddDiagVecMat<Real>(sizes[s], kTrans);
  }
  for (int32 s = 0; s < ns; s++)
    TestSymInvertPosDef<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCholesky<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixSigmoid<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixHeaviside<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuFindRowMaxId<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCompObjfAndDeriv<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixMulRowsGroupMat<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixSoftmax<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixDiffSoftmax<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixDiffLogSoftmax<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixLogSoftmax<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixGroupPnorm<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixDiffGroupPnorm<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixGroupMax<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixGroupMaxAllGroupSizes<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixGroupMaxDeriv<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixTraceMatMat<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuSparseMatrixTraceMatSmat<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyLowerToUpper<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyFromTp<Real>(sizes[s], kNoTrans);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyFromTp<Real>(sizes[s], kTrans);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyFromSp<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyUpperToLower<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixSetZeroAboveDiag<Real>(sizes[s]);
  for (int32 s = 0; s + 2 < ns; s++)
    TestCuMatrixLookup<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyRows1<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyRows2<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixCopyToRows<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixAddRows1<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixAddRows2<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixAddToRows<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixAddRowRanges<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixTransposeCross<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixTransposeS<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixTransposeNS<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixSum<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixMax<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuMatrixMin<Real>(sizes[s]);
}

CudaMatrixUnitTest()

void kaldi::CudaMatrixUnitTest

(

)

Definition at line 2941 of file cu-matrix-test.cc.

                                                  {
  UnitTestCuMatrixApplyExpSpecial<Real>();
  UnitTestCuMatrixApplyExpLimited<Real>();
  UnitTextCuMatrixAddSmatMat<Real>();
  UnitTextCuMatrixAddMatSmat<Real>();
  UnitTextCuMatrixAddSmat<Real>();
  UnitTestCuMatrixTraceMatMat<Real>();
  UnitTestCuMatrixObjfDeriv<Real>();
  //test CuMatrix<Real> methods by cross-check with Matrix
  UnitTestCuMatrixCopyCross<Real>();
  UnitTestCuMatrixCopyCross2<Real>();
  UnitTestCuMatrixApplyLog<Real>();
  UnitTestCuMatrixApplyExp<Real>();
  UnitTestCuMatrixSetRandn<Real>();
  UnitTestCuMatrixSetRandUniform<Real>();
  UnitTestCuMatrixScale<Real>();
  UnitTestCuMatrixSigmoid<Real>();
  UnitTestCuMatrixSoftHinge<Real>();
  UnitTestCuMatrixApplyPow<Real>();
  UnitTestCuMatrixApplyPowAbs<Real>();
  UnitTestCuMatrixSet<Real>();
  UnitTestCuMatrixAdd<Real>();
  UnitTestCuMatrixApplyFloor<Real>();
  UnitTestCuMatrixApplyCeiling<Real>();
  UnitTestCuMatrixApplyHeaviside<Real>();
  UnitTestCuMatrixHeaviside<Real>();
  UnitTestCuMatrixMulElements<Real>();
  UnitTestCuMatrixDivElements<Real>();
  UnitTestCuMatrixMax<Real>();
  UnitTestCuMatrixMin<Real>();
  UnitTestCuMatrixMulColsVec<Real>();
  UnitTestCuMatrixMulRowsVec<Real>();
  UnitTestCuMatrixDivRowsVec<Real>();
  UnitTestCuMatrixAddMat<Real>();
  UnitTestCuMatrixAddMatBlocks1<Real>();
  UnitTestCuMatrixAddMatBlocks1Trans<Real>();
  UnitTestCuMatrixAddMatBlocks2<Real>();
  UnitTestCuMatrixReduceSum<Real>();
  UnitTestCuMatrixReduceMax<Real>();
  UnitTestCuMatrixReduceMin<Real>();
  UnitTestCuMatrixAddVecToCols<Real>();
  UnitTestCuMatrixAddVecToRows<Real>();
  UnitTestCuMatrixAddMatMat<Real>();
  UnitTestCuMatrixAddVecVec<Real>();
  UnitTestCuMatrixSymAddMat2<Real>();
  UnitTestCuMatrixAddMatMatBatched<Real>();
  UnitTestCuMatrixSymInvertPosDef<Real>();
  UnitTestCuMatrixCopyFromMat<Real>();
  UnitTestCuMatrixCopyFromTp<Real>();
  UnitTestCuMatrixAddMatTp<Real>();
  UnitTestCuMatrixCopyCols<Real>();
  UnitTestCuMatrixAddCols<Real>();
  UnitTestCuMatrixSumColumnRanges<Real>();
  UnitTestCuMatrixCopyRows<Real>();
  UnitTestCuMatrixCopyRowsFromVec<Real>();
  UnitTestCuMatrixCopyColsFromVec<Real>();
  UnitTestCuMatrixCopyToRows<Real>();
  UnitTestCuMatrixAddRows<Real>();
  UnitTestCuMatrixMulRows<Real>();
  UnitTestCuMatrixAddToRows<Real>();
  UnitTestCuMatrixAddRowRanges<Real>();
  UnitTestCuMatrixAddTpMat<Real>();
  UnitTestCuMatrixTranspose<Real>();
  UnitTestCuMatrixCopyUpperToLower<Real>();
  UnitTestCuMatrixCopyLowerToUpper<Real>();
  UnitTestCuMatrixSetZeroAboveDiag<Real>();
  UnitTestCuMatrixAddElements<Real>();
  UnitTestCuMatrixAddToElements<Real>();
  UnitTestCuMatrixLookup<Real>();
  UnitTestCuMatrixEqualElementMask<Real>();
  // test CuVector<Real> methods
  UnitTestCuVectorAddVec<Real>();
  UnitTestCuVectorAddRowSumMat<Real>();
  UnitTestCuVectorAddRowSumMatLarge<Real>();
  UnitTestCuVectorAddColSumMat<Real>();
  UnitTestCuVectorAddColSumMatLarge<Real>();
  UnitTestCuSubMatrix<Real>();
  UnitTestCuMatrixInvertElements<Real>();
  UnitTestCuVectorInvertElements<Real>();
  UnitTestCuMatrixIO<Real>();
  UnitTestCuSigmoid<Real>();
  UnitTestCuApproxEqual<Real>();
  UnitTestCuCopy<Real, float>();
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().DoublePrecisionSupported())
#endif
    UnitTestCuCopy<Real, double>();
  UnitTestCuMatrixAddToDiag<Real>();
  UnitTestCuMatrixAdd2<Real>();
  UnitTestCuDiffSigmoid<Real>();
  UnitTestCuDiffSoftmax<Real>();
  UnitTestCuDiffLogSoftmax<Real>();
  UnitTestCuMatrixGroupPnorm<Real>();
  UnitTestCuMatrixDiffGroupPnorm<Real>();
  UnitTestCuMatrixGroupMax<Real>();
  UnitTestCuMatrixGroupMaxDeriv<Real>();
  UnitTestCuMatrixMulRowsVec<Real>();
  UnitTestCuMatrixMulRowsGroupMat<Real>();
  UnitTestCuFindRowMaxId<Real>();
  UnitTestCuSoftmax<Real>();
  UnitTestCuLogSoftmax<Real>();
  UnitTestCuDiffXent<Real>();
  UnitTestCheck<Real>();
  UnitTestSwapCu2Cu<Real>();
  UnitTestSwapCu2M<Real>();
  UnitTestCuMatrixAddDiagVecMat<Real>();
  UnitTestCuMatrixAddMatDiagVec<Real>();
  UnitTestCuMatrixAddMatMatElements<Real>();
  UnitTestCuMatrixSetMatMatDivMat<Real>();
  UnitTestCuTanh<Real>();
  UnitTestCuCholesky<Real>();
  UnitTestCuDiffTanh<Real>();
  UnitTestCuVectorAddTpVec<Real>();
  UnitTestCuVectorMulTp<Real>();
}

CudaPackedMatrixUnitTest()

void kaldi::CudaPackedMatrixUnitTest

(

)

Definition at line 231 of file cu-packed-matrix-test.cc.

                                                        {
  UnitTestCuPackedMatrixConstructor<Real>();
  //UnitTestCuPackedMatrixCopy<Real>();
  UnitTestCuPackedMatrixTrace<Real>();
  UnitTestCuPackedMatrixScale<Real>();
  UnitTestCuPackedMatrixAddToDiag<Real>();
  UnitTestCuPackedMatrixSetUnit<Real>();
}

CudaSparseMatrixUnitTest()

void kaldi::CudaSparseMatrixUnitTest

(

)

Definition at line 271 of file cu-sparse-matrix-test.cc.

                                {
  UnitTestCuSparseMatrixConstructFromIndexes<Real>();
  UnitTestCuSparseMatrixSelectRowsAndTranspose<Real>();
  UnitTestCuSparseMatrixTraceMatSmat<Real>();
  UnitTestCuSparseMatrixSum<Real>();
  UnitTestCuSparseMatrixFrobeniusNorm<Real>();
  UnitTestCuSparseMatrixCopyToSmat<Real>();
  UnitTestCuSparseMatrixSwap<Real>();
}

CudaSpMatrixUnitTest() [1/2]

void kaldi::CudaSpMatrixUnitTest

(

)

Definition at line 342 of file cu-sp-matrix-test.cc.

                                                    {
  UnitTestCuSpMatrixIO<Real>();
  UnitTestCuSpMatrixConstructor<Real>();
  UnitTestCuSpMatrixOperator<Real>();
  UnitTestCuSpMatrixApproxEqual<Real>();
  UnitTestCuSpMatrixInvert<Real>();
  UnitTestCuSpMatrixCopyFromMat<Real>();
  UnitTestCuSpMatrixAddVec2<Real>();
  UnitTestCuSpMatrixAddMat2<Real>();
  UnitTestCuSpMatrixAddSp<Real>();
  UnitTestCuSpMatrixAddToDiag<Real>();
  UnitTestCuSpMatrixSetUnit<Real>();
}

CudaSpMatrixUnitTest() [2/2]

void kaldi::CudaSpMatrixUnitTest

(

)

Definition at line 356 of file cu-sp-matrix-test.cc.

                                                                        {
  UnitTestCuSpMatrixTraceSpSp<Real, OtherReal>();

}

CudaTpMatrixUnitTest()

void kaldi::CudaTpMatrixUnitTest

(

)

Definition at line 176 of file cu-tp-matrix-test.cc.

                                                    {
  UnitTestCuTpMatrixIO<Real>();
  UnitTestCuTpMatrixInvert<Real>();
  UnitTestCuTpMatrixCopyFromTp<Real>();
  UnitTestCuTpMatrixCholesky<Real>();
  UnitTestCuTpMatrixCopyFromMat<Real>();
}

CudaVectorSpeedTest()

void kaldi::CudaVectorSpeedTest

(

)

Definition at line 402 of file cu-vector-speed-test.cc.

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

                                                   {
  const size_t a = 1 << 5;
  const size_t b = 1 << 8;
  for (size_t i = a; i <= b; i *= 2) {
    for (size_t j = a; j <= b; j *= 2) {
      if (i * j <= a * b) {
        TestCuVectorAddDiagMatMatShape<Real>(i, j, kNoTrans, kNoTrans);
        TestCuVectorAddDiagMatMatShape<Real>(i, j, kNoTrans, kTrans);
        TestCuVectorAddDiagMatMatShape<Real>(i, j, kTrans, kNoTrans);
        TestCuVectorAddDiagMatMatShape<Real>(i, j, kTrans, kTrans);
      }
    }
  }

  std::vector<int32> sizes;
  for (int i = 32; i <= 1024; i *= 2) {
    sizes.push_back(i);
  }
  int32 ns = sizes.size();
  for (int32 s = 0; s < ns; s++)
    TestCuVectorSoftmax<Real>(sizes[s]);
#if HAVE_CUDA == 1
  TestCuVectorSumChooseMinLength<Real>();
#endif
  for (int32 s = 0; s < ns; s++)
    TestCuVectorSum<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuVectorVecVecOne<Real>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuVectorCopyFromVec<Real, float>(sizes[s]);
  for (int32 s = 0; s < ns; s++)
    TestCuVectorCopyFromVec<Real, double>(sizes[s]);
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorAddDiagMatMat<Real>(sizes[s], kNoTrans, kNoTrans);
    TestCuVectorAddDiagMatMat<Real>(sizes[s], kNoTrans, kTrans);
    TestCuVectorAddDiagMatMat<Real>(sizes[s], kTrans, kNoTrans);
    TestCuVectorAddDiagMatMat<Real>(sizes[s], kTrans, kTrans);
  }
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorAddDiagMat2OnVariousShapes<Real>(sizes[s], kNoTrans);
    TestCuVectorAddDiagMat2OnVariousShapes<Real>(sizes[s], kTrans);
  }
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorAddDiagMat2<Real>(sizes[s], kNoTrans);
    TestCuVectorAddDiagMat2<Real>(sizes[s], kTrans);
  }
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorAddRowSumMat<Real>(sizes[s], kNoTrans);
    TestCuVectorAddRowSumMat<Real>(sizes[s], kTrans);
  }
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorAddColSumMat<Real>(sizes[s], kNoTrans);
    TestCuVectorAddColSumMat<Real>(sizes[s], kTrans);
  }
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorApplyFloor<Real>(sizes[s]);
    TestCuVectorApplyFloorNoCount<Real>(sizes[s]);
  }
  for (int32 s = 0; s < ns; s++) {
    TestCuVectorApplyCeiling<Real>(sizes[s]);
    TestCuVectorApplyCeilingNoCount<Real>(sizes[s]);
  }

}

CuMatrixUnitTest()

static void kaldi::CuMatrixUnitTest ( )

static

Definition at line 561 of file cu-test.cc.

                               {
  UnitTestTrace<Real>();
  UnitTestCholesky<Real>();
  UnitTestInvert<Real>();
  UnitInvert<Real>();
  UnitTestCopyFromMat<Real>();
  UnitTestCopySp<Real>();
  UnitTestConstructor<Real>();
  UnitTestVector<Real>();
  UnitTestMulTp<Real>();
  UnitTestMatrix<Real>();
  UnitTestSetZeroAboveDiag<Real>();
}

CuRandGaussianMatrixBaseSpeedTest()

void kaldi::CuRandGaussianMatrixBaseSpeedTest

(

const int32

iter

)

Definition at line 129 of file cu-rand-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, kUndefined, MeanVariance(), CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), and CuRand< Real >::RandGaussian().

                                                         {
  Timer t;
  CuRand<Real> rand;
  CuMatrix<Real> m(249,1001, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandGaussian(dynamic_cast<CuMatrixBase<Real>*>(&m));
  }
  CuMatrix<Real> m2(256,1024, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandGaussian(dynamic_cast<CuMatrixBase<Real>*>(&m2));
  }
  // flops = number of generated random numbers per second,
  Real flops = iter * (m.NumRows() * m.NumCols() + m2.NumRows() * m2.NumCols()) / t.Elapsed();
  KALDI_LOG << __func__ << NameOf<Real>()
            << " Speed was " << flops << " rand_elems/s. "
            << "(debug " << MeanVariance(m) << ")";
}

CuRandGaussianMatrixSpeedTest()

void kaldi::CuRandGaussianMatrixSpeedTest

(

const int32

iter

)

Definition at line 110 of file cu-rand-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, kUndefined, MeanVariance(), CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), and CuRand< Real >::RandGaussian().

                                                     {
  Timer t;
  CuRand<Real> rand;
  CuMatrix<Real> m(249,1001, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandGaussian(&m);
  }
  CuMatrix<Real> m2(256,1024, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandGaussian(&m2);
  }
  // flops = number of generated random numbers per second,
  Real flops = iter * (m.NumRows() * m.NumCols() + m2.NumRows() * m2.NumCols()) / t.Elapsed();
  KALDI_LOG << __func__ << NameOf<Real>()
            << " Speed was " << flops << " rand_elems/s. "
            << "(debug " << MeanVariance(m) << ")";
}

CuRandGaussianVectorSpeedTest()

void kaldi::CuRandGaussianVectorSpeedTest

(

const int32

iter

)

Definition at line 167 of file cu-rand-speed-test.cc.

References CuVectorBase< Real >::Dim(), Timer::Elapsed(), rnnlm::i, kUndefined, MeanVariance(), and CuRand< Real >::RandGaussian().

                                                     {
  Timer t;
  CuRand<Real> rand;
  CuVector<Real> v(2011, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandGaussian(&v);
  }
  CuVector<Real> v2(2048, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandGaussian(&v2);
  }
  // flops = number of generated random numbers per second,
  Real flops = iter * (v.Dim() + v2.Dim()) / t.Elapsed();
  KALDI_LOG << __func__ << NameOf<Real>()
            << " Speed was " << flops << " rand_elems/s. "
            << "(debug " << MeanVariance(v) << ")";
}

CuRandUniformMatrixBaseSpeedTest()

void kaldi::CuRandUniformMatrixBaseSpeedTest

(

const int32

iter

)

Definition at line 91 of file cu-rand-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, kUndefined, MeanVariance(), CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), and CuRand< Real >::RandUniform().

                                                        {
  Timer t;
  CuRand<Real> rand;
  CuMatrix<Real> m(249,1001, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandUniform(dynamic_cast<CuMatrixBase<Real>*>(&m));
  }
  CuMatrix<Real> m2(256,1024, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandUniform(dynamic_cast<CuMatrixBase<Real>*>(&m2));
  }
  // flops = number of generated random numbers per second,
  Real flops = iter * (m.NumRows() * m.NumCols() + m2.NumRows() * m2.NumCols()) / t.Elapsed();
  KALDI_LOG << __func__ << NameOf<Real>()
            << " Speed was " << flops << " rand_elems/s. "
            << "(debug " << MeanVariance(m) << ")";
}

CuRandUniformMatrixSpeedTest()

void kaldi::CuRandUniformMatrixSpeedTest

(

const int32

iter

)

Definition at line 72 of file cu-rand-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, kUndefined, MeanVariance(), CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), and CuRand< Real >::RandUniform().

                                                    {
  Timer t;
  CuRand<Real> rand;
  CuMatrix<Real> m(249,1001, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandUniform(&m);
  }
  CuMatrix<Real> m2(256,1024, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandUniform(&m2);
  }
  // flops = number of generated random numbers per second,
  Real flops = iter * (m.NumRows() * m.NumCols() + m2.NumRows() * m2.NumCols()) / t.Elapsed();
  KALDI_LOG << __func__ << NameOf<Real>()
            << " Speed was " << flops << " rand_elems/s. "
            << "(debug " << MeanVariance(m) << ")";
}

CuRandUniformVectorSpeedTest()

void kaldi::CuRandUniformVectorSpeedTest

(

const int32

iter

)

Definition at line 148 of file cu-rand-speed-test.cc.

References CuVectorBase< Real >::Dim(), Timer::Elapsed(), rnnlm::i, kUndefined, MeanVariance(), and CuRand< Real >::RandUniform().

                                                    {
  Timer t;
  CuRand<Real> rand;
  CuVector<Real> v(2011, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandUniform(&v);
  }
  CuVector<Real> v2(2048, kUndefined);
  for (int32 i = 0; i < iter; i++) {
    rand.RandUniform(&v2);
  }
  // flops = number of generated random numbers per second,
  Real flops = iter * (v.Dim() + v2.Dim()) / t.Elapsed();
  KALDI_LOG << __func__ << NameOf<Real>()
            << " Speed was " << flops << " rand_elems/s. "
            << "(debug " << MeanVariance(v) << ")";
}

CuSpMatrixSpeedTest()

void kaldi::CuSpMatrixSpeedTest

(

)

Definition at line 107 of file cu-sp-matrix-speed-test.cc.

References kTakeLower, kTakeMean, and kTakeUpper.

                                                   {
  std::vector<int32> sizes;
  sizes.push_back(16);
  sizes.push_back(32);
  sizes.push_back(64);
  sizes.push_back(128);
  sizes.push_back(256);
  sizes.push_back(512);
  sizes.push_back(1024);
  int32 ns = sizes.size();

  for (int32 s = 0; s < ns; s++) {
    UnitTestCuSpMatrixInvert<Real>(sizes[s]);
    UnitTestCuSpMatrixCopyFromMat<Real>(sizes[s], kTakeLower);
    UnitTestCuSpMatrixCopyFromMat<Real>(sizes[s], kTakeUpper);
    UnitTestCuSpMatrixCopyFromMat<Real>(sizes[s], kTakeMean);
  }
}

CuVectorUnitTest()

void kaldi::CuVectorUnitTest

(

)

Definition at line 780 of file cu-vector-test.cc.

                                                {
  UnitTestCuVectorCopyFromVec<Real, float>();
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().DoublePrecisionSupported())
#endif
  UnitTestCuVectorCopyFromVec<Real, double>();
  UnitTestCuVectorIO<Real>();
  CuVectorUnitTestVecVec<Real>();
  CuVectorUnitTestAddVec<Real>();
  CuVectorUnitTestAddVecCross<Real>();
  CuVectorUnitTestAddVecExtra<Real>();
  CuVectorUnitTestApproxEqual<Real>();
  CuVectorUnitTestScale<Real>();
  CuVectorUnitTestSum<Real>();
  CuVectorUnitTestInvertElements<Real>();
  UnitTestCuVectorSum<Real>();
  CuVectorUnitTestAddRowSumMat<Real>();
  CuVectorUnitTestAddColSumMat<Real>();
  UnitTestCuVectorReplaceValue<Real>();
  UnitTestCuVectorAddTp<Real>();
  UnitTestCuVectorMulTp<Real>();
  UnitTestCuSubVector<Real>();
  CuVectorUnitTestCopyFromMat<Real>();
  CuVectorUnitTestMin<Real>();
  CuVectorUnitTestMax<Real>();
  CuVectorUnitTestApplySoftMax<Real>();
  CuVectorUnitTestCopyDiagFromPacked<Real>();
  CuVectorUnitTestCopyDiagFromMat<Real>();
  CuVectorUnitTestCopyCross<Real>();
  CuVectorUnitTestCopyCross2<Real>();
  CuVectorUnitTestNorm<Real>();
  CuVectorUnitTestApplyExp<Real>();
  CuVectorUnitTestApplyLog<Real>();
  CuVectorUnitTestApplyFloor<Real>();
  CuVectorUnitTestApplyFloorNoCount<Real>();
  CuVectorUnitTestApplyCeilingNoCount<Real>();
  CuVectorUnitTestApplyCeiling<Real>();
  CuVectorUnitTestApplyPow<Real>();
  CuVectorUnitTestAddMatVec<Real>();
  CuVectorUnitTestAddSpVec<Real>();
  CuVectorUnitTestAddVecVec<Real>();
  CuVectorUnitTestAddDiagMat2<Real>();
  CuVectorUnitTestAddDiagMatMat<Real>();
  CuVectorUnitTestCopyElements<Real>();
  UnitTestVecMatVec<Real>();
}

CuVectorUnitTestAddColSumMat()

void kaldi::CuVectorUnitTestAddColSumMat

(

)

Definition at line 264 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddColSumMat(), VectorBase< Real >::AddColSumMat(), AssertEqual(), Rand(), and CuMatrixBase< Real >::SetRandn().

                                                            {
  int32 M = 10 + Rand() % 280, N = 10 + Rand() % 20;
  BaseFloat alpha = 10.0143432, beta = 43.4321;
  CuMatrix<Real> mat(M, N);
  mat.SetRandn();
  CuVector<Real> vec(M);
  mat.SetRandn();
  Matrix<Real> mat2(mat);
  Vector<Real> vec2(M);
  vec.AddColSumMat(alpha, mat, beta);
  vec2.AddColSumMat(alpha, mat2, beta);
  Vector<Real> vec3(vec);
  AssertEqual(vec2, vec3);
}

CuVectorUnitTestAddDiagMat2()

void kaldi::CuVectorUnitTestAddDiagMat2

(

)

Definition at line 668 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddDiagMat2(), VectorBase< Real >::AddDiagMat2(), AssertEqual(), kNoTrans, kTrans, Rand(), CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                           {
  for (int p = 0; p < 4; p++) {
    int32 M = 230 + Rand() % 100, N = 230 + Rand() % 100;
    BaseFloat alpha = 0.2 + Rand() % 3, beta = 0.3 + Rand() % 2;
    CuVector<Real> cu_vector(M);
    cu_vector.SetRandn();

    CuMatrix<Real> cu_mat_orig(M, N);
    cu_mat_orig.SetRandn();
    MatrixTransposeType trans = (p % 2 == 0 ? kNoTrans : kTrans);
    CuMatrix<Real> cu_mat(cu_mat_orig, trans);

    Vector<Real> vector(cu_vector);
    Matrix<Real> mat(cu_mat);

    vector.AddDiagMat2(alpha, mat, trans, beta);
    cu_vector.AddDiagMat2(alpha, cu_mat, trans, beta);

    Vector<Real> vector2(cu_vector);
    AssertEqual(vector, vector2);
  }
}

CuVectorUnitTestAddDiagMatMat()

static void kaldi::CuVectorUnitTestAddDiagMatMat ( )

static

Definition at line 692 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddDiagMatMat(), CuMatrixBase< Real >::AddMatMat(), CuVectorBase< Real >::AddVec(), AssertEqual(), CuVectorBase< Real >::CopyDiagFromMat(), rnnlm::d, kNoTrans, kTrans, Rand(), CuVectorBase< Real >::Scale(), CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                            {
  for (MatrixIndexT iter = 0; iter < 4; iter++) {
    BaseFloat alpha = 0.432 + Rand() % 5, beta = 0.043 + Rand() % 2;
    MatrixIndexT dimM = 10 + Rand() % 300,
                 dimN = 5 + Rand() % 300;
    CuVector<Real> v(dimM);
    CuMatrix<Real> M_orig(dimM, dimN), N_orig(dimN, dimM);
    M_orig.SetRandn();
    N_orig.SetRandn();
    MatrixTransposeType transM = (iter % 2 == 0 ? kNoTrans : kTrans);
    MatrixTransposeType transN = ((iter/2) % 2 == 0 ? kNoTrans : kTrans);
    CuMatrix<Real> M(M_orig, transM), N(N_orig, transN);

    v.SetRandn();
    CuVector<Real> w(v);

    w.AddDiagMatMat(alpha, M, transM, N, transN, beta);

    {
      CuVector<Real> w2(v);
      CuMatrix<Real> MN(dimM, dimM);
      MN.AddMatMat(1.0, M, transM, N, transN, 0.0);
      CuVector<Real> d(dimM);
      d.CopyDiagFromMat(MN);
      w2.Scale(beta);
      w2.AddVec(alpha, d);
      AssertEqual(w, w2);
    }
  }
}

CuVectorUnitTestAddMatVec()

void kaldi::CuVectorUnitTestAddMatVec

(

)

Definition at line 725 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddMatVec(), VectorBase< Real >::AddMatVec(), AssertEqual(), rnnlm::i, kNoTrans, kTrans, Rand(), CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                         {
  for (int32 i = 0; i < 10; i++) {
    int32 M = 10 + Rand() % 500, N = 10 + Rand() % 400;

    bool transpose = (i % 2 == 0);

    CuVector<Real> src_cu(M);
    src_cu.SetRandn();
    Vector<Real> src(src_cu);

    CuVector<Real> dst_cu(N);
    dst_cu.SetRandn();
    Vector<Real> dst(dst_cu);

    CuMatrix<Real> mat_cu(transpose ? M : N, transpose ? N : M);
    mat_cu.SetRandn();
    Matrix<Real> mat(mat_cu);

    BaseFloat alpha = 0.5 * (Rand() % 10), beta = 0.5 * (Rand() % 10);
    dst_cu.AddMatVec(alpha, mat_cu, transpose ? kTrans : kNoTrans,
                     src_cu, beta);
    dst.AddMatVec(alpha, mat, transpose ? kTrans : kNoTrans,
                  src, beta);
    Vector<Real> dst2(dst_cu);
    AssertEqual(dst, dst2);
  }
}

CuVectorUnitTestAddRowSumMat()

void kaldi::CuVectorUnitTestAddRowSumMat

(

)

Definition at line 249 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddRowSumMat(), VectorBase< Real >::AddRowSumMat(), AssertEqual(), Rand(), and CuMatrixBase< Real >::SetRandn().

                                                            {
  int32 M = 10 + Rand() % 280, N = 10 + Rand() % 20;
  BaseFloat alpha = 10.0143432, beta = 43.4321;
  CuMatrix<Real> mat(N, M);
  mat.SetRandn();
  CuVector<Real> vec(M);
  mat.SetRandn();
  Matrix<Real> mat2(mat);
  Vector<Real> vec2(M);
  vec.AddRowSumMat(alpha, mat, beta);
  vec2.AddRowSumMat(alpha, mat2, beta);
  Vector<Real> vec3(vec);
  AssertEqual(vec2, vec3);
}

CuVectorUnitTestAddSpVec()

void kaldi::CuVectorUnitTestAddSpVec

(

)

Definition at line 754 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddSpVec(), VectorBase< Real >::AddSpVec(), AssertEqual(), rnnlm::i, Rand(), CuPackedMatrix< Real >::SetRandn(), and CuVectorBase< Real >::SetRandn().

                                                        {
  for (int32 i = 0; i < 5; i++) {
    int32 M = 100 + Rand() % 256;

    CuVector<Real> src_cu(M);
    src_cu.SetRandn();
    Vector<Real> src(src_cu);

    CuVector<Real> dst_cu(M);
    dst_cu.SetRandn();
    Vector<Real> dst(dst_cu);

    CuSpMatrix<Real> mat_cu(M);
    mat_cu.SetRandn();
    SpMatrix<Real> mat(mat_cu);

    BaseFloat alpha = 0.5 * (Rand() % 5), beta = 0.5 * (Rand() % 5);
    dst_cu.AddSpVec(alpha, mat_cu, src_cu, beta);
    dst.AddSpVec(alpha, mat, src, beta);
    Vector<Real> dst2(dst_cu);
    AssertEqual(dst, dst2);
  }
}

CuVectorUnitTestAddVec()

void kaldi::CuVectorUnitTestAddVec

(

)

Definition at line 155 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddVec(), AssertEqual(), rnnlm::i, Rand(), and CuVectorBase< Real >::SetRandn().

                                                      {
  int32 M = 10 + Rand() % 100;
  CuVector<Real> vec1(M);
  CuVector<Real> vec2(M);
  vec1.SetRandn();
  vec2.SetRandn();
  CuVector<Real> vec1_orig(vec1);
  BaseFloat alpha = 0.43243;
  vec1.AddVec(alpha, vec2);

  for (int32 i = 0; i < M; i++)
    AssertEqual(vec1_orig(i) + alpha * vec2(i), vec1(i));
}

CuVectorUnitTestAddVecCross()

void kaldi::CuVectorUnitTestAddVecCross

(

)

Definition at line 169 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddVec(), AssertEqual(), rnnlm::i, Rand(), and CuVectorBase< Real >::SetRandn().

                                                           {
  for (int32 i = 0; i < 4; i++) {
    int32 M = 10 + Rand() % 100;
    CuVector<float> vec1(M);
    CuVector<Real> vec2(M);
    vec1.SetRandn();
    vec2.SetRandn();

    if (i == 0) {
      CuVector<Real> vec1_orig(vec1);
      Real alpha = 0.43243;
      vec1.AddVec(alpha, vec2);

      for (int32 i = 0; i < M; i++)
        AssertEqual(vec1_orig(i) + alpha * vec2(i), vec1(i));
    } else {
      CuVector<Real> vec2_orig(vec2);
      Real alpha = 0.43243;
      vec2.AddVec(alpha, vec1);
      for (int32 i = 0; i < M; i++)
        AssertEqual(vec2_orig(i) + alpha * vec1(i), vec2(i));
    }
  }
}

CuVectorUnitTestAddVecExtra()

void kaldi::CuVectorUnitTestAddVecExtra

(

)

Definition at line 194 of file cu-vector-test.cc.

References AssertEqual(), rnnlm::i, Rand(), and CuVectorBase< Real >::SetRandn().

                                                           {
  int32 M = 10 + Rand() % 100;
  CuVector<Real> vec1(M), vec2(M);
  vec1.SetRandn();
  vec2.SetRandn();
  CuVector<Real> vec1_orig(vec1);
  BaseFloat alpha = 0.43243, beta = 1.4321;
  vec1.AddVec(alpha, vec2, beta);

  for (int32 i = 0; i < M; i++)
    AssertEqual(beta * vec1_orig(i) + alpha * vec2(i), vec1(i));
}

CuVectorUnitTestAddVecVec()

void kaldi::CuVectorUnitTestAddVecVec

(

)

Definition at line 647 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddVecVec(), VectorBase< Real >::AddVecVec(), AssertEqual(), Rand(), VectorBase< Real >::SetRandn(), and CuVectorBase< Real >::SetRandn().

                                                         {
  int32 dim = 100;
  CuVector<Real> cu_vector(dim);
  cu_vector.SetRandn();
  Vector<Real> vector(cu_vector);

  Real beta = Rand();
  Real alpha = Rand();
  Vector<Real> v(dim), r(dim);
  v.SetRandn(); r.SetRandn();
  CuVector<Real> cuV(v), cuR(r);


  cu_vector.AddVecVec(alpha, cuR, cuV, beta);
  vector.AddVecVec(alpha, r, v, beta);

  CuVector<Real> cu2(vector);
  std::cout<<cu2(0)<<' '<<cu_vector(0)<<std::endl;
  AssertEqual(cu2, cu_vector);
}

CuVectorUnitTestApplyCeiling()

void kaldi::CuVectorUnitTestApplyCeiling

(

)

Definition at line 591 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyCeiling(), VectorBase< Real >::ApplyCeiling(), AssertEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_WARN, Rand(), and CuVectorBase< Real >::SetRandn().

                                                            {
  for (int32 l = 0; l < 10; l++) {
    int32 dim = 100 + Rand() % 700;
    CuVector<Real> cu_vector(dim);
    cu_vector.SetRandn();

    Vector<Real> vector(cu_vector);
    BaseFloat floor = 0.33 * (-5 + Rand() % 10);
    MatrixIndexT i, j;
    cu_vector.ApplyCeiling(floor, &i);
    vector.ApplyCeiling(floor, &j);

    CuVector<Real> cu2(vector);

    AssertEqual(cu2, cu_vector);
    if (i != j) {
      KALDI_WARN << "ApplyCeiling return code broken...";
    }
    KALDI_ASSERT(i==j);
  }
}

CuVectorUnitTestApplyCeilingNoCount()

void kaldi::CuVectorUnitTestApplyCeilingNoCount

(

)

Definition at line 613 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyCeiling(), AssertEqual(), Rand(), and CuVectorBase< Real >::SetRandn().

                                                                   {
  for (int32 l = 0; l < 10; l++) {
    int32 dim = 100 + Rand() % 700;
    CuVector<Real> cu_vector1(dim);
    cu_vector1.SetRandn();
    CuVector<Real> cu_vector2(cu_vector1);

    BaseFloat floor = 0.33 * (-5 + Rand() % 10);
    MatrixIndexT dummy_count;
    cu_vector1.ApplyCeiling(floor, &dummy_count);
    cu_vector2.ApplyCeiling(floor, nullptr);
    AssertEqual(cu_vector1, cu_vector2);
  }
}

CuVectorUnitTestApplyExp()

void kaldi::CuVectorUnitTestApplyExp

(

)

Definition at line 522 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyExp(), Exp(), rnnlm::j, KALDI_ASSERT, and CuVectorBase< Real >::SetRandn().

                                                        {
  int32 dim = 100;
  CuVector<Real> vector(dim);
  vector.SetRandn();
  CuVector<Real> vector2(vector);

  vector.ApplyExp();
  for(int32 j = 0; j < dim; j++) {
    //std::cout<<"diff is "<<exp(vector2(j))-vector(j)<<std::endl;;
    KALDI_ASSERT(std::abs(Exp(vector2(j))-vector(j)) < 0.00001);
  }

}

CuVectorUnitTestApplyFloor()

void kaldi::CuVectorUnitTestApplyFloor

(

)

Definition at line 554 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyFloor(), VectorBase< Real >::ApplyFloor(), AssertEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_WARN, Rand(), and CuVectorBase< Real >::SetRandn().

                                                          {
  for (int32 l = 0; l < 10; l++) {
    int32 dim = 100 + Rand() % 700;
    CuVector<Real> cu_vector(dim);
    cu_vector.SetRandn();

    Vector<Real> vector(cu_vector);
    BaseFloat floor = 0.33 * (-5 + Rand() % 10);
    MatrixIndexT i, j;
    cu_vector.ApplyFloor(floor, &i);
    vector.ApplyFloor(floor, &j);

    CuVector<Real> cu2(vector);

    AssertEqual(cu2, cu_vector);
    if (i != j) {
      KALDI_WARN << "ApplyFloor return code broken...";
    }
    KALDI_ASSERT(i==j);
  }
}

CuVectorUnitTestApplyFloorNoCount()

void kaldi::CuVectorUnitTestApplyFloorNoCount

(

)

Definition at line 576 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyFloor(), AssertEqual(), Rand(), and CuVectorBase< Real >::SetRandn().

                                                                 {
  for (int32 l = 0; l < 10; l++) {
    int32 dim = 100 + Rand() % 700;
    CuVector<Real> cu_vector1(dim);
    cu_vector1.SetRandn();
    CuVector<Real> cu_vector2(cu_vector1);

    BaseFloat floor = 0.33 * (-5 + Rand() % 10);
    MatrixIndexT dummy_count;
    cu_vector1.ApplyFloor(floor, &dummy_count);
    cu_vector2.ApplyFloor(floor, nullptr);
    AssertEqual(cu_vector1, cu_vector2);
  }
}

CuVectorUnitTestApplyLog()

void kaldi::CuVectorUnitTestApplyLog

(

)

Definition at line 536 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyLog(), rnnlm::j, KALDI_ASSERT, Log(), and CuVectorBase< Real >::SetRandn().

                                                        {
  int32 dim = 100;
  CuVector<Real> vector(dim);
  vector.SetRandn();
  for(int32 j = 0; j < dim; j++) {
    if(vector(j) <= 0.0)
      vector(j) = 1.0 - vector(j);
  }

  CuVector<Real> vector2(vector);

  vector.ApplyLog();
  for(int32 j = 0; j < dim; j++) {
    //std::cout<<"diff is "<<exp(vector2(j))-vector(j)<<std::endl;;
    KALDI_ASSERT(std::abs(Log(vector2(j))-vector(j)) < 0.000001 );
  }
}

CuVectorUnitTestApplyPow()

void kaldi::CuVectorUnitTestApplyPow

(

)

Definition at line 628 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplyPow(), VectorBase< Real >::ApplyPow(), AssertEqual(), Rand(), and CuVectorBase< Real >::SetRandn().

                                                        {
  for (int32 l = 0; l < 10; l++) {
    int32 dim = 100 + Rand() % 700;

    CuVector<Real> cu_vector(dim);
    cu_vector.SetRandn();

    Vector<Real> vector(cu_vector);

    BaseFloat pow = -2 + (Rand() % 5);
    cu_vector.ApplyPow(pow);
    vector.ApplyPow(pow);

    CuVector<Real> cu2(vector);

    AssertEqual(cu2, cu_vector);
  }
}

CuVectorUnitTestApplySoftMax()

void kaldi::CuVectorUnitTestApplySoftMax

(

)

Definition at line 506 of file cu-vector-test.cc.

References CuVectorBase< Real >::ApplySoftMax(), VectorBase< Real >::ApplySoftMax(), AssertEqual(), rnnlm::i, Rand(), and CuVectorBase< Real >::SetRandn().

                                                            {
  for (int32 i = 0; i < 10; i++) {
    int32 dim = 100 + Rand() % 300;
    //int32 dim = 1024;
    CuVector<Real> cu_vector(dim);
    cu_vector.SetRandn();
    Vector<Real> vector(cu_vector);

    cu_vector.ApplySoftMax();
    vector.ApplySoftMax();
    CuVector<Real> cu_vector2(vector);
    //std::cout<<cu_vector <<"\n"<<cu_vector2<<std::endl;
    AssertEqual(cu_vector, cu_vector2);
  }
}

CuVectorUnitTestApproxEqual()

void kaldi::CuVectorUnitTestApproxEqual

(

)

Definition at line 280 of file cu-vector-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and CuVectorBase< Real >::SetRandn().

                                                           {
  int32 M = 10 + Rand() % 100;
  CuVector<Real> vec1(M), vec2(M);
  vec1.SetRandn();
  vec2.SetRandn();
  Real tol = 0.5;
  for (int32 i = 0; i < 10; i++) {
    Real sumsq = 0.0, sumsq_orig = 0.0;
    for (int32 j = 0; j < M; j++) {
      sumsq += (vec1(j) - vec2(j)) * (vec1(j) - vec2(j));
      sumsq_orig += vec1(j) * vec1(j);
    }
    Real rms = sqrt(sumsq), rms_orig = sqrt(sumsq_orig);
    KALDI_ASSERT(vec1.ApproxEqual(vec2, tol) == (rms <= tol * rms_orig));
    tol *= 2.0;
  }
}

CuVectorUnitTestCopyCross()

void kaldi::CuVectorUnitTestCopyCross

(

)

Definition at line 424 of file cu-vector-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyFromVec(), rnnlm::i, Rand(), and CuVectorBase< Real >::SetRandn().

                                                         {
  for (int32 i = 0; i < 10; i++) {
    int32 M = 100 + Rand() % 255;
    if (Rand() % 3 == 0) M = 0;
    CuVector<Real> v1(M);
    v1.SetRandn();
    CuVector<float> v2(M);
    v2.CopyFromVec(v1);
    CuVector<Real> v3(M);
    v3.CopyFromVec(v2);
    AssertEqual(v1, v3);
  }
}

CuVectorUnitTestCopyCross2()

void kaldi::CuVectorUnitTestCopyCross2

(

)

Definition at line 438 of file cu-vector-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyFromVec(), VectorBase< Real >::CopyFromVec(), rnnlm::i, Rand(), and CuVectorBase< Real >::SetRandn().

                                                          {
  for (int32 i = 0; i < 10; i++) {
    int32 M = 100 + Rand() % 255;
    if (Rand() % 3 == 0) M = 0;
    CuVector<Real> v1(M);
    v1.SetRandn();
    Vector<float> v2(M);
    v2.CopyFromVec(v1);
    CuVector<Real> v3(M);
    v3.CopyFromVec(v2);
    AssertEqual(v1, v3);
  }
}

CuVectorUnitTestCopyDiagFromMat()

void kaldi::CuVectorUnitTestCopyDiagFromMat

(

)

Definition at line 452 of file cu-vector-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyDiagFromMat(), VectorBase< Real >::CopyDiagFromMat(), rnnlm::i, kUndefined, Rand(), MatrixBase< Real >::SetRandn(), CuVectorBase< Real >::Sum(), VectorBase< Real >::Sum(), MatrixBase< Real >::Trace(), CuMatrixBase< Real >::Trace(), and Matrix< Real >::Transpose().

                                                               {
  for (int32 i = 0; i < 5; i++) {
    int32 M = 100 + Rand() % 255, N = M + Rand() % 2;
    Matrix<Real> matrix(M, N);
    if (i % 2 == 0) matrix.Transpose();
    matrix.SetRandn();
    Vector<Real> vector(M, kUndefined);
    vector.CopyDiagFromMat(matrix);

    CuMatrix<Real> cuda_matrix(matrix);
    CuVector<Real> cuda_vector(M, kUndefined);
    cuda_vector.CopyDiagFromMat(cuda_matrix);
    Vector<Real> vector2(cuda_vector);
    AssertEqual(vector, vector2);
    AssertEqual(vector.Sum(), cuda_matrix.Trace(false));
    AssertEqual(cuda_vector.Sum(), matrix.Trace(false));
  }
}

CuVectorUnitTestCopyDiagFromPacked()

void kaldi::CuVectorUnitTestCopyDiagFromPacked

(

)

Definition at line 409 of file cu-vector-test.cc.

References VectorBase< Real >::ApproxEqual(), CuVectorBase< Real >::CopyDiagFromPacked(), VectorBase< Real >::CopyDiagFromPacked(), rnnlm::i, KALDI_ASSERT, kUndefined, Rand(), and CuPackedMatrix< Real >::SetRandn().

                                                                  {
  for (int32 i = 0; i < 5; i++) {
    int32 N = 100 + Rand() % 255;
    CuSpMatrix<Real> S(N);
    S.SetRandn();
    CuVector<Real> V(N, kUndefined);
    V.CopyDiagFromPacked(S);
    SpMatrix<Real> cpu_S(S);
    Vector<Real> cpu_V(N);
    cpu_V.CopyDiagFromPacked(cpu_S);
    Vector<Real> cpu_V2(V);
    KALDI_ASSERT(cpu_V.ApproxEqual(cpu_V2));
  }
}

CuVectorUnitTestCopyElements()

void kaldi::CuVectorUnitTestCopyElements

(

)

Definition at line 207 of file cu-vector-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyElements(), rnnlm::i, rnnlm::j, kNoTrans, kTrans, kUndefined, rnnlm::n, Rand(), CuMatrix< Real >::Resize(), CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                            {
  int32 dim = 10 + Rand() % 100, N = 20 + Rand() % 50;
  CuVector<Real> V(dim);
  V.SetRandn();
  CuVector<Real> V_copy(V);
  for (int n = 0; n < 2; n++) {
    bool transpose = (n == 0);
    CuMatrix<Real> M;
    if (!transpose)
      M.Resize(dim, N, kUndefined);
    else
      M.Resize(N, dim, kUndefined);
    M.SetRandn();
    std::vector<int32> elements(dim);
    for (int32 i = 0; i < dim; i++) {
      int32 j = elements[i] = Rand() % N;
      if (!transpose)
        V_copy(i) = M(i, j);
      else
        V_copy(i) = M(j, i);
    }
    CuArray<int32> cu_elements(elements);
    V.CopyElements(M, transpose ? kTrans : kNoTrans, cu_elements);
    AssertEqual(V, V_copy);
  }
}

CuVectorUnitTestCopyFromMat()

void kaldi::CuVectorUnitTestCopyFromMat

(

)

Definition at line 375 of file cu-vector-test.cc.

References CuVectorBase< Real >::CopyColFromMat(), CuVectorBase< Real >::CopyRowsFromMat(), VectorBase< Real >::CopyRowsFromMat(), MatrixBase< Real >::CopyRowsFromVec(), CuMatrixBase< Real >::CopyRowsFromVec(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                                           {
  int32 M = 100 + Rand() % 255, N = 100 + Rand() % 255;
  CuMatrix<Real> cu_matrix(M, N);
  cu_matrix.SetRandn();
  for(int32 i = 0; i < N; i++) {
    CuVector<Real> vector(M);
    vector.CopyColFromMat(cu_matrix, i);
    for(int32 j = 0; j < M; j++) {
      KALDI_ASSERT(vector(j)==cu_matrix(j, i));
    }
  }
  Matrix<Real> matrix(cu_matrix), matrix2(M, N);
  CuMatrix<Real> matrix3(M, N);

  CuVector<Real> vector(M * N), vector2(M * N);
  vector.CopyRowsFromMat(cu_matrix);
  vector2.CopyRowsFromMat(matrix);
  matrix2.CopyRowsFromVec(vector2);
  matrix3.CopyRowsFromVec(Vector<Real>(vector2));
  Vector<Real> vector3(M * N);
  vector3.CopyRowsFromMat(cu_matrix);


  for(int32 j = 0; j < M*N; j++) {
    if (Rand() % 500 == 0) { // random small subset (it was slow)
      KALDI_ASSERT(vector(j) == cu_matrix(j/N, j%N));
      KALDI_ASSERT(vector2(j) == cu_matrix(j/N, j%N));
      KALDI_ASSERT(vector2(j) == matrix2(j/N, j%N));
      KALDI_ASSERT(vector3(j) == matrix2(j/N, j%N));
      KALDI_ASSERT(vector3(j) == matrix3(j/N, j%N));
    }
  }
}

CuVectorUnitTestInvertElements()

void kaldi::CuVectorUnitTestInvertElements

(

)

Definition at line 327 of file cu-vector-test.cc.

References AssertEqual(), CuVectorBase< Real >::InvertElements(), CuVectorBase< Real >::MulElements(), Rand(), CuVectorBase< Real >::SetRandn(), and VecVec().

                                                              {
  // Also tests MulElements();
  int32 M = 256 + Rand() % 100;
  CuVector<Real> vec1(M);
  vec1.SetRandn();
  CuVector<Real> vec2(vec1);
  vec2.InvertElements();
  CuVector<Real> vec3(vec1);
  vec3.MulElements(vec2);
  // vec3 should be all ones.
  Real prod = VecVec(vec3, vec3);
  AssertEqual(prod, static_cast<Real>(M));
}

CuVectorUnitTestMax()

void kaldi::CuVectorUnitTestMax

(

)

Definition at line 494 of file cu-vector-test.cc.

References KALDI_ASSERT, CuVectorBase< Real >::Max(), VectorBase< Real >::Max(), Rand(), and CuVectorBase< Real >::SetRandn().

                                                   {
  for (int32 p = 1; p <= 1000000; p *= 2) {
    int32 dim = p + Rand() % 500;
    CuVector<Real> cu_vector(dim);
    cu_vector.SetRandn();
    Vector<Real> vector(cu_vector);
    Real max1 = cu_vector.Max(), max2 = vector.Max();
    KALDI_ASSERT(max1 == max2);
  }
}

CuVectorUnitTestMin()

void kaldi::CuVectorUnitTestMin

(

)

Definition at line 482 of file cu-vector-test.cc.

References KALDI_ASSERT, CuVectorBase< Real >::Min(), VectorBase< Real >::Min(), Rand(), and CuVectorBase< Real >::SetRandn().

                                                   {
  for (int32 p = 1; p <= 1000000; p *= 2) {
    int32 dim = p + Rand() % 500;
    CuVector<Real> cu_vector(dim);
    cu_vector.SetRandn();
    Vector<Real> vector(cu_vector);
    Real min1 = cu_vector.Min(), min2 = vector.Min();
    KALDI_ASSERT(min1 == min2);
  }
}

CuVectorUnitTestNorm()

void kaldi::CuVectorUnitTestNorm

(

)

Definition at line 472 of file cu-vector-test.cc.

References ApproxEqual(), KALDI_ASSERT, and CuVectorBase< Real >::Norm().

                                                    {
  int32 dim = 2;
  CuVector<Real> cu_vector(dim);
  cu_vector(0) = 1.0;
  cu_vector(1) = -2.0;
  KALDI_ASSERT(ApproxEqual(cu_vector.Norm(1.0), 3.0));
  KALDI_ASSERT(ApproxEqual(cu_vector.Norm(2.0), sqrt(5.0)));
}

CuVectorUnitTestScale()

void kaldi::CuVectorUnitTestScale

(

)

Definition at line 361 of file cu-vector-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, Rand(), CuVectorBase< Real >::Scale(), VectorBase< Real >::Scale(), and CuVectorBase< Real >::SetRandn().

                                                     {
  for (int32 i = 0; i < 4; i++) {
    int32 dim = 100 + Rand() % 400;
    CuVector<Real> cu_vec(dim);
    cu_vec.SetRandn();
    Vector<Real> vec(cu_vec);
    BaseFloat scale = 0.333;
    cu_vec.Scale(scale);
    vec.Scale(scale);
    Vector<Real> vec2(cu_vec);
    KALDI_ASSERT(ApproxEqual(vec, vec2));
  }
}

CuVectorUnitTestSum()

void kaldi::CuVectorUnitTestSum

(

)

Definition at line 341 of file cu-vector-test.cc.

References VectorBase< Real >::ApplyAbs(), KALDI_ASSERT, Rand(), CuVectorBase< Real >::Set(), VectorBase< Real >::Sum(), and VecVec().

                                                   {
  for (int32 p = 1; p <= 1000000; p *= 2) {
    MatrixIndexT dim = p + Rand() % 500;
    CuVector<Real> A(dim), ones(dim);
    A.SetRandn();
    ones.Set(1.0);

    Real x = VecVec(A, ones);
    Real y = A.Sum();
    Real diff = std::abs(x - y);
    // Note: CuVectorBase<> does not have an ApplyAbs() member
    // function, so we copy back to a host vector for simplicity in
    // this test case.
    Vector<Real> A_host(A);
    A_host.ApplyAbs();
    Real s = A_host.Sum();
    KALDI_ASSERT ( diff <= 1.0e-04 * s);
  }
}

CuVectorUnitTestVecVec()

void kaldi::CuVectorUnitTestVecVec

(

)

Definition at line 144 of file cu-vector-test.cc.

References AssertEqual(), rnnlm::i, Rand(), CuVectorBase< Real >::SetRandn(), and VecVec().

                                                      {
  int32 M = 10 + Rand() % 100;
  CuVector<Real> vec1(M), vec2(M);
  vec1.SetRandn();
  vec2.SetRandn();
  Real prod = 0.0;
  for (int32 i = 0; i < M; i++)
    prod += vec1(i) * vec2(i);
  AssertEqual(prod, VecVec(vec1, vec2));
}

cygprefix()

static std::string kaldi::cygprefix ( "/cygdrive/"  )

static

Referenced by prefixp().

CygwinCompatPopen()

static FILE* kaldi::CygwinCompatPopen ( const char *  command, const char *  mode  )

static

Definition at line 110 of file kaldi-cygwin-io-inl.h.

                                                                      {
  // To speed up command launch marginally, optionally accept full path
  // to bash.exe. This will not work if the path contains spaces, but
  // no sane person would install cygwin into a space-ridden path.
  const char* bash_exe = std::getenv("BASH_EXE");
  std::string qcmd(bash_exe != nullptr ? bash_exe : "bash.exe");
  qcmd += " -c \"";
  for (; *command; ++command) {
    if (*command == '\"')
      qcmd += '\"';
    qcmd += *command;
  }
  qcmd += '\"';

  return _popen(qcmd.c_str(), mode);
}

DecodeLabelUid()

StateId kaldi::DecodeLabelUid

(

uint64

osymbol

)

Definition at line 42 of file kws-search.cc.

Referenced by main(), and OutputDetailedStatistics().

                                       {
  return static_cast<StateId>(osymbol >> 32);
}

DecodeUtterance()

bool kaldi::DecodeUtterance	(	LatticeBiglmFasterDecoder &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

Definition at line 36 of file gmm-latgen-biglm-faster.cc.

References fst::AcousticLatticeScale(), LatticeBiglmFasterDecoder::Decode(), LatticeFasterDecoderConfig::det_opts, fst::DeterminizeLatticePhonePrunedWrapper(), LatticeBiglmFasterDecoder::GetBestPath(), fst::GetLinearSymbolSequence(), LatticeBiglmFasterDecoder::GetOptions(), LatticeBiglmFasterDecoder::GetRawLattice(), rnnlm::i, TableWriter< Holder >::IsOpen(), KALDI_ERR, KALDI_LOG, KALDI_VLOG, KALDI_WARN, LatticeFasterDecoderConfig::lattice_beam, LatticeBiglmFasterDecoder::ReachedFinal(), fst::ScaleLattice(), LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), words, and TableWriter< Holder >::Write().

Referenced by main().

                                       {  // puts utterance's like in like_ptr on success.
  using fst::VectorFst;

  if (!decoder.Decode(&decodable)) {
    KALDI_WARN << "Failed to decode file " << utt;
    return false;
  }
  if (!decoder.ReachedFinal()) {
    if (allow_partial) {
      KALDI_WARN << "Outputting partial output for utterance " << utt
                 << " since no final-state reached\n";
    } else {
      KALDI_WARN << "Not producing output for utterance " << utt
                 << " since no final-state reached and "
                 << "--allow-partial=false.\n";
      return false;
    }
  }

  double likelihood;
  LatticeWeight weight;
  int32 num_frames;
  { // First do some stuff with word-level traceback...
    VectorFst<LatticeArc> decoded;
    decoder.GetBestPath(&decoded);
    if (decoded.NumStates() == 0)
      // Shouldn't really reach this point as already checked success.
      KALDI_ERR << "Failed to get traceback for utterance " << utt;

    std::vector<int32> alignment;
    std::vector<int32> words;
    GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
    num_frames = alignment.size();
    if (words_writer->IsOpen())
      words_writer->Write(utt, words);
    if (alignment_writer->IsOpen())
      alignment_writer->Write(utt, alignment);
    if (word_syms != NULL) {
      std::cerr << utt << ' ';
      for (size_t i = 0; i < words.size(); i++) {
        std::string s = word_syms->Find(words[i]);
        if (s == "")
          KALDI_ERR << "Word-id " << words[i] <<" not in symbol table.";
        std::cerr << s << ' ';
      }
      std::cerr << '\n';
    }
    likelihood = -(weight.Value1() + weight.Value2());
  }

  // Get lattice, and do determinization if requested.
  Lattice lat;
  decoder.GetRawLattice(&lat);
  if (lat.NumStates() == 0)
    KALDI_ERR << "Unexpected problem getting lattice for utterance " << utt;
  fst::Connect(&lat);
  if (determinize) {
    CompactLattice clat;
    if (!DeterminizeLatticePhonePrunedWrapper(
            trans_model,
            &lat,
            decoder.GetOptions().lattice_beam,
            &clat,
            decoder.GetOptions().det_opts))
      KALDI_WARN << "Determinization finished earlier than the beam for "
                 << "utterance " << utt;
    // We'll write the lattice without acoustic scaling.
    if (acoustic_scale != 0.0)
      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &clat);
    compact_lattice_writer->Write(utt, clat);
  } else {
    Lattice fst;
    decoder.GetRawLattice(&fst);
    if (fst.NumStates() == 0)
      KALDI_ERR << "Unexpected problem getting lattice for utterance "
                << utt;
    fst::Connect(&fst); // Will get rid of this later... shouldn't have any
    // disconnected states there, but we seem to.
    if (acoustic_scale != 0.0) // We'll write the lattice without acoustic scaling
      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &fst); 
    lattice_writer->Write(utt, fst);
  }
  KALDI_LOG << "Log-like per frame for utterance " << utt << " is "
            << (likelihood / num_frames) << " over "
            << num_frames << " frames.";
  KALDI_VLOG(2) << "Cost for utterance " << utt << " is "
                << weight.Value1() << " + " << weight.Value2();
  *like_ptr = likelihood;
  return true;
}

DecodeUtteranceLatticeFaster() [1/3]

bool DecodeUtteranceLatticeFaster	(	LatticeFasterDecoderTpl< FST > &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignments_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

This function DecodeUtteranceLatticeFaster is used in several decoders, and we have moved it here.

Note: this is really "binary-level" code as it involves table readers and writers; we've just put it here as there is no other obvious place to put it. If determinize == false, it writes to lattice_writer, else to compact_lattice_writer. The writers for alignments and words will only be written to if they are open.

Caution: this will only link correctly if FST is either fst::Fst<fst::StdArc>, or fst::GrammarFst, as the template function is defined in the .cc file and only instantiated for those two types.

Definition at line 287 of file decoder-wrappers.cc.

References fst::AcousticLatticeScale(), LatticeFasterDecoderTpl< FST, Token >::Decode(), DecodeUtteranceLatticeIncremental(), fst::DeterminizeLatticePhonePrunedWrapper(), LatticeFasterDecoderTpl< FST, Token >::GetBestPath(), fst::GetLinearSymbolSequence(), LatticeFasterDecoderTpl< FST, Token >::GetOptions(), LatticeFasterDecoderTpl< FST, Token >::GetRawLattice(), rnnlm::i, TableWriter< Holder >::IsOpen(), KALDI_ERR, KALDI_LOG, KALDI_VLOG, KALDI_WARN, LatticeFasterDecoderTpl< FST, Token >::ReachedFinal(), fst::ScaleLattice(), LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), words, and TableWriter< Holder >::Write().

Referenced by main(), ProcessUtterance(), and AlignConfig::Register().

                      { // puts utterance's like in like_ptr on success.
  using fst::VectorFst;

  if (!decoder.Decode(&decodable)) {
    KALDI_WARN << "Failed to decode utterance with id " << utt;
    return false;
  }
  if (!decoder.ReachedFinal()) {
    if (allow_partial) {
      KALDI_WARN << "Outputting partial output for utterance " << utt
                 << " since no final-state reached\n";
    } else {
      KALDI_WARN << "Not producing output for utterance " << utt
                 << " since no final-state reached and "
                 << "--allow-partial=false.\n";
      return false;
    }
  }

  double likelihood;
  LatticeWeight weight;
  int32 num_frames;
  { // First do some stuff with word-level traceback...
    VectorFst<LatticeArc> decoded;
    if (!decoder.GetBestPath(&decoded))
      // Shouldn't really reach this point as already checked success.
      KALDI_ERR << "Failed to get traceback for utterance " << utt;

    std::vector<int32> alignment;
    std::vector<int32> words;
    GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
    num_frames = alignment.size();
    if (words_writer->IsOpen())
      words_writer->Write(utt, words);
    if (alignment_writer->IsOpen())
      alignment_writer->Write(utt, alignment);
    if (word_syms != NULL) {
      std::cerr << utt << ' ';
      for (size_t i = 0; i < words.size(); i++) {
        std::string s = word_syms->Find(words[i]);
        if (s == "")
          KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
        std::cerr << s << ' ';
      }
      std::cerr << '\n';
    }
    likelihood = -(weight.Value1() + weight.Value2());
  }

  // Get lattice, and do determinization if requested.
  Lattice lat;
  decoder.GetRawLattice(&lat);
  if (lat.NumStates() == 0)
    KALDI_ERR << "Unexpected problem getting lattice for utterance " << utt;
  fst::Connect(&lat);
  if (determinize) {
    CompactLattice clat;
    if (!DeterminizeLatticePhonePrunedWrapper(
            trans_model,
            &lat,
            decoder.GetOptions().lattice_beam,
            &clat,
            decoder.GetOptions().det_opts))
      KALDI_WARN << "Determinization finished earlier than the beam for "
                 << "utterance " << utt;
    // We'll write the lattice without acoustic scaling.
    if (acoustic_scale != 0.0)
      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &clat);
    compact_lattice_writer->Write(utt, clat);
  } else {
    // We'll write the lattice without acoustic scaling.
    if (acoustic_scale != 0.0)
      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &lat);
    lattice_writer->Write(utt, lat);
  }
  KALDI_LOG << "Log-like per frame for utterance " << utt << " is "
            << (likelihood / num_frames) << " over "
            << num_frames << " frames.";
  KALDI_VLOG(2) << "Cost for utterance " << utt << " is "
                << weight.Value1() << " + " << weight.Value2();
  *like_ptr = likelihood;
  return true;
}

DecodeUtteranceLatticeFaster() [2/3]

template bool kaldi::DecodeUtteranceLatticeFaster	(	LatticeFasterDecoderTpl< fst::Fst< fst::StdArc > > &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

DecodeUtteranceLatticeFaster() [3/3]

template bool kaldi::DecodeUtteranceLatticeFaster	(	LatticeFasterDecoderTpl< fst::GrammarFst > &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

DecodeUtteranceLatticeIncremental() [1/3]

bool DecodeUtteranceLatticeIncremental	(	LatticeIncrementalDecoderTpl< FST > &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

TODO.

Definition at line 199 of file decoder-wrappers.cc.

References fst::AcousticLatticeScale(), CompactLatticeShortestPath(), fst::ConvertLattice(), LatticeIncrementalDecoderTpl< FST, Token >::Decode(), LatticeIncrementalDecoderTpl< FST, Token >::GetLattice(), fst::GetLinearSymbolSequence(), rnnlm::i, TableWriter< Holder >::IsOpen(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, KALDI_VLOG, KALDI_WARN, LatticeIncrementalDecoderTpl< FST, Token >::NumFramesDecoded(), LatticeIncrementalDecoderTpl< FST, Token >::ReachedFinal(), fst::ScaleLattice(), LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), words, and TableWriter< Holder >::Write().

Referenced by DecodeUtteranceLatticeFaster(), main(), and AlignConfig::Register().

                      { // puts utterance's like in like_ptr on success.
  using fst::VectorFst;
  if (!decoder.Decode(&decodable)) {
    KALDI_WARN << "Failed to decode utterance with id " << utt;
    return false;
  }
  if (!decoder.ReachedFinal()) {
    if (allow_partial) {
      KALDI_WARN << "Outputting partial output for utterance " << utt
                 << " since no final-state reached\n";
    } else {
      KALDI_WARN << "Not producing output for utterance " << utt
                 << " since no final-state reached and "
                 << "--allow-partial=false.\n";
      return false;
    }
  }

  // Get lattice
  CompactLattice clat = decoder.GetLattice(decoder.NumFramesDecoded(), true);
  if (clat.NumStates() == 0)
    KALDI_ERR << "Unexpected problem getting lattice for utterance " << utt;

  double likelihood;
  LatticeWeight weight;
  int32 num_frames;
  { // First do some stuff with word-level traceback...
    CompactLattice decoded_clat;
    CompactLatticeShortestPath(clat, &decoded_clat);
    Lattice decoded;
    fst::ConvertLattice(decoded_clat, &decoded);

    if (decoded.Start() == fst::kNoStateId)
      // Shouldn't really reach this point as already checked success.
      KALDI_ERR << "Failed to get traceback for utterance " << utt;

    std::vector<int32> alignment;
    std::vector<int32> words;
    GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
    num_frames = alignment.size();
    KALDI_ASSERT(num_frames == decoder.NumFramesDecoded());
    if (words_writer->IsOpen())
      words_writer->Write(utt, words);
    if (alignment_writer->IsOpen())
      alignment_writer->Write(utt, alignment);
    if (word_syms != NULL) {
      std::cerr << utt << ' ';
      for (size_t i = 0; i < words.size(); i++) {
        std::string s = word_syms->Find(words[i]);
        if (s == "")
          KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
        std::cerr << s << ' ';
      }
      std::cerr << '\n';
    }
    likelihood = -(weight.Value1() + weight.Value2());
  }

  // We'll write the lattice without acoustic scaling.
  if (acoustic_scale != 0.0)
    fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &clat);
  Connect(&clat);
  compact_lattice_writer->Write(utt, clat);
  KALDI_LOG << "Log-like per frame for utterance " << utt << " is "
            << (likelihood / num_frames) << " over "
            << num_frames << " frames.";
  KALDI_VLOG(2) << "Cost for utterance " << utt << " is "
                << weight.Value1() << " + " << weight.Value2();
  *like_ptr = likelihood;
  return true;
}

DecodeUtteranceLatticeIncremental() [2/3]

template bool kaldi::DecodeUtteranceLatticeIncremental	(	LatticeIncrementalDecoderTpl< fst::Fst< fst::StdArc > > &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

DecodeUtteranceLatticeIncremental() [3/3]

template bool kaldi::DecodeUtteranceLatticeIncremental	(	LatticeIncrementalDecoderTpl< fst::GrammarFst > &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

DecodeUtteranceLatticeSimple()

bool DecodeUtteranceLatticeSimple	(	LatticeSimpleDecoder &	decoder,
		DecodableInterface &	decodable,
		const TransitionModel &	trans_model,
		const fst::SymbolTable *	word_syms,
		std::string	utt,
		double	acoustic_scale,
		bool	determinize,
		bool	allow_partial,
		Int32VectorWriter *	alignment_writer,
		Int32VectorWriter *	words_writer,
		CompactLatticeWriter *	compact_lattice_writer,
		LatticeWriter *	lattice_writer,
		double *	like_ptr
	)

Definition at line 448 of file decoder-wrappers.cc.

References fst::AcousticLatticeScale(), LatticeSimpleDecoder::Decode(), LatticeSimpleDecoderConfig::det_opts, fst::DeterminizeLatticePhonePrunedWrapper(), LatticeSimpleDecoder::GetBestPath(), fst::GetLinearSymbolSequence(), LatticeSimpleDecoder::GetOptions(), LatticeSimpleDecoder::GetRawLattice(), rnnlm::i, TableWriter< Holder >::IsOpen(), KALDI_ERR, KALDI_LOG, KALDI_VLOG, KALDI_WARN, LatticeSimpleDecoderConfig::lattice_beam, LatticeSimpleDecoder::ReachedFinal(), fst::ScaleLattice(), LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), words, TableWriter< Holder >::Write(), and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by main().

                      { // puts utterance's like in like_ptr on success.
  using fst::VectorFst;

  if (!decoder.Decode(&decodable)) {
    KALDI_WARN << "Failed to decode utterance with id " << utt;
    return false;
  }
  if (!decoder.ReachedFinal()) {
    if (allow_partial) {
      KALDI_WARN << "Outputting partial output for utterance " << utt
                 << " since no final-state reached\n";
    } else {
      KALDI_WARN << "Not producing output for utterance " << utt
                 << " since no final-state reached and "
                 << "--allow-partial=false.\n";
      return false;
    }
  }

  double likelihood;
  LatticeWeight weight = LatticeWeight::Zero();
  int32 num_frames;
  { // First do some stuff with word-level traceback...
    VectorFst<LatticeArc> decoded;
    if (!decoder.GetBestPath(&decoded))
      // Shouldn't really reach this point as already checked success.
      KALDI_ERR << "Failed to get traceback for utterance " << utt;

    std::vector<int32> alignment;
    std::vector<int32> words;
    GetLinearSymbolSequence(decoded, &alignment, &words, &weight);
    num_frames = alignment.size();
    if (words_writer->IsOpen())
      words_writer->Write(utt, words);
    if (alignment_writer->IsOpen())
      alignment_writer->Write(utt, alignment);
    if (word_syms != NULL) {
      std::cerr << utt << ' ';
      for (size_t i = 0; i < words.size(); i++) {
        std::string s = word_syms->Find(words[i]);
        if (s == "")
          KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
        std::cerr << s << ' ';
      }
      std::cerr << '\n';
    }
    likelihood = -(weight.Value1() + weight.Value2());
  }

  // Get lattice, and do determinization if requested.
  Lattice lat;
  if (!decoder.GetRawLattice(&lat))
    KALDI_ERR << "Unexpected problem getting lattice for utterance " << utt;
  fst::Connect(&lat);
  if (determinize) {
    CompactLattice clat;
    if (!DeterminizeLatticePhonePrunedWrapper(
            trans_model,
            &lat,
            decoder.GetOptions().lattice_beam,
            &clat,
            decoder.GetOptions().det_opts))
      KALDI_WARN << "Determinization finished earlier than the beam for "
                 << "utterance " << utt;
    // We'll write the lattice without acoustic scaling.
    if (acoustic_scale != 0.0)
      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &clat);
    compact_lattice_writer->Write(utt, clat);
  } else {
    // We'll write the lattice without acoustic scaling.
    if (acoustic_scale != 0.0)
      fst::ScaleLattice(fst::AcousticLatticeScale(1.0 / acoustic_scale), &lat);
    lattice_writer->Write(utt, lat);
  }
  KALDI_LOG << "Log-like per frame for utterance " << utt << " is "
            << (likelihood / num_frames) << " over "
            << num_frames << " frames.";
  KALDI_VLOG(2) << "Cost for utterance " << utt << " is "
                << weight.Value1() << " + " << weight.Value2();
  *like_ptr = likelihood;
  return true;
}

DeletePointers()

void kaldi::DeletePointers

(

std::vector< A *> *

v

)

Deletes any non-NULL pointers in the vector v, and sets the corresponding entries of v to NULL.

Definition at line 184 of file stl-utils.h.

References KALDI_ASSERT.

Referenced by AutomaticallyObtainQuestions(), BlockAffineComponent::Backprop(), RegressionTree::BuildTree(), ClusterEventMap(), ClusterEventMapGetMapping(), ClusterEventMapRestrictedByKeys(), ClusterEventMapRestrictedByMap(), ClusterEventMapToNClustersRestrictedByMap(), ClusterGaussiansToUbm(), ClusterKMeans(), ComputeInitialSplit(), AmDiagGmm::CopyFromAmDiagGmm(), DoTableSplit(), FindBestSplitForKey(), RegressionTree::GatherStats(), GetHTransducer(), AmDiagGmm::Init(), AccumAmDiagGmm::Init(), RegtreeMllrDiagGmmAccs::Init(), RegtreeFmllrDiagGmmAccs::Init(), CompositeComponent::Init(), InitAmGmm(), DecodableAmDiagGmmRegtreeMllr::InitCache(), CompositeComponent::InitFromConfig(), KMeansClusterPhones(), main(), MapEventMapLeaves(), DiagGmm::MergeKmeans(), ObjfGivenMap(), BlockAffineComponent::Propagate(), Questions::Read(), RenumberEventMap(), ShareEventMapLeaves(), TestAddToClusters(), TestAddToClustersOptimized(), TestClusterBottomUp(), TestClusterEventMapGetMappingAndRenumberEventMap(), TestClusterEventMapGetMappingAndRenumberEventMap2(), TestClusterKMeans(), TestClusterKMeansVector(), TestClusterTopDown(), TestEnsureClusterableVectorNotNull(), TestRefineClusters(), TestTreeCluster(), TypeOneUsage(), TypeOneUsageAverage(), UnitTestRegtreeFmllrDiagGmm(), RegtreeMllrDiagGmmAccs::Update(), RegtreeFmllrDiagGmmAccs::Update(), AccumAmDiagGmm::~AccumAmDiagGmm(), AmDiagGmm::~AmDiagGmm(), BottomUpClusterer::~BottomUpClusterer(), CompartmentalizedBottomUpClusterer::~CompartmentalizedBottomUpClusterer(), CompositeComponent::~CompositeComponent(), DecodableAmDiagGmmRegtreeMllr::~DecodableAmDiagGmmRegtreeMllr(), DecodableAmNnetSimpleParallel::~DecodableAmNnetSimpleParallel(), GeneralDescriptor::~GeneralDescriptor(), Questions::~Questions(), RegtreeFmllrDiagGmmAccs::~RegtreeFmllrDiagGmmAccs(), RegtreeMllrDiagGmmAccs::~RegtreeMllrDiagGmmAccs(), SwitchingForwardingDescriptor::~SwitchingForwardingDescriptor(), TableEventMap::~TableEventMap(), and TreeClusterer::~TreeClusterer().

                                      {
  KALDI_ASSERT(v != NULL);
  typename std::vector<A*>::iterator iter = v->begin(), end = v->end();
  for (; iter != end; ++iter) {
    if (*iter != NULL) {
      delete *iter;
      *iter = NULL;  // set to NULL for extra safety.
    }
  }
}

DeterminizeLatticeWrapper()

bool DeterminizeLatticeWrapper	(	const Lattice &	lat,
		const std::string &	key,
		bool	prune,
		BaseFloat	beam,
		BaseFloat	beam_ratio,
		int32	max_mem,
		int32	max_loop,
		BaseFloat	delta,
		int32	num_loops,
		CompactLattice *	clat
	)

Definition at line 38 of file lattice-determinize-non-compact.cc.

References DeterminizeLatticeOptions::delta, fst::DeterminizeLattice(), rnnlm::i, KALDI_WARN, DeterminizeLatticeOptions::max_loop, DeterminizeLatticeOptions::max_mem, fst::NumArcs(), and PruneLattice().

Referenced by main().

                                                     {
  fst::DeterminizeLatticeOptions lat_opts;
  lat_opts.max_mem = max_mem;
  lat_opts.max_loop = max_loop;
  lat_opts.delta = delta;
  BaseFloat cur_beam = beam;
  for (int32 i = 0; i < num_loops;) { // we increment i below.

    if (lat.Start() == fst::kNoStateId) {
      KALDI_WARN << "Detected empty lattice, skipping " << key;
      return false;
    }

    // The work gets done in the next line.
    if (DeterminizeLattice(lat, clat, lat_opts, NULL)) {
      if (prune) PruneLattice(cur_beam, clat);
      return true;
    } else { // failed to determinize..
      KALDI_WARN << "Failed to determinize lattice (presumably max-states "
                 << "reached), reducing lattice-beam to "
                 << (cur_beam*beam_ratio) << " and re-trying.";
      for (; i < num_loops; i++) {
        cur_beam *= beam_ratio;
        Lattice pruned_lat(lat);
        PruneLattice(cur_beam, &pruned_lat);
        if (NumArcs(lat) == NumArcs(pruned_lat)) {
          cur_beam *= beam_ratio;
          KALDI_WARN << "Pruning did not have an effect on the original "
                     << "lattice size; reducing beam to "
                     << cur_beam << " and re-trying.";
        } else if (DeterminizeLattice(pruned_lat, clat, lat_opts, NULL)) {
          if (prune) PruneLattice(cur_beam, clat);
          return true;
        } else {
          KALDI_WARN << "Determinization failed again; reducing beam again to "
                     << (cur_beam*beam_ratio) << " and re-trying.";
        }
      }
    }
  }
  KALDI_WARN << "Decreased pruning beam --num-loops=" << num_loops
             << " times and was not able to determinize: failed for "
             << key;
  return false;
}

DiagGmmToStats()

void DiagGmmToStats	(	const DiagGmm &	gmm,
		GmmFlagsType	flags,
		double	state_occ,
		AccumDiagGmm *	dst_stats
	)

Creates stats from the GMM. Resizes them as needed.

Definition at line 339 of file ebw-diag-gmm.cc.

References AccumDiagGmm::AddStatsForComponent(), VectorBase< Real >::AddVec(), VectorBase< Real >::AddVec2(), AugmentGmmFlags(), DiagGmm::Dim(), DiagGmmNormal::means_, DiagGmm::NumGauss(), AccumDiagGmm::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::SetZero(), DiagGmmNormal::vars_, and DiagGmmNormal::weights_.

Referenced by IsmoothStatsAmDiagGmmFromModel(), and EbwWeightOptions::Register().

                                             {
  dst_stats->Resize(gmm, AugmentGmmFlags(flags));
  int32 num_gauss = gmm.NumGauss(), dim = gmm.Dim();
  DiagGmmNormal gmmnormal(gmm);
  Vector<double> x_stats(dim), x2_stats(dim);
  for (int32 g = 0; g < num_gauss; g++) {
    double occ = state_occ * gmmnormal.weights_(g);
    x_stats.SetZero();
    x_stats.AddVec(occ, gmmnormal.means_.Row(g));
    x2_stats.SetZero();
    x2_stats.AddVec2(occ, gmmnormal.means_.Row(g));
    x2_stats.AddVec(occ, gmmnormal.vars_.Row(g));
    dst_stats->AddStatsForComponent(g, occ, x_stats, x2_stats);
  }
}

DifferenceWrapper()

static void kaldi::DifferenceWrapper ( const fst::VectorFst< Arc > &  fst1, const fst::VectorFst< Arc > &  fst2, fst::VectorFst< Arc > *  difference  )

static

Definition at line 303 of file kws-functions.cc.

References fst::RemoveWeights().

Referenced by MaybeDoSanityCheck().

                                                             {
  using namespace fst;
  if (!fst2.Properties(kAcceptor, true)) {
    // make it an acceptor by encoding the weights.
    EncodeMapper<Arc> encoder(kEncodeLabels, ENCODE);
    VectorFst<Arc> fst1_copy(fst1);
    VectorFst<Arc> fst2_copy(fst2);
    Encode(&fst1_copy, &encoder);
    Encode(&fst2_copy, &encoder);
    DifferenceWrapper(fst1_copy, fst2_copy, difference);
    Decode(difference, encoder);
  } else {
    VectorFst<Arc> fst2_copy(fst2);
    RmEpsilon(&fst2_copy);  // or Difference will crash.
    RemoveWeights(&fst2_copy);  // or Difference will crash.
    Difference(fst1, fst2_copy, difference);
  }
}

DirExist()

bool kaldi::DirExist

(

const std::string &

dirname

)

Definition at line 43 of file pitch-functions-test.cc.

References KALDI_LOG.

Referenced by main().

                                        {
  struct stat st;
  if (stat(dirname.c_str(), &st) != 0) {
    KALDI_LOG << " directory " << dirname << " does not exist!";
    return false;
  }
  return true;
}

DivideRoundingDown()

static int32 kaldi::DivideRoundingDown ( int32  a, int32  b  )

inlinestatic

Returns a / b, rounding towards negative infinity in all cases.

Definition at line 287 of file kaldi-math.h.

References KALDI_ASSERT.

Referenced by BackpropTruncationComponent::PrecomputeIndexes(), GeneralDropoutComponent::PrecomputeIndexes(), kaldi::nnet3::time_height_convolution::RoundDownToMultipleOf(), and UnitTestDivideRoundingDown().

                                                         {
  KALDI_ASSERT(b != 0);
  if (a * b >= 0)
    return a / b;
  else if (a < 0)
    return (a - b + 1) / b;
  else
    return (a - b - 1) / b;
}

DoFactorDisambiguation()

void DoFactorDisambiguation

(

KwsLexicographicFst *

index_transducer

)

Definition at line 98 of file kws-functions2.cc.

Referenced by main().

                                                                   {
  using namespace fst;
  typedef KwsLexicographicArc::StateId StateId;

  StateId ns = index_transducer->NumStates();
  for (StateId s = 0; s < ns; s++) {
    for (MutableArcIterator<KwsLexicographicFst>
         aiter(index_transducer, s); !aiter.Done(); aiter.Next()) {
      KwsLexicographicArc arc = aiter.Value();
      if (index_transducer->Final(arc.nextstate) != KwsLexicographicWeight::Zero())
        arc.ilabel = s;
      else
        arc.olabel = 0;
      aiter.SetValue(arc);
    }
  }
}

DoFactorMerging()

void DoFactorMerging	(	KwsProductFst *	factor_transducer,
		KwsLexicographicFst *	index_transducer
	)

Definition at line 53 of file kws-functions2.cc.

References fst::DeterminizeStar(), KALDI_VLOG, MaybeDoSanityCheck(), and ReplaceSymbolWithEpsilon().

Referenced by main().

                                                            {
  using namespace fst;
  typedef KwsProductFst::Arc::Label Label;

  // Encode the transducer first
  EncodeMapper<KwsProductArc> encoder(kEncodeLabels, ENCODE);
  Encode(factor_transducer, &encoder);


  // We want DeterminizeStar to remove epsilon arcs, so turn whatever it encoded
  // epsilons as, into actual epsilons.
  {
    KwsProductArc epsilon_arc(0, 0, KwsProductWeight::One(), 0);
    Label epsilon_label = encoder(epsilon_arc).ilabel;
    ReplaceSymbolWithEpsilon(epsilon_label, factor_transducer);
  }


  MaybeDoSanityCheck(*factor_transducer);

  // Use DeterminizeStar
  KALDI_VLOG(2) << "DoFactorMerging: determinization...";
  KwsProductFst dest_transducer;
  DeterminizeStar(*factor_transducer, &dest_transducer);

  MaybeDoSanityCheck(dest_transducer);

  // Commenting the minimization out, as it moves states/arcs in a way we don't
  // want in some rare cases. For example, if we have two arcs from starting
  // state, which have same words on the input side, but different cluster IDs
  // on the output side, it may make the two arcs sharing a common final arc,
  // which will cause problem in the factor disambiguation stage (we will not
  // be able to add disambiguation symbols for both paths). We do a final step
  // optimization anyway so commenting this out shouldn't matter too much.
  // KALDI_VLOG(2) << "DoFactorMerging: minimization...";
  // Minimize(&dest_transducer);

  MaybeDoSanityCheck(dest_transducer);

  Decode(&dest_transducer, encoder);

  Map(dest_transducer, index_transducer, KwsProductFstToKwsLexicographicFstMapper());
}

DoRescalingUpdate() [1/2]

void kaldi::DoRescalingUpdate	(	const AccumDiagGmm &	old_ml_acc,
		const AccumDiagGmm &	new_ml_acc,
		BaseFloat	min_variance,
		BaseFloat	min_gaussian_occupancy,
		DiagGmm *	gmm,
		double *	tot_count,
		double *	tot_divergence
	)

Definition at line 177 of file indirect-diff-diag-gmm.cc.

References DiagGmmNormal::CopyToDiagGmm(), rnnlm::d, DiagGmm::Dim(), AccumDiagGmm::Dim(), AccumDiagGmm::Flags(), KALDI_ASSERT, KALDI_WARN, kGmmMeans, kGmmVariances, Log(), AccumDiagGmm::mean_accumulator(), DiagGmmNormal::means_, DiagGmm::NumGauss(), AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy(), AccumDiagGmm::variance_accumulator(), and DiagGmmNormal::vars_.

Referenced by DoRescalingUpdate(), and main().

                                               {
  int32 num_gauss = gmm->NumGauss(), dim = gmm->Dim();
  KALDI_ASSERT(old_ml_acc.NumGauss() == num_gauss &&
               old_ml_acc.Dim() == dim);
  KALDI_ASSERT(new_ml_acc.NumGauss() == num_gauss &&
               new_ml_acc.Dim() == dim);
  KALDI_ASSERT((old_ml_acc.Flags() & (kGmmMeans|kGmmVariances)) ==
               (kGmmMeans|kGmmVariances));
  KALDI_ASSERT((new_ml_acc.Flags() & (kGmmMeans|kGmmVariances)) ==
               (kGmmMeans|kGmmVariances));

  DiagGmmNormal gmm_normal(*gmm);
  for (int32 gauss = 0; gauss < num_gauss; gauss++) {
    double old_ml_count = old_ml_acc.occupancy()(gauss),
        new_ml_count = new_ml_acc.occupancy()(gauss);
    if (old_ml_count <= min_gaussian_occupancy ||
        new_ml_count <= min_gaussian_occupancy) {
      KALDI_WARN << "Gaussian being skipped because it has small count: (old,new) = "
                 << old_ml_count << ", " << new_ml_count;
      continue;
    }
    *tot_count += new_ml_count;
    for (int32 d = 0; d < dim; d++) {
      double old_model_mean = gmm_normal.means_(gauss, d),
          old_model_var = gmm_normal.vars_(gauss, d),
          old_ml_mean = old_ml_acc.mean_accumulator()(gauss, d) / old_ml_count,
          old_ml_var = old_ml_acc.variance_accumulator()(gauss, d) / old_ml_count
          - old_ml_mean*old_ml_mean,
          new_ml_mean = new_ml_acc.mean_accumulator()(gauss, d) / new_ml_count,
          new_ml_var = new_ml_acc.variance_accumulator()(gauss, d) / new_ml_count
          - new_ml_mean*new_ml_mean,
          new_model_mean = old_model_mean + new_ml_mean - old_ml_mean,
          new_model_var = std::max(static_cast<double>(min_variance),
                                   old_model_var * new_ml_var / old_ml_var);
      double divergence = 
          0.5 *(((new_model_mean-old_model_mean)*(new_model_mean-old_model_mean) +
                 new_model_var - old_model_var)/old_model_var +
                Log(old_model_var / new_model_var));
      if (divergence < 0.0)
        KALDI_WARN << "Negative divergence " << divergence;
      *tot_divergence += divergence * new_ml_count;
      gmm_normal.means_(gauss, d) = new_model_mean;
      gmm_normal.vars_(gauss, d) = new_model_var;
    }
  }
  gmm_normal.CopyToDiagGmm(gmm);
}

DoRescalingUpdate() [2/2]

void DoRescalingUpdate	(	const AccumAmDiagGmm &	old_ml_accs,
		const AccumAmDiagGmm &	new_ml_accs,
		BaseFloat	min_variance,
		BaseFloat	min_gaussian_occupancy,
		AmDiagGmm *	am_gmm
	)

Definition at line 232 of file indirect-diff-diag-gmm.cc.

References AmDiagGmm::ComputeGconsts(), DoRescalingUpdate(), AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), KALDI_ASSERT, KALDI_LOG, AccumAmDiagGmm::NumAccs(), and AmDiagGmm::NumPdfs().

                                          {
  int32 num_pdfs = am_gmm->NumPdfs();
  KALDI_ASSERT(old_ml_accs.NumAccs() == num_pdfs);
  KALDI_ASSERT(new_ml_accs.NumAccs() == num_pdfs);
  double tot_count = 0.0, tot_divergence = 0.0;
  for (int32 pdf = 0; pdf < num_pdfs; pdf++)
    DoRescalingUpdate(old_ml_accs.GetAcc(pdf), new_ml_accs.GetAcc(pdf),
                      min_variance, min_gaussian_occupancy, &am_gmm->GetPdf(pdf),
                      &tot_count, &tot_divergence);
  KALDI_LOG << "K-L divergence from old to new model is "
            << (tot_divergence/tot_count) << " over "
            << tot_count << " frames.";
  am_gmm->ComputeGconsts();
}

DoReverberation()

float kaldi::DoReverberation	(	const Vector< BaseFloat > &	rir,
		BaseFloat	samp_freq,
		Vector< BaseFloat > *	signal
	)

Definition at line 93 of file wav-reverberate.cc.

References ComputeEarlyReverbEnergy(), and FFTbasedBlockConvolveSignals().

Referenced by main().

                                                   {
  float signal_power = ComputeEarlyReverbEnergy(rir, *signal, samp_freq);
  FFTbasedBlockConvolveSignals(rir, signal);
  return signal_power;
}

DoubleFactorial() [1/2]

static int32 kaldi::DoubleFactorial ( int32  i )

static

Definition at line 444 of file matrix-lib-test.cc.

Referenced by DoubleFactorial(), UnitTestCuMatrixSetRandn(), and UnitTestSetRandn().

                                      {
  if (i <= 0) { return 1; } else { return i * DoubleFactorial(i - 2); }
}

DoubleFactorial() [2/2]

static int32 kaldi::DoubleFactorial ( int32  i )

static

Definition at line 2622 of file cu-matrix-test.cc.

References DoubleFactorial().

                                      {
  if (i <= 0) { return 1; } else { return i * DoubleFactorial(i - 2); }
}

EBWUpdateGaussian()

static bool kaldi::EBWUpdateGaussian ( BaseFloat  D, GmmFlagsType  flags, const VectorBase< double > &  orig_mean, const VectorBase< double > &  orig_var, const VectorBase< double > &  x_stats, const VectorBase< double > &  x2_stats, double  occ, VectorBase< double > *  mean, VectorBase< double > *  var, double *  auxf_impr  )

static

Definition at line 31 of file ebw-diag-gmm.cc.

References VectorBase< Real >::AddVec(), VectorBase< Real >::AddVec2(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), rnnlm::i, KALDI_ASSERT, kGmmMeans, kGmmVariances, Log(), VectorBase< Real >::Min(), VectorBase< Real >::Scale(), and VectorBase< Real >::SetZero().

Referenced by UpdateEbwDiagGmm().

                       {
  if (! (flags&(kGmmMeans|kGmmVariances))) { // nothing to do.
    if (auxf_impr) *auxf_impr = 0.0;
    mean->CopyFromVec(orig_mean);
    var->CopyFromVec(orig_var);
    return true; 
  }   
  KALDI_ASSERT(!( (flags&kGmmVariances) && !(flags&kGmmMeans))
               && "We didn't make the update cover this case sensibly (update vars not means)");
  
  mean->SetZero();
  var->SetZero();
  mean->AddVec(D, orig_mean);
  var->AddVec2(D, orig_mean);
  var->AddVec(D, orig_var);
  mean->AddVec(1.0, x_stats);
  var->AddVec(1.0, x2_stats);
  BaseFloat scale = 1.0 / (occ + D);
  mean->Scale(scale);
  var->Scale(scale);
  var->AddVec2(-1.0, *mean);
  
  if (!(flags&kGmmVariances)) var->CopyFromVec(orig_var);
  if (!(flags&kGmmMeans)) mean->CopyFromVec(orig_mean);

  // Return false if any NaN's.
  for (int32 i = 0; i < mean->Dim(); i++) {
    double m =  ((*mean)(i)), v = ((*var)(i));
    if (m!=m || v!=v || m-m != 0 || v-v != 0) {
      return false;
    }
  }
  
  if (var->Min() > 0.0) {
    if (auxf_impr != NULL) {
      // work out auxf improvement.  
      BaseFloat old_auxf = 0.0, new_auxf = 0.0;
      int32 dim = orig_mean.Dim();
      for (int32 i = 0; i < dim; i++) {
        BaseFloat mean_diff = (*mean)(i) - orig_mean(i);
        old_auxf += (occ+D) * -0.5 * (Log(orig_var(i)) +
                                      ((*var)(i) + mean_diff*mean_diff)
                                      / orig_var(i));
        new_auxf += (occ+D) * -0.5 * (Log((*var)(i)) + 1.0);
        
      }
      *auxf_impr = new_auxf - old_auxf;
    }
    return true;
  } else return false;
}

ElementwiseProductOfFft()

void kaldi::ElementwiseProductOfFft	(	const Vector< BaseFloat > &	a,
		Vector< BaseFloat > *	b
	)

Definition at line 26 of file signal.cc.

References ComplexMul(), VectorBase< Real >::Dim(), and rnnlm::i.

Referenced by FFTbasedBlockConvolveSignals(), and FFTbasedConvolveSignals().

                                                                               {
  int32 num_fft_bins = a.Dim() / 2;
  for (int32 i = 0; i < num_fft_bins; i++) {
    // do complex multiplication
    ComplexMul(a(2*i), a(2*i + 1), &((*b)(2*i)), &((*b)(2*i + 1)));
  }
}

EncodeLabel()

uint64 kaldi::EncodeLabel	(	StateId	ilabel,
		StateId	olabel
	)

Definition at line 35 of file kws-search.cc.

Referenced by main().

                                                   {
  return (static_cast<int64>(olabel) << 32) + static_cast<int64>(ilabel);
}

EndpointDetected< fst::Fst< fst::StdArc > >() [1/2]

template bool kaldi::EndpointDetected< fst::Fst< fst::StdArc > >	(	const OnlineEndpointConfig &	config,
		const TransitionModel &	tmodel,
		BaseFloat	frame_shift_in_seconds,
		const LatticeFasterOnlineDecoderTpl< fst::Fst< fst::StdArc > > &	decoder
	)

EndpointDetected< fst::Fst< fst::StdArc > >() [2/2]

template bool kaldi::EndpointDetected< fst::Fst< fst::StdArc > >	(	const OnlineEndpointConfig &	config,
		const TransitionModel &	tmodel,
		BaseFloat	frame_shift_in_seconds,
		const LatticeIncrementalOnlineDecoderTpl< fst::Fst< fst::StdArc > > &	decoder
	)

EndpointDetected< fst::GrammarFst >() [1/2]

template bool kaldi::EndpointDetected< fst::GrammarFst >	(	const OnlineEndpointConfig &	config,
		const TransitionModel &	tmodel,
		BaseFloat	frame_shift_in_seconds,
		const LatticeFasterOnlineDecoderTpl< fst::GrammarFst > &	decoder
	)

EndpointDetected< fst::GrammarFst >() [2/2]

template bool kaldi::EndpointDetected< fst::GrammarFst >	(	const OnlineEndpointConfig &	config,
		const TransitionModel &	tmodel,
		BaseFloat	frame_shift_in_seconds,
		const LatticeIncrementalOnlineDecoderTpl< fst::GrammarFst > &	decoder
	)

EstimateIvectorsOnline()

double EstimateIvectorsOnline	(	const Matrix< BaseFloat > &	feats,
		const Posterior &	post,
		const IvectorExtractor &	extractor,
		int32	ivector_period,
		int32	num_cg_iters,
		BaseFloat	max_count,
		Matrix< BaseFloat > *	ivectors
	)

Definition at line 1778 of file ivector-extractor.cc.

References IvectorExtractor::IvectorDim(), KALDI_ASSERT, MatrixBase< Real >::NumRows(), IvectorExtractor::PriorOffset(), Matrix< Real >::Resize(), and MatrixBase< Real >::Row().

Referenced by main().

                                 {

  KALDI_ASSERT(ivector_period > 0);
  KALDI_ASSERT(static_cast<int32>(post.size()) == feats.NumRows());
  int32 num_frames = feats.NumRows(),
      num_ivectors = (num_frames + ivector_period - 1) / ivector_period;

  ivectors->Resize(num_ivectors, extractor.IvectorDim());

  OnlineIvectorEstimationStats online_stats(extractor.IvectorDim(),
                                            extractor.PriorOffset(),
                                            max_count);

  double ans = 0.0;

  Vector<double> cur_ivector(extractor.IvectorDim());
  cur_ivector(0) = extractor.PriorOffset();
  for (int32 frame = 0; frame < num_frames; frame++) {
    online_stats.AccStats(extractor,
                          feats.Row(frame),
                          post[frame]);
    if (frame % ivector_period == 0) {
      online_stats.GetIvector(num_cg_iters, &cur_ivector);
      int32 ivector_index = frame / ivector_period;
      ivectors->Row(ivector_index).CopyFromVec(cur_ivector);
      if (ivector_index == num_ivectors - 1)  // last iVector
        ans = online_stats.ObjfChange(cur_ivector);
    }
  }
  return ans;
}

EstimateSgmm2FmllrSubspace()

void EstimateSgmm2FmllrSubspace	(	const SpMatrix< double > &	fmllr_grad_scatter,
		int32	num_fmllr_bases,
		int32	feat_dim,
		Sgmm2FmllrGlobalParams *	fmllr_globals,
		double	min_eig = 0.0
	)

Computes the fMLLR basis matrices given the scatter of the vectorized gradients (eq: B.10).

The result is stored in 'fmllr_globals'. The actual number of bases may be less than 'num_fmllr_bases' depending on the feature dimension and number of eigenvalues greater than 'min_eig'.

Definition at line 506 of file fmllr-sgmm2.cc.

References VectorBase< Real >::Dim(), SpMatrix< Real >::Eig(), Sgmm2FmllrGlobalParams::fmllr_bases_, KALDI_ASSERT, KALDI_LOG, KALDI_VLOG, KALDI_WARN, kSetZero, PackedMatrix< Real >::NumRows(), and SortSvd().

Referenced by TestSgmm2FmllrSubspace().

                                                                                {
  KALDI_ASSERT(num_fmllr_bases > 0 && feat_dim > 0);
  if (num_fmllr_bases >  feat_dim * (feat_dim + 1)) {
    num_fmllr_bases = feat_dim * (feat_dim + 1);
    KALDI_WARN << "Limiting number of fMLLR bases to be the same as transform "
               << "dimension.";
  }

  vector< Matrix<BaseFloat> > &fmllr_bases(globals->fmllr_bases_);

  Vector<double> s(fmllr_grad_scatter.NumRows());
  Matrix<double> U(fmllr_grad_scatter.NumRows(),
                      fmllr_grad_scatter.NumRows());
  try {
    fmllr_grad_scatter.Eig(&s, &U);
    SortSvd(&s, &U);  // in case was not exactly sorted.
    KALDI_VLOG(1) << "Eigenvalues (max 200) of CMLLR scatter are: "
                  << (SubVector<double>(s, 0,
                                        std::min(static_cast<MatrixIndexT>(200),
                                                 s.Dim())));


//    for (int32 b = 2; b < num_fmllr_bases; b++) {
//      if (s(b) < min_eig) {
//        num_fmllr_bases = b;
//        KALDI_WARN << "Limiting number of fMLLR bases to " << num_fmllr_bases
//                   << " because of small eigenvalues.";
//        break;
//      }
//    }

    U.Transpose();  // Now the rows of U correspond to the basis vectors.
    fmllr_bases.resize(num_fmllr_bases);
    for (int32 b = 0; b < num_fmllr_bases; b++) {
      fmllr_bases[b].Resize(feat_dim, feat_dim + 1, kSetZero);
      fmllr_bases[b].CopyRowsFromVec(U.Row(b));
    }
    KALDI_LOG << "Estimated " << num_fmllr_bases << " fMLLR basis matrices.";
  } catch(const std::exception &e) {
    KALDI_WARN << "Not estimating FMLLR bases because of a thrown exception:\n"
               << e.what();
    fmllr_bases.resize(0);
  }
}  // End of EstimateSgmm2FmllrSubspace

EstPca()

bool kaldi::EstPca	(	const Matrix< BaseFloat > &	ivector_mat,
		BaseFloat	target_energy,
		const std::string &	reco,
		Matrix< BaseFloat > *	mat
	)

Definition at line 29 of file ivector-plda-scoring-dense.cc.

References SpMatrix< Real >::AddMat2(), VectorBase< Real >::AddRowSumMat(), SpMatrix< Real >::AddVec2(), ApproxEqual(), MatrixBase< Real >::CopyFromMat(), VectorBase< Real >::Dim(), SpMatrix< Real >::Eig(), KALDI_WARN, kCopyData, kTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), SpMatrix< Real >::Resize(), Vector< Real >::Resize(), Matrix< Real >::Resize(), PackedMatrix< Real >::Scale(), VectorBase< Real >::Scale(), SortSvd(), and VectorBase< Real >::Sum().

Referenced by main().

                                                 {

  // If the target_energy is 1.0, it's equivalent to not applying the
  // conversation-dependent PCA at all, so it's better to exit this
  // function before doing any computation.
  if (ApproxEqual(target_energy, 1.0, 0.001))
    return false;

  int32 num_rows = ivector_mat.NumRows(),
    num_cols = ivector_mat.NumCols();
  Vector<BaseFloat> sum;
  SpMatrix<BaseFloat> sumsq;
  sum.Resize(num_cols);
  sumsq.Resize(num_cols);
  sum.AddRowSumMat(1.0, ivector_mat);
  sumsq.AddMat2(1.0, ivector_mat, kTrans, 1.0);
  sum.Scale(1.0 / num_rows);
  sumsq.Scale(1.0 / num_rows);
  sumsq.AddVec2(-1.0, sum); // now sumsq is centered covariance.
  int32 full_dim = sum.Dim();

  Matrix<BaseFloat> P(full_dim, full_dim);
  Vector<BaseFloat> s(full_dim);

  try {
    if (num_rows > num_cols)
      sumsq.Eig(&s, &P);
    else
      Matrix<BaseFloat>(sumsq).Svd(&s, &P, NULL);
  } catch (...) {
    KALDI_WARN << "Unable to compute conversation dependent PCA for"
      << " recording " << reco << ".";
    return false;
  }

  SortSvd(&s, &P);

  Matrix<BaseFloat> transform(P, kTrans); // Transpose of P.  This is what
                                       // appears in the transform.

  // We want the PCA transform to retain target_energy amount of the total
  // energy.
  BaseFloat total_energy = s.Sum();
  BaseFloat energy = 0.0;
  int32 dim = 1;
  while (energy / total_energy <= target_energy) {
    energy += s(dim-1);
    dim++;
  }
  Matrix<BaseFloat> transform_float(transform);
  mat->Resize(transform.NumCols(), transform.NumRows());
  mat->CopyFromMat(transform);
  mat->Resize(dim, transform_float.NumCols(), kCopyData);
  return true;
}

EventTypeToString()

std::string EventTypeToString

(

const EventType &

evec

)

Definition at line 253 of file event-map.cc.

Referenced by FilterStatsByKey(), MakeEventPair(), SplitStatsByKey(), and SplitStatsByMap().

                                                   {
  std::stringstream ss;
  EventType::const_iterator iter = evec.begin(), end = evec.end();
  std::string sep = "";
  for (; iter != end; ++iter) {
    ss << sep << iter->first <<":"<<iter->second;
    sep = " ";
  }
  return ss.str();
}

Exp() [1/2]

double kaldi::Exp ( double  x )

inline

Definition at line 83 of file kaldi-math.h.

Referenced by MinimumBayesRisk::AccStats(), VectorBase< float >::ApplyExp(), VectorBase< float >::ApplyLogSoftMax(), VectorBase< float >::ApplySoftMax(), MatrixBase< float >::ApplySoftMax(), TransitionModel::ComputeDerivedOfProbs(), AmSgmm2::ComputeNormalizers(), AmSgmm2::ComputeNormalizersInternal(), CuVectorUnitTestApplyExp(), MinimumBayesRisk::EditDistance(), Exp(), MatrixBase< float >::Exp(), MatrixBase< float >::ExpLimited(), MatrixBase< float >::ExpSpecial(), generate_features(), AmSgmm2::GetDjms(), TransitionModel::GetTransitionProb(), init_rand_diag_gmm(), kaldi::unittest::InitRandDiagGmm(), InitRandomGmm(), LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), LogAdd(), LogSub(), VectorBase< float >::LogSumExp(), MatrixBase< float >::LogSumExp(), main(), NccfToPov(), PushSpecialClass::PushSpecialClass(), rand_diag_gmm(), kaldi::cu::ScalarSigmoid(), kaldi::cu::ScalarTanh(), VectorBase< float >::Sigmoid(), MatrixBase< float >::SoftHinge(), VectorBase< float >::Tanh(), PushSpecialClass::TestAccuracy(), TestSgmm2Fmllr(), UnitTestDefines(), UnitTestDiagGmm(), UnitTestEstimateDiagGmm(), UnitTestEstimateMmieDiagGmm(), UnitTestEstimateSgmm2(), UnitTestExpSpeed(), UnitTestLbfgs(), UnitTestLogAddSub(), UnitTestMleAmDiagGmm(), UnitTestSigmoid(), UnitTestSimple(), UnitTestSimpleForVec(), UnitTestSoftHinge(), UnitTestTanh(), and VectorToPosteriorEntry().

{ return exp(x); }

Exp() [2/2]

float kaldi::Exp ( float  x )

inline

Definition at line 85 of file kaldi-math.h.

References Exp().

{ return expf(x); }

ExpectOneOrTwoTokens()

void ExpectOneOrTwoTokens	(	std::istream &	is,
		bool	binary,
		const std::string &	token1,
		const std::string &	token2
	)

This function is like ExpectToken but for two tokens, and it will either accept token1 and then token2, or just token2.

This is useful in Read functions where the first token may already have been consumed.

Definition at line 536 of file text-utils.cc.

References ExpectToken(), KALDI_ASSERT, KALDI_ERR, and ReadToken().

Referenced by PnormComponent::Read(), DistributeComponent::Read(), DistributeComponentPrecomputedIndexes::Read(), RestrictedAttentionComponent::Read(), ElementwiseProductComponent::Read(), RestrictedAttentionComponent::PrecomputedIndexes::Read(), BatchNormComponent::Read(), StatisticsExtractionComponent::Read(), ConvolutionModel::Read(), TimeHeightConvolutionComponent::PrecomputedIndexes::Read(), StatisticsExtractionComponentPrecomputedIndexes::Read(), ConvolutionComputation::Read(), StatisticsPoolingComponent::Read(), StatisticsPoolingComponentPrecomputedIndexes::Read(), BackpropTruncationComponent::Read(), MaxpoolingComponent::Read(), TdnnComponent::PrecomputedIndexes::Read(), BackpropTruncationComponentPrecomputedIndexes::Read(), NonlinearComponent::Read(), DropoutMaskComponent::Read(), GeneralDropoutComponent::Read(), GeneralDropoutComponentPrecomputedIndexes::Read(), FixedAffineComponent::Read(), SpecAugmentTimeMaskComponent::Read(), SumGroupComponent::Read(), SpecAugmentTimeMaskComponentPrecomputedIndexes::Read(), FixedScaleComponent::Read(), FixedBiasComponent::Read(), NoOpComponent::Read(), SumBlockComponent::Read(), ClipGradientComponent::Read(), and PermuteComponent::Read().

                                                   {
  KALDI_ASSERT(token1 != token2);
  std::string temp;
  ReadToken(is, binary, &temp);
  if (temp == token1) {
    ExpectToken(is, binary, token2);
  } else {
    if (temp != token2) {
      KALDI_ERR << "Expecting token " << token1 << " or " << token2
                << " but got " << temp;
    }
  }
}

ExtendWaveWithSilence()

void ExtendWaveWithSilence	(	const Vector< BaseFloat > &	wav_in,
		BaseFloat	samp_rate,
		Vector< BaseFloat > *	wav_out,
		BaseFloat	sil_search_len,
		BaseFloat	sil_extract_len,
		BaseFloat	sil_extract_shift
	)

Definition at line 152 of file extend-wav-with-silence.cc.

References VectorBase< Real >::AddVecVec(), VectorBase< Real >::Dim(), FindQuietestSegment(), rnnlm::i, KALDI_ASSERT, M_2PI, and VectorBase< Real >::Range().

Referenced by main().

                                                       {
  Vector<BaseFloat> quietest_seg;
  FindQuietestSegment(wav_in, samp_rate, &quietest_seg,
                      sil_search_len, sil_extract_len, sil_extract_shift);

  int32 window_size = quietest_seg.Dim(),
    window_size_half = window_size / 2;
  KALDI_ASSERT(window_size > 0);
  Vector<BaseFloat> window(window_size);
  Vector<BaseFloat> windowed_silence(window_size);
  Vector<BaseFloat> half_window(window_size_half);
  for(int32 i = 0; i < window.Dim(); i++){
    BaseFloat i_fl = static_cast<BaseFloat>(i);
    window(i) = 0.54 - 0.46*cos(M_2PI * i_fl / (window_size-1));
  }
  half_window = window.Range(window_size_half, window_size_half);
  windowed_silence.AddVecVec(1.0, window, quietest_seg, 0.0);

  wav_out->Range(0, wav_in.Dim()).CopyFromVec(wav_in);
  SubVector<BaseFloat> wav_ext(*wav_out, wav_in.Dim() - window_size_half,
                                wav_out->Dim() - wav_in.Dim() + window_size_half);
  for(int32 i = 0; i < window_size_half; i++)    // windowing the first half window
    wav_ext(i) *= half_window(i);

  int32 tmp_offset = 0;
  for(; tmp_offset + window_size < wav_ext.Dim();) {
    wav_ext.Range(tmp_offset, window_size).AddVec(1.0, windowed_silence);
    tmp_offset += window_size_half;
  }

  for(int32 i = tmp_offset; i < wav_ext.Dim(); i++)
    wav_ext(i) += windowed_silence(i-tmp_offset);

}

ExtractObjectRange() [1/6]

template bool kaldi::ExtractObjectRange	(	const CompressedMatrix &	,
		const std::string &	,
		Matrix< float > *
	)

ExtractObjectRange() [2/6]

template bool kaldi::ExtractObjectRange	(	const CompressedMatrix &	,
		const std::string &	,
		Matrix< double > *
	)

ExtractObjectRange() [3/6]

template bool kaldi::ExtractObjectRange	(	const Matrix< double > &	,
		const std::string &	,
		Matrix< double > *
	)

ExtractObjectRange() [4/6]

template bool kaldi::ExtractObjectRange	(	const Matrix< float > &	,
		const std::string &	,
		Matrix< float > *
	)

ExtractObjectRange() [5/6]

template bool kaldi::ExtractObjectRange	(	const Vector< double > &	,
		const std::string &	,
		Vector< double > *
	)

ExtractObjectRange() [6/6]

template bool kaldi::ExtractObjectRange	(	const Vector< float > &	,
		const std::string &	,
		Vector< float > *
	)

Factorize()

void kaldi::Factorize	(	I	m,
		std::vector< I > *	factors
	)

Definition at line 325 of file kaldi-math.h.

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

Referenced by ComplexFft(), and UnitTestFactorizeTpl().

                                                             {
  // Splits a number into its prime factors, in sorted order from
  // least to greatest,  with duplication.  A very inefficient
  // algorithm, which is mainly intended for use in the
  // mixed-radix FFT computation (where we assume most factors
  // are small).
  KALDI_ASSERT(factors != NULL);
  KALDI_ASSERT(m >= 1);  // Doesn't work for zero or negative numbers.
  factors->clear();
  I small_factors[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };

  // First try small factors.
  for (I i = 0; i < 10; i++) {
    if (m == 1) return;  // We're done.
    while (m % small_factors[i] == 0) {
      m /= small_factors[i];
      factors->push_back(small_factors[i]);
    }
  }
  // Next try all odd numbers starting from 31.
  for (I j = 31;; j += 2) {
    if (m == 1) return;
    while (m % j == 0) {
      m /= j;
      factors->push_back(j);
    }
  }
}

FakeStatsForSomeDims()

void FakeStatsForSomeDims	(	const std::vector< int32 > &	dims,
		MatrixBase< double > *	stats
	)

Modify the stats so that for some dimensions (specified in "dims"), we replace them with "fake" stats that have zero mean and unit variance; this is done to disable CMVN for those dimensions.

Definition at line 168 of file cmvn.cc.

References count, rnnlm::d, rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

Referenced by OnlineCmvn::GetFrame(), and main().

                                                     {
  KALDI_ASSERT(stats->NumRows() == 2 && stats->NumCols() > 1);
  int32 dim = stats->NumCols() - 1;
  double count = (*stats)(0, dim);
  for (size_t i = 0; i < dims.size(); i++) {
    int32 d = dims[i];
    KALDI_ASSERT(d >= 0 && d < dim);
    (*stats)(0, d) = 0.0;
    (*stats)(1, d) = count;
  }
}

FFTbasedBlockConvolveSignals()

void FFTbasedBlockConvolveSignals	(	const Vector< BaseFloat > &	filter,
		Vector< BaseFloat > *	signal
	)

Definition at line 77 of file signal.cc.

References SplitRadixRealFft< Real >::Compute(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), ElementwiseProductOfFft(), KALDI_VLOG, kCopyData, VectorBase< Real >::Range(), Vector< Real >::Resize(), RoundUpToNearestPowerOfTwo(), VectorBase< Real >::Scale(), and VectorBase< Real >::SetZero().

Referenced by ComputeEarlyReverbEnergy(), DoReverberation(), and UnitTestFFTbasedBlockConvolution().

                                                                                              {
  int32 signal_length = signal->Dim();
  int32 filter_length = filter.Dim();
  int32 output_length = signal_length + filter_length - 1;
  signal->Resize(output_length, kCopyData);

  KALDI_VLOG(1) << "Length of the filter is " << filter_length;

  int32 fft_length = RoundUpToNearestPowerOfTwo(4 * filter_length);
  KALDI_VLOG(1) << "Best FFT length is " << fft_length;

  int32 block_length = fft_length - filter_length + 1;
  KALDI_VLOG(1) << "Block size is " << block_length;
  SplitRadixRealFft<BaseFloat> srfft(fft_length);

  Vector<BaseFloat> filter_padded(fft_length);
  filter_padded.Range(0, filter_length).CopyFromVec(filter);
  srfft.Compute(filter_padded.Data(), true);

  Vector<BaseFloat> temp_pad(filter_length - 1);
  temp_pad.SetZero();
  Vector<BaseFloat> signal_block_padded(fft_length);

  for (int32 po = 0; po < output_length; po += block_length) {
    // get a block of the signal
    int32 process_length = std::min(block_length, output_length - po);
    signal_block_padded.SetZero();
    signal_block_padded.Range(0, process_length).CopyFromVec(signal->Range(po, process_length));

    srfft.Compute(signal_block_padded.Data(), true);

    ElementwiseProductOfFft(filter_padded, &signal_block_padded);

    srfft.Compute(signal_block_padded.Data(), false);
    signal_block_padded.Scale(1.0 / fft_length);

    // combine the block
    if (po + block_length < output_length) {       // current block is not the last block
      signal->Range(po, block_length).CopyFromVec(signal_block_padded.Range(0, block_length));
      signal->Range(po, filter_length - 1).AddVec(1.0, temp_pad);
      temp_pad.CopyFromVec(signal_block_padded.Range(block_length, filter_length - 1));
    } else {
      signal->Range(po, output_length - po).CopyFromVec(
                        signal_block_padded.Range(0, output_length - po));
      if (filter_length - 1 < output_length - po)
        signal->Range(po, filter_length - 1).AddVec(1.0, temp_pad);
      else
        signal->Range(po, output_length - po).AddVec(1.0, temp_pad.Range(0, output_length - po));
    }
  }
}

FFTbasedConvolveSignals()

void FFTbasedConvolveSignals	(	const Vector< BaseFloat > &	filter,
		Vector< BaseFloat > *	signal
	)

Definition at line 50 of file signal.cc.

References SplitRadixRealFft< Real >::Compute(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), ElementwiseProductOfFft(), KALDI_VLOG, VectorBase< Real >::Range(), Vector< Real >::Resize(), RoundUpToNearestPowerOfTwo(), and VectorBase< Real >::Scale().

Referenced by UnitTestFFTbasedBlockConvolution(), and UnitTestFFTbasedConvolution().

                                                                                         {
  int32 signal_length = signal->Dim();
  int32 filter_length = filter.Dim();
  int32 output_length = signal_length + filter_length - 1;

  int32 fft_length = RoundUpToNearestPowerOfTwo(output_length);
  KALDI_VLOG(1) << "fft_length for full signal convolution is " << fft_length;

  SplitRadixRealFft<BaseFloat> srfft(fft_length);

  Vector<BaseFloat> filter_padded(fft_length);
  filter_padded.Range(0, filter_length).CopyFromVec(filter);
  srfft.Compute(filter_padded.Data(), true);

  Vector<BaseFloat> signal_padded(fft_length);
  signal_padded.Range(0, signal_length).CopyFromVec(*signal);
  srfft.Compute(signal_padded.Data(), true);

  ElementwiseProductOfFft(filter_padded, &signal_padded);

  srfft.Compute(signal_padded.Data(), false);
  signal_padded.Scale(1.0 / fft_length);

  signal->Resize(output_length);
  signal->CopyFromVec(signal_padded.Range(0, output_length));
}

FilterMatrixRows() [1/2]

template void kaldi::FilterMatrixRows	(	const Matrix< float > &	in,
		const std::vector< bool > &	keep_rows,
		Matrix< float > *	out
	)

FilterMatrixRows() [2/2]

template void kaldi::FilterMatrixRows	(	const Matrix< double > &	in,
		const std::vector< bool > &	keep_rows,
		Matrix< double > *	out
	)

Referenced by FilterCompressedMatrixRows(), FilterGeneralMatrixRows(), and FilterMatrixRows().

FilterSparseMatrixRows() [1/2]

template void kaldi::FilterSparseMatrixRows	(	const SparseMatrix< float > &	in,
		const std::vector< bool > &	keep_rows,
		SparseMatrix< float > *	out
	)

FilterSparseMatrixRows() [2/2]

template void kaldi::FilterSparseMatrixRows	(	const SparseMatrix< double > &	in,
		const std::vector< bool > &	keep_rows,
		SparseMatrix< double > *	out
	)

Referenced by FilterGeneralMatrixRows(), and FilterSparseMatrixRows().

FindQuietestSegment()

void FindQuietestSegment	(	const Vector< BaseFloat > &	wav_in,
		BaseFloat	samp_rate,
		Vector< BaseFloat > *	wav_sil,
		BaseFloat	search_dur = 0.5,
		BaseFloat	seg_dur = 0.1,
		BaseFloat	seg_shift_dur = 0.05
	)

Definition at line 195 of file extend-wav-with-silence.cc.

References VectorBase< Real >::Dim(), KALDI_ASSERT, KALDI_WARN, VectorBase< Real >::Range(), and VecVec().

Referenced by ExtendWaveWithSilence().

                                                 {
  KALDI_ASSERT(seg_dur < search_dur);

  int32 search_len = (int32) (search_dur * samp_rate),
    seg_len = (int32) (seg_dur * samp_rate),
    seg_shift = (int32) (seg_shift_dur *samp_rate),
    start = 0;
  double min_energy;
  Vector<BaseFloat> wav_min_energy;
  Vector<BaseFloat> seg_tmp(wav_in.Range(0, seg_len));
  wav_min_energy = seg_tmp;
  min_energy = VecVec(seg_tmp, seg_tmp);
  for(start = 0; start + seg_len < search_len; ){
    SubVector<BaseFloat> seg_this(wav_in, start, seg_len);
    seg_tmp = seg_this;
    double energy_this = VecVec(seg_this, seg_this);
    if(energy_this < min_energy && energy_this > 0.0){
      min_energy = energy_this;
      wav_min_energy = seg_tmp;
    }
    start += seg_shift;
  }

  for(start = wav_in.Dim() - search_len; start + seg_len < wav_in.Dim(); ){
    SubVector<BaseFloat> seg_this(wav_in, start, seg_len);
    seg_tmp = seg_this;
    double energy_this = VecVec(seg_this, seg_this);
    if(energy_this < min_energy && energy_this > 0.0){
      min_energy = energy_this;
      wav_min_energy = seg_tmp;
    }
    start += seg_shift;
  }

  if (min_energy == 0.0) {
    KALDI_WARN << "Zero energy silence being used.";
  }
  *wav_sil = wav_min_energy;
}

FmllrAuxfGradient()

BaseFloat FmllrAuxfGradient	(	const MatrixBase< BaseFloat > &	xform,
		const AffineXformStats &	stats,
		MatrixBase< BaseFloat > *	grad_out
	)

Returns the (diagonal-GMM) FMLLR auxiliary function value given the transform and the stats.

Definition at line 510 of file fmllr-diag-gmm.cc.

References MatrixBase< Real >::AddMat(), VectorBase< Real >::AddSpVec(), AffineXformStats::beta_, MatrixBase< Real >::CopyFromMat(), MatrixBase< Real >::CopyRowFromVec(), rnnlm::d, AffineXformStats::G_, AffineXformStats::K_, kNoTrans, kTrans, MatrixBase< Real >::LogDet(), MatrixBase< Real >::Range(), MatrixBase< Real >::Row(), MatrixBase< Real >::Scale(), TraceMatMat(), and VecVec().

Referenced by ComputeFmllrLogDet().

                                                             {
  int32 dim = static_cast<int32>(stats.G_.size());
  Matrix<double> xform_d(xform);
  Vector<double> xform_row_g(dim + 1);
  SubMatrix<double> A(xform_d, 0, dim, 0, dim);
  double obj = stats.beta_ * A.LogDet() +
      TraceMatMat(xform_d, stats.K_, kTrans);
  Matrix<double> S(dim, dim + 1);
  for (int32 d = 0; d < dim; d++) {
    xform_row_g.AddSpVec(1.0, stats.G_[d], xform_d.Row(d), 0.0);
    obj -= 0.5 * VecVec(xform_row_g, xform_d.Row(d));
    S.CopyRowFromVec(xform_row_g, d);
  }

  // Compute the gradient: P = \beta [(A^{-1})^{T} , 0] + K - S
  // grad_out->Resize(dim, dim + 1);
  Matrix<double> tmp_grad(dim, dim + 1);
  tmp_grad.Range(0, dim, 0, dim).CopyFromMat(A);
  tmp_grad.Range(0, dim, 0, dim).Invert();
  tmp_grad.Range(0, dim, 0, dim).Transpose();
  tmp_grad.Scale(stats.beta_);
  tmp_grad.AddMat(-1.0, S, kNoTrans);
  tmp_grad.AddMat(1.0, stats.K_, kNoTrans);
  grad_out->CopyFromMat(tmp_grad, kNoTrans);

  return obj;
}

FmllrAuxFuncDiagGmm() [1/2]

float FmllrAuxFuncDiagGmm	(	const MatrixBase< float > &	xform,
		const AffineXformStats &	stats
	)

Returns the (diagonal-GMM) FMLLR auxiliary function value given the transform and the stats.

Definition at line 481 of file fmllr-diag-gmm.cc.

References VectorBase< Real >::AddSpVec(), AffineXformStats::beta_, rnnlm::d, AffineXformStats::G_, AffineXformStats::K_, kTrans, MatrixBase< Real >::LogDet(), MatrixBase< Real >::Row(), TraceMatMat(), and VecVec().

Referenced by ComputeFmllrLogDet(), ComputeFmllrMatrixDiagGmmDiagonal(), ComputeFmllrMatrixDiagGmmFull(), LinearVtln::ComputeTransform(), and BasisFmllrEstimate::ComputeTransform().

                                                             {
  int32 dim = static_cast<int32>(stats.G_.size());
  Matrix<double> xform_d(xform);
  Vector<double> xform_row_g(dim + 1);
  SubMatrix<double> A(xform_d, 0, dim, 0, dim);
  double obj = stats.beta_ * A.LogDet() +
      TraceMatMat(xform_d, stats.K_, kTrans);
  for (int32 d = 0; d < dim; d++) {
    xform_row_g.AddSpVec(1.0, stats.G_[d], xform_d.Row(d), 0.0);
    obj -= 0.5 * VecVec(xform_row_g, xform_d.Row(d));
  }
  return obj;
}

FmllrAuxFuncDiagGmm() [2/2]

double FmllrAuxFuncDiagGmm	(	const MatrixBase< double > &	xform,
		const AffineXformStats &	stats
	)

Definition at line 496 of file fmllr-diag-gmm.cc.

References VectorBase< Real >::AddSpVec(), AffineXformStats::beta_, rnnlm::d, AffineXformStats::G_, AffineXformStats::K_, kTrans, MatrixBase< Real >::LogDet(), MatrixBase< Real >::Row(), TraceMatMat(), and VecVec().

                                                          {
  int32 dim = static_cast<int32>(stats.G_.size());
  Vector<double> xform_row_g(dim + 1);
  SubMatrix<double> A(xform, 0, dim, 0, dim);
  double obj = stats.beta_ * A.LogDet() +
      TraceMatMat(xform, stats.K_, kTrans);
  for (int32 d = 0; d < dim; d++) {
    xform_row_g.AddSpVec(1.0, stats.G_[d], xform.Row(d), 0.0);
    obj -= 0.5 * VecVec(xform_row_g, xform.Row(d));
  }
  return obj;
}

FmllrInnerUpdate()

void FmllrInnerUpdate	(	SpMatrix< double > &	inv_G,
		VectorBase< double > &	k,
		double	beta,
		int32	row,
		MatrixBase< double > *	transform
	)

This function does one row of the inner-loop fMLLR transform update.

We export it because it's needed in the RawFmllr code. Here, if inv_G is the inverse of the G matrix indexed by this row, and k is the corresponding row of the K matrix.

Definition at line 193 of file fmllr-diag-gmm.cc.

References VectorBase< Real >::AddSpVec(), VectorBase< Real >::AddVec(), MatrixBase< Real >::CopyFromMat(), MatrixBase< Real >::Invert(), KALDI_ASSERT, kTrans, Log(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), VectorBase< Real >::Range(), MatrixBase< Real >::Range(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), and VecVec().

Referenced by ComputeFmllrLogDet(), ComputeFmllrMatrixDiagGmmFull(), and FmllrRawAccs::Update().

                                                     {
  int32 dim = transform->NumRows();
  KALDI_ASSERT(transform->NumCols() == dim + 1);
  KALDI_ASSERT(row >= 0 && row < dim);

  double logdet;
  // Calculating the matrix of cofactors (transpose of adjugate)
  Matrix<double> cofact_mat(dim, dim);
  cofact_mat.CopyFromMat(transform->Range(0, dim, 0, dim), kTrans);
  cofact_mat.Invert(&logdet);
  // Removed this step because it's not necessary and could lead to
  // under/overflow [Dan]
  // cofact_mat.Scale(exp(logdet));
  
  // The extended cofactor vector for the current row
  Vector<double> cofact_row(dim + 1);
  cofact_row.Range(0, dim).CopyRowFromMat(cofact_mat, row);
  cofact_row(dim) = 0;
  Vector<double> cofact_row_invg(dim + 1);
  cofact_row_invg.AddSpVec(1.0, inv_G, cofact_row, 0.0);

  // Solve the quadratic equation for step size
  double e1 = VecVec(cofact_row_invg, cofact_row);
  double e2 = VecVec(cofact_row_invg, k);
  double discr = std::sqrt(e2 * e2 + 4 * e1 * beta);
  double alpha1 = (-e2 + discr) / (2 * e1);
  double alpha2 = (-e2 - discr) / (2 * e1);
  double auxf1 = beta * Log(std::abs(alpha1 * e1 + e2)) -
      0.5 * alpha1 * alpha1 * e1;
  double auxf2 = beta * Log(std::abs(alpha2 * e1 + e2)) -
      0.5 * alpha2 * alpha2 * e1;
  double alpha = (auxf1 > auxf2) ? alpha1 : alpha2;

  // Update transform row: w_d = (\alpha cofact_d + k_d) G_d^{-1}
  cofact_row.Scale(alpha);
  cofact_row.AddVec(1.0, k);
  transform->Row(row).AddSpVec(1.0, inv_G, cofact_row, 0.0);
}

FrameLevelLpp()

void kaldi::FrameLevelLpp	(	const SubVector< BaseFloat > &	prob_row,
		const std::vector< std::set< int32 > > &	pdf2phones,
		const std::vector< int32 > *	phone_map,
		Vector< BaseFloat > *	out_frame_level_lpp
	)

FrameLevelLpp compute a log posterior for pure-phones by sum the posterior of the states belonging to those triphones whose current phone is the canonical phone:

p(p|o_t) = {s p} p(s|o_t),

where s is the senone label, {s|s p} is the states belonging to those riphones whose current phone is the canonical phone p.

Definition at line 76 of file compute-gop.cc.

References VectorBase< Real >::ApplyLog(), VectorBase< Real >::Dim(), rnnlm::i, and KALDI_ASSERT.

Referenced by main().

                                                           {
  for (int32 i = 0; i < prob_row.Dim(); i++) {
    std::set<int32> dest_idxs;
    for (int32 ph : pdf2phones.at(i)) {
      dest_idxs.insert((phone_map != NULL) ? (*phone_map)[ph] - 1 : ph - 1);
    }

    for (int32 idx : dest_idxs) {
      KALDI_ASSERT(idx < out_frame_level_lpp->Dim());
      (*out_frame_level_lpp)(idx) += prob_row(i);
    }
  }
  out_frame_level_lpp->ApplyLog();
}

Gcd()

I kaldi::Gcd	(	I	m,
		I	n
	)

Definition at line 297 of file kaldi-math.h.

References KALDI_ASSERT, KALDI_ERR, and rnnlm::n.

Referenced by ClusterKMeansOnce(), ConvolutionModel::ComputeDerived(), kaldi::nnet3::time_height_convolution::FindGcdOfDifferences(), RestrictedAttentionComponent::GetComputationStructure(), Lcm(), LinearResample::LinearResample(), kaldi::nnet3::time_height_convolution::PadComputationInputTime(), and UnitTestGcdLcmTpl().

                                   {
  if (m == 0 || n == 0) {
    if (m == 0 && n == 0) {  // gcd not defined, as all integers are divisors.
      KALDI_ERR << "Undefined GCD since m = 0, n = 0.";
    }
    return (m == 0 ? (n > 0 ? n : -n) : ( m > 0 ? m : -m));
    // return absolute value of whichever is nonzero
  }
  // could use compile-time assertion
  // but involves messing with complex template stuff.
  KALDI_ASSERT(std::numeric_limits<I>::is_integer);
  while (1) {
    m %= n;
    if (m == 0) return (n > 0 ? n : -n);
    n %= m;
    if (n == 0) return (m > 0 ? m : -m);
  }
}

generate_features()

static void kaldi::generate_features ( cova_type  covariance_type, size_t  n_gaussians, size_t  dim, Matrix< BaseFloat > &  trans_mat, size_t  frames_per_gaussian, std::vector< Vector< BaseFloat > *> &  train_feats, std::vector< Vector< BaseFloat > *> &  adapt_feats  )

static

Definition at line 64 of file regtree-fmllr-diag-gmm-test.cc.

References MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddMatVec(), VectorBase< Real >::CopyColFromMat(), MatrixBase< Real >::CopyFromMat(), rnnlm::d, diag, Exp(), full, rnnlm::i, MatrixBase< Real >::Invert(), rnnlm::j, kNoTrans, RandFullCova(), RandGauss(), MatrixBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::SetZero().

Referenced by UnitTestRegtreeFmllrDiagGmm().

                    {
  // compute inverse of the transformation matrix
  Matrix<BaseFloat> inv_trans_mat(dim, dim);
  inv_trans_mat.CopyFromMat(trans_mat, kNoTrans);
  inv_trans_mat.Invert();
  // the untransformed means are random
  Matrix<BaseFloat> untransformed_means(dim, n_gaussians);
  untransformed_means.SetRandn();
  untransformed_means.Scale(10);

  // the actual means result from
  // transformation with inv_trans_mat
  Matrix<BaseFloat> actual_means(dim, n_gaussians);

  // actual_means = inv_trans_mat * untransformed_means
  actual_means.AddMatMat(1.0, inv_trans_mat, kNoTrans,
                         untransformed_means, kNoTrans, 0.0);

  size_t train_counter = 0;

  // temporary variables
  Vector<BaseFloat> randomvec(dim);
  Matrix<BaseFloat> Sj(dim, dim);

  // loop over all gaussians
  for (size_t j = 0; j < n_gaussians; j++) {
    if (covariance_type == diag) {
      // random diagonal covariance for gaussian j
      Sj.SetZero();
      for (size_t d = 0; d < dim; d++) {
        Sj(d, d) = 2*Exp(RandGauss());
      }
    }
    if (covariance_type == full) {
      // random full covariance for gaussian j
      RandFullCova(&Sj);
    }
    // compute inv_trans_mat * Sj
    Matrix<BaseFloat> tmp_matrix(dim, dim);
    tmp_matrix.AddMatMat(1.0, inv_trans_mat, kNoTrans, Sj, kNoTrans, 0.0);

    // compute features
    for (size_t i = 0; i < frames_per_gaussian; i++) {
      train_feats[train_counter] = new Vector<BaseFloat>(dim);
      adapt_feats[train_counter] = new Vector<BaseFloat>(dim);

      // initalize feature vector with mean of class j
      train_feats[train_counter]->CopyColFromMat(untransformed_means, j);
      adapt_feats[train_counter]->CopyColFromMat(actual_means, j);

      // determine random vector and
      // multiply the random vector with SJ
      // and add it to train_feats:
      // train_feats = train_feats + SJ * random
      // for adapt_feats we include the invtrans_mat:
      // adapt_feats = adapt_feats + invtrans_mat * SJ * random
      for (size_t d = 0; d < dim; d++) {
        randomvec(d) = RandGauss();
      }
      train_feats[train_counter]->AddMatVec(1.0, Sj, kNoTrans,
                                            randomvec, 1.0);
      adapt_feats[train_counter]->AddMatVec(1.0, tmp_matrix, kNoTrans,
                                            randomvec, 1.0);
      train_counter++;
    }
  }
  return;
}

GenerateActivePaths()

bool kaldi::GenerateActivePaths	(	const KwsLexicographicFst &	proxy,
		std::vector< ActivePath > *	paths,
		KwsLexicographicFst::StateId	cur_state,
		std::vector< KwsLexicographicArc::Label >	cur_path,
		KwsLexicographicArc::Weight	cur_weight
	)

Definition at line 90 of file kws-search.cc.

References ActivePath::last, ActivePath::path, fst::Times(), and ActivePath::weight.

Referenced by OutputDetailedStatistics().

                                                             {
  for (fst::ArcIterator<KwsLexicographicFst> aiter(proxy, cur_state);
       !aiter.Done(); aiter.Next()) {
    const Arc &arc = aiter.Value();
    Weight temp_weight = Times(arc.weight, cur_weight);

    cur_path.push_back(arc.ilabel);

    if ( arc.olabel != 0 ) {
      ActivePath path;
      path.path = cur_path;
      path.weight = temp_weight;
      path.last = arc.olabel;
      paths->push_back(path);
    } else {
      GenerateActivePaths(proxy, paths,
                        arc.nextstate, cur_path, temp_weight);
    }
    cur_path.pop_back();
  }

  return true;
}

GenerateCompactLatticeRandomly()

void kaldi::GenerateCompactLatticeRandomly	(	const std::vector< int32 > &	alignment,
		const std::vector< int32 > &	words,
		CompactLattice *	clat
	)

Definition at line 132 of file word-align-lattice-lexicon-test.cc.

References rnnlm::i, LatticeWeightTpl< BaseFloat >::One(), CompactLatticeWeightTpl< WeightType, IntType >::One(), and RandInt().

Referenced by TestWordAlignLatticeLexicon().

                                                          {
  clat->DeleteStates();
  clat->AddState();
  clat->SetStart(0);
  int32 cur_state = 0;
  size_t word_start = 0, alignment_start = 0,
      num_words = words.size(), num_transition_ids = alignment.size();
  for (; word_start < num_words; word_start++) {
    int32 word = words[word_start];
    int32 ali_length = RandInt(0, num_transition_ids - alignment_start);
    std::vector<int32> this_ali(ali_length);
    for (int32 i = 0; i < ali_length; i++)
      this_ali[i] = alignment[alignment_start + i];
    alignment_start += ali_length;
    CompactLatticeWeight weight(LatticeWeight::One(), this_ali);
    int32 ilabel = word;
    int32 next_state = clat->AddState();
    CompactLatticeArc arc(ilabel, ilabel, weight, next_state);
    clat->AddArc(cur_state, arc);
    cur_state = next_state;
  }
  if (alignment_start < alignment.size()) {
    int32 ali_length = num_transition_ids - alignment_start;
    std::vector<int32> this_ali(ali_length);
    for (int32 i = 0; i < ali_length; i++)
      this_ali[i] = alignment[alignment_start + i];
    alignment_start += ali_length;
    CompactLatticeWeight weight(LatticeWeight::One(), this_ali);
    int32 ilabel = 0;
    int32 next_state = clat->AddState();
    CompactLatticeArc arc(ilabel, ilabel, weight, next_state);
    clat->AddArc(cur_state, arc);
    cur_state = next_state;
  }
  clat->SetFinal(cur_state, CompactLatticeWeight::One());
}

GenerateLexicon()

void kaldi::GenerateLexicon	(	const std::vector< int32 > &	phones,
		bool	allow_zero_words,
		bool	allow_empty_word,
		bool	allow_multiple_prons,
		std::vector< std::vector< int32 > > *	lexicon
	)

Definition at line 32 of file word-align-lattice-lexicon-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, RandInt(), and SortAndUniq().

Referenced by TestWordAlignLatticeLexicon().

                                                            {
  KALDI_ASSERT(!phones.empty());
  lexicon->clear();
  int32 num_words = RandInt(1, 20);
  for (int32 word = 1; word <= num_words; word++) {
    int32 num_prons = RandInt(1, (allow_multiple_prons ? 2 : 1));
    bool is_zero_word = allow_zero_words && (RandInt(1, 5) == 1);

    for (int32 j = 0; j < num_prons; j++) {
      // don't allow empty pron if this word isn't labeled in the lattice (zero word,
      // like optional silence).  This doesn't make sense.
      int32 pron_length = RandInt(((allow_empty_word && !is_zero_word) ? 0 : 1),
                                  4);
      std::vector<int32> this_entry;
      this_entry.push_back(is_zero_word ? 0 : word);
      this_entry.push_back(word);
      for (int32 p = 0; p < pron_length; p++)
        this_entry.push_back(phones[RandInt(0, phones.size() - 1)]);
      lexicon->push_back(this_entry);
    }
  }
  SortAndUniq(lexicon);
  // randomize the order.
  std::random_shuffle(lexicon->begin(), lexicon->end());


  for (size_t i = 0; i < lexicon->size(); i++) {
    if ((*lexicon)[i].size() > 2) {
      // ok, this lexicon has at least one nonempty word: potentially OK.  Do
      // further check that the info object doesn't complain.
      try {
        WordAlignLatticeLexiconInfo info(*lexicon);
        return;  // OK, we're satisfied with this lexicon.
      } catch (...) {
        break;  // will re-try, see below.
      }
    }
  }
  // there were no nonempty words in the lexicon -> try again.
  // recursing is the easiest way.
  GenerateLexicon(phones, allow_zero_words, allow_empty_word, allow_multiple_prons,
                  lexicon);


}

GeneratePathThroughHmm()

void GeneratePathThroughHmm	(	const HmmTopology &	topology,
		bool	reorder,
		int32	phone,
		std::vector< std::pair< int32, int32 > > *	path
	)

This function generates a random path through the HMM for the given phone.

The 'path' output is a list of pairs (HMM-state, transition-index) in which any nonemitting states will have been removed. This is used in other test code. the 'reorder' option is as described in the documentation; if true, the self-loops from a state are reordered to come after the forward-transition.

Definition at line 190 of file hmm-test-utils.cc.

References HmmTopology::HmmState::forward_pdf_class, KALDI_ASSERT, RandInt(), HmmTopology::TopologyForPhone(), and HmmTopology::HmmState::transitions.

Referenced by GenerateRandomAlignment().

                                                                     {
  path->clear();
  const HmmTopology::TopologyEntry &this_entry =
      topology.TopologyForPhone(phone);
  int32 cur_state = 0;  // start-state is always state zero.
  int32 num_states = this_entry.size(), final_state = num_states - 1;
  KALDI_ASSERT(num_states > 1);  // there has to be a final nonemitting state
  // that's different from the start state.
  std::vector<std::pair<int32, int32> > pending_self_loops;
  while (cur_state != final_state) {
    const HmmTopology::HmmState &cur_hmm_state = this_entry[cur_state];
    int32 num_transitions = cur_hmm_state.transitions.size(),
        transition_index = RandInt(0, num_transitions - 1);
    if (cur_hmm_state.forward_pdf_class != -1) {
      std::pair<int32, int32> pr(cur_state, transition_index);
      if (!reorder) {
        path->push_back(pr);
      } else {
        bool is_self_loop = (cur_state ==
                             cur_hmm_state.transitions[transition_index].first);
        if (is_self_loop) { // save these up, we'll put them after the forward
                            // transition.
          pending_self_loops.push_back(pr);
        } else {
          // non-self-loop: output it and then flush out any self-loops we
          // stored up.
          path->push_back(pr);
          path->insert(path->end(), pending_self_loops.begin(),
                       pending_self_loops.end());
          pending_self_loops.clear();
        }
      }
    }
    cur_state = cur_hmm_state.transitions[transition_index].first;
  }
  KALDI_ASSERT(pending_self_loops.empty());
}

GenerateRandomAlignment()

void GenerateRandomAlignment	(	const ContextDependencyInterface &	ctx_dep,
		const TransitionModel &	trans_model,
		bool	reorder,
		const std::vector< int32 > &	phone_sequence,
		std::vector< int32 > *	alignment
	)

For use in test code, this function generates an alignment (a sequence of transition-ids) corresponding to a given phone sequence.

Definition at line 232 of file hmm-test-utils.cc.

References ContextDependencyInterface::CentralPosition(), ContextDependencyInterface::Compute(), ContextDependencyInterface::ContextWidth(), GeneratePathThroughHmm(), TransitionModel::GetTopo(), rnnlm::i, rnnlm::j, KALDI_ASSERT, TransitionModel::PairToTransitionId(), HmmTopology::TopologyForPhone(), and TransitionModel::TupleToTransitionState().

Referenced by TestConvertAlignment(), TestSplitToPhones(), and TestWordAlignLatticeLexicon().

                                                          {
  int32 context_width = ctx_dep.ContextWidth(),
      central_position = ctx_dep.CentralPosition(),
      num_phones = phone_sequence.size();
  alignment->clear();
  for (int32 i = 0; i < num_phones; i++) {
    std::vector<int32> context_window;
    context_window.reserve(context_width);
    for (int32 j = i - central_position;
         j < i - central_position + context_width;
         j++) {
      if (j >= 0 && j < num_phones) context_window.push_back(phone_sequence[j]);
      else context_window.push_back(0);  // zero for out-of-window phones
    }
    // 'path' is the path through this phone's HMM, represented as
    // (emitting-HMM-state, transition-index) pairs
    std::vector<std::pair<int32, int32> > path;
    int32 phone = phone_sequence[i];
    GeneratePathThroughHmm(trans_model.GetTopo(), reorder, phone, &path);
    for (size_t k = 0; k < path.size(); k++) {
      const HmmTopology::TopologyEntry &entry =
          trans_model.GetTopo().TopologyForPhone(phone);
      int32 hmm_state = path[k].first,
          transition_index = path[k].second,
          forward_pdf_class = entry[hmm_state].forward_pdf_class,
          self_loop_pdf_class = entry[hmm_state].self_loop_pdf_class,
          forward_pdf_id, self_loop_pdf_id;
      bool ans = ctx_dep.Compute(context_window, forward_pdf_class, &forward_pdf_id);
      KALDI_ASSERT(ans && "context-dependency computation failed.");
      ans = ctx_dep.Compute(context_window, self_loop_pdf_class, &self_loop_pdf_id);
      KALDI_ASSERT(ans && "context-dependency computation failed.");
      int32 transition_state = trans_model.TupleToTransitionState(
                               phone, hmm_state, forward_pdf_id, self_loop_pdf_id),
          transition_id = trans_model.PairToTransitionId(transition_state,
                                                         transition_index);
      alignment->push_back(transition_id);
    }
  }
}

GenerateWordAndPhoneSequence()

void kaldi::GenerateWordAndPhoneSequence	(	std::vector< std::vector< int32 > > &	lexicon,
		std::vector< int32 > *	phone_seq,
		std::vector< int32 > *	word_seq
	)

Definition at line 109 of file word-align-lattice-lexicon-test.cc.

References rnnlm::i, and RandInt().

Referenced by TestWordAlignLatticeLexicon().

                                                              {
  int32 num_words = RandInt(0, 5);
  phone_seq->clear();
  word_seq->clear();
  for (int32 i = 0; i < num_words; i++) {
    const std::vector<int32> &lexicon_entry =
        lexicon[RandInt(0, lexicon.size() - 1)];
    // the zeroth element of 'lexicon_entry' is how it appears in
    // the lattice prior to word alignment.
    int32 word = lexicon_entry[0];
    if (word != 0) word_seq->push_back(word);
    // add everything from position 2 in the lexicon entry, to the
    // phone sequence.
    phone_seq->insert(phone_seq->end(),
                      lexicon_entry.begin() + 2,
                      lexicon_entry.end());
  }
}

GenRandContextDependency()

ContextDependency * GenRandContextDependency	(	const std::vector< int32 > &	phones,
		bool	ensure_all_covered,
		std::vector< int32 > *	num_pdf_classes
	)

GenRandContextDependency is mainly of use for debugging.

Phones must be sorted and uniq on input.

Parameters

phones	[in] A vector of phone id's [must be sorted and uniq].
ensure_all_covered	[in] boolean argument; if true, GenRandContextDependency generates a context-dependency object that "works" for all phones [no gaps].
num_pdf_classes	[out] outputs a vector indexed by phone, of the number of pdf classes (e.g. states) for that phone.

Returns

Returns the a context dependency object.

Definition at line 46 of file context-dep.cc.

References BuildTree(), ContextDependency::ContextDependency(), DeleteBuildTreeStats(), GenRandStats(), rnnlm::i, Questions::InitRand(), IsSortedAndUniq(), KALDI_ASSERT, KALDI_VLOG, kAllKeysUnion, Rand(), and RandUniform().

Referenced by TestGenRandContextDependency().

                                                                           {
  KALDI_ASSERT(IsSortedAndUniq(phone_ids));
  int32 num_phones = phone_ids.size();
  int32 num_stats = 1 + (Rand() % 15) * (Rand() % 15);  // up to 14^2 + 1 separate stats.
  int32 N = 2 + Rand() % 3;  // 2, 3 or 4.
  int32 P = Rand() % N;
  float ctx_dep_prob = 0.7 + 0.3*RandUniform();
  int32 max_phone = *std::max_element(phone_ids.begin(), phone_ids.end());
  hmm_lengths->clear();
  hmm_lengths->resize(max_phone + 1, -1);
  std::vector<bool> is_ctx_dep(max_phone + 1);

  for (int32 i = 0; i <= max_phone; i++) {
    (*hmm_lengths)[i] = 1 + Rand() % 3;
    is_ctx_dep[i] = (RandUniform() < ctx_dep_prob);  // true w.p. ctx_dep_prob.
  }
  for (size_t i = 0; i < (size_t) num_phones; i++)
    KALDI_VLOG(2) <<  "For idx = " << i
                  << ", (phone_id, hmm_length, is_ctx_dep) == "
                  << (phone_ids[i]) << " " << ((*hmm_lengths)[phone_ids[i]])
                  << " " << (is_ctx_dep[phone_ids[i]]);
  // Generate rand stats.
  BuildTreeStatsType stats;
  size_t dim = 3 + Rand() % 20;
  GenRandStats(dim, num_stats, N, P, phone_ids, *hmm_lengths,
               is_ctx_dep, ensure_all_covered, &stats);

  // Now build the tree.

  Questions qopts;
  int32 num_quest = Rand() % 10, num_iters = rand () % 5;
  qopts.InitRand(stats, num_quest, num_iters, kAllKeysUnion);  // This was tested in build-tree-utils-test.cc

  float thresh = 100.0 * RandUniform();

  EventMap *tree = NULL;
  std::vector<std::vector<int32> > phone_sets(phone_ids.size());
  for (size_t i = 0; i < phone_ids.size(); i++)
    phone_sets[i].push_back(phone_ids[i]);
  std::vector<bool> share_roots(phone_sets.size(), true),
      do_split(phone_sets.size(), true);

  tree = BuildTree(qopts, phone_sets, *hmm_lengths, share_roots,
                   do_split, stats, thresh, 1000, 0.0, P);
  DeleteBuildTreeStats(&stats);
  return new ContextDependency(N, P, tree);
}

GenRandContextDependencyLarge()

ContextDependency * GenRandContextDependencyLarge	(	const std::vector< int32 > &	phones,
		int	N,
		int	P,
		bool	ensure_all_covered,
		std::vector< int32 > *	num_pdf_classes
	)

GenRandContextDependencyLarge is like GenRandContextDependency but generates a larger tree with specified N and P for use in "one-time" larger-scale tests.

Definition at line 97 of file context-dep.cc.

References BuildTree(), ContextDependency::ContextDependency(), DeleteBuildTreeStats(), GenRandStats(), rnnlm::i, Questions::InitRand(), IsSortedAndUniq(), KALDI_ASSERT, KALDI_VLOG, kAllKeysUnion, Rand(), and RandUniform().

Referenced by GenRandTransitionModel(), TestConvertAlignment(), kaldi::nnet2::UnitTestAmNnet(), and kaldi::nnet2::UnitTestNnetDecodable().

                                                                                {
  KALDI_ASSERT(IsSortedAndUniq(phone_ids));
  int32 num_phones = phone_ids.size();
  int32 num_stats = 3000;  // each is a separate context.
  float ctx_dep_prob = 0.9;
  KALDI_ASSERT(num_phones > 0);
  hmm_lengths->clear();
  int32 max_phone = *std::max_element(phone_ids.begin(), phone_ids.end());
  hmm_lengths->resize(max_phone + 1, -1);
  std::vector<bool> is_ctx_dep(max_phone + 1);

  for (int32 i = 0; i <= max_phone; i++) {
    (*hmm_lengths)[i] = 1 + Rand() % 3;
    is_ctx_dep[i] = (RandUniform() < ctx_dep_prob);  // true w.p. ctx_dep_prob.
  }
  for (size_t i = 0; i < (size_t) num_phones; i++) {
    KALDI_VLOG(2) <<  "For idx = "<< i << ", (phone_id, hmm_length, is_ctx_dep) == " << (phone_ids[i]) << " " << ((*hmm_lengths)[phone_ids[i]]) << " " << (is_ctx_dep[phone_ids[i]]);
  }
  // Generate rand stats.
  BuildTreeStatsType stats;
  size_t dim = 3 + Rand() % 20;
  GenRandStats(dim, num_stats, N, P, phone_ids, *hmm_lengths, is_ctx_dep, ensure_all_covered, &stats);

  // Now build the tree.

  Questions qopts;
  int32 num_quest = 40, num_iters = 0;
  qopts.InitRand(stats, num_quest, num_iters, kAllKeysUnion);  // This was tested in build-tree-utils-test.cc

  float thresh = 100.0 * RandUniform();

  EventMap *tree = NULL;
  std::vector<std::vector<int32> > phone_sets(phone_ids.size());
  for (size_t i = 0; i < phone_ids.size(); i++)
    phone_sets[i].push_back(phone_ids[i]);
  std::vector<bool> share_roots(phone_sets.size(), true),
      do_split(phone_sets.size(), true);

  tree = BuildTree(qopts, phone_sets, *hmm_lengths, share_roots,
                   do_split, stats, thresh, 1000, 0.0, P);
  DeleteBuildTreeStats(&stats);
  return new ContextDependency(N, P, tree);
}

GenRandTopology() [1/2]

HmmTopology GenRandTopology	(	const std::vector< int32 > &	phones,
		const std::vector< int32 > &	num_pdf_classes
	)

This method of generating an arbitrary HmmTopology object allows you to specify the number of pdf-classes for each phone separately.

'num_pdf_classes' is indexed by the phone-index (so the length will be longer than the length of the 'phones' vector, which for example lacks the zero index and may have gaps).

Definition at line 87 of file hmm-test-utils.cc.

References rnnlm::i, IsSortedAndUniq(), rnnlm::j, KALDI_ASSERT, rnnlm::n, RandInt(), and HmmTopology::Read().

Referenced by GenRandTopology(), GenRandTransitionModel(), TestConvertAlignment(), and TestHmmTopology().

                                                                     {
  std::vector<int32> phones(phones_in);
  std::sort(phones.begin(), phones.end());
  KALDI_ASSERT(IsSortedAndUniq(phones) && !phones.empty());

  std::ostringstream topo_string;

   std::map<int32, std::vector<int32> > num_pdf_classes_to_phones;
  for (size_t i = 0; i < phones.size(); i++) {
    int32 p = phones[i];
    KALDI_ASSERT(static_cast<size_t>(p) < num_pdf_classes.size());
    int32 n = num_pdf_classes[p];
    KALDI_ASSERT(n > 0 && "num-pdf-classes cannot be zero.");
    num_pdf_classes_to_phones[n].push_back(p);
  }

  topo_string <<  "<Topology>\n";
  std::map<int32, std::vector<int32> >::const_iterator
      iter = num_pdf_classes_to_phones.begin(),
      end = num_pdf_classes_to_phones.end();
  for (; iter != end; ++iter) {
    topo_string << "<TopologyEntry>\n"
        "<ForPhones> ";
    int32 this_num_pdf_classes = iter->first;
    const std::vector<int32> &phones = iter->second;
    for (size_t i = 0; i < phones.size(); i++)
      topo_string << phones[i] << " ";
    topo_string << "</ForPhones> ";
    bool ergodic = (RandInt(0, 1) == 0);
    if (ergodic) {
      // Note, this type of topology is not something we ever use in practice- it
      // has an initial nonemitting state (no PdfClass specified).  But it's
      // supported so we're testing it.
      std::vector<int32> state_to_pdf_class;
      state_to_pdf_class.push_back(-1);  // state zero, nonemitting.
      for (int32 i = 0; i < this_num_pdf_classes; i++) {
        int32 num_states = RandInt(1, 2);
        for (int32 j = 0; j < num_states; j++)
          state_to_pdf_class.push_back(i);
      }
      state_to_pdf_class.push_back(-1);  // final non-emitting state.
      { // state zero is nonemitting.  This is not something used in any current
        // example script.
        topo_string << "<State> 0\n";
        BaseFloat prob = 1.0 / (state_to_pdf_class.size() - 2);
        for (size_t i = 1; i + 1 < state_to_pdf_class.size(); i++) {
          topo_string << "<Transition> " << i << ' ' << prob << '\n';
        }
        topo_string << "</State>\n";
      }
      // ergodic part.
      for (size_t i = 1; i + 1 < state_to_pdf_class.size(); i++) {
        BaseFloat prob = 1.0 / (state_to_pdf_class.size() - 1);
        topo_string << "<State> " << i << " <PdfClass> "
                    << state_to_pdf_class[i] << '\n';
        for (size_t j = 1; j < state_to_pdf_class.size(); j++)
          topo_string << "<Transition> " << j << ' ' << prob << '\n';
        topo_string << "</State>\n";
      }
      // final, nonemitting state.  No pdf-class, no transitions.
      topo_string << "<State> " << (state_to_pdf_class.size() - 1) << " </State>\n";
    } else {
      // feedforward topology.
      int32 cur_state = 0;
      for (int32 pdf_class = 0; pdf_class < this_num_pdf_classes; pdf_class++) {
        int32 this_num_states = RandInt(1, 2);
        for (int32 s = 0; s < this_num_states; s++) {
          topo_string << "<State> " << cur_state << " <PdfClass> " << pdf_class
                      << "\n<Transition> " << cur_state << " 0.5\n<Transition> "
                      << (cur_state + 1) << " 0.5\n</State>\n";
          cur_state++;
        }
      }
      // final, non-emitting state.
      topo_string << "<State> " << cur_state << " </State>\n";
    }
    topo_string << "</TopologyEntry>\n";
  }
  topo_string << "</Topology>\n";

  HmmTopology topo;
  std::istringstream iss(topo_string.str());
  topo.Read(iss, false);
  return topo;
}

GenRandTopology() [2/2]

HmmTopology GenRandTopology

(

)

This version of GenRandTopology() generates the phone list and number of pdf classes randomly.

Definition at line 174 of file hmm-test-utils.cc.

References GenRandTopology(), GetDefaultTopology(), rnnlm::i, and RandInt().

                              {
  std::vector<int32> phones;
  phones.push_back(1);
  for (int32 i = 2; i < 20; i++)
    if (rand() % 2 == 0)
      phones.push_back(i);
  if (RandInt(0, 1) == 0) {
    return GetDefaultTopology(phones);
  } else {
    std::vector<int32> num_pdf_classes(phones.back() + 1, -1);
    for (int32 i = 0; i < phones.size(); i++)
      num_pdf_classes[phones[i]] = RandInt(1, 5);
    return GenRandTopology(phones, num_pdf_classes);
  }
}

GenRandTransitionModel()

TransitionModel * GenRandTransitionModel

(

ContextDependency **

ctx_dep_out

)

Definition at line 26 of file hmm-test-utils.cc.

References GenRandContextDependencyLarge(), GenRandTopology(), and rnnlm::i.

Referenced by TestSplitToPhones(), TestTransitionModel(), and TestWordAlignLatticeLexicon().

                                                                         {
  std::vector<int32> phones;
  phones.push_back(1);
  for (int32 i = 2; i < 20; i++)
    if (rand() % 2 == 0)
      phones.push_back(i);
  int32 N = 2 + rand() % 2, // context-size N is 2 or 3.
      P = rand() % N;  // Central-phone is random on [0, N)

  std::vector<int32> num_pdf_classes;

  ContextDependency *ctx_dep =
      GenRandContextDependencyLarge(phones, N, P,
                                    true, &num_pdf_classes);

  HmmTopology topo = GenRandTopology(phones, num_pdf_classes);

  TransitionModel *trans_model = new TransitionModel(*ctx_dep, topo);

  if (ctx_dep_out == NULL) delete ctx_dep;
  else *ctx_dep_out = ctx_dep;
  return trans_model;
}

GetActiveParents()

static bool kaldi::GetActiveParents ( int32  node, const vector< int32 > &  parents, const vector< bool > &  is_active, vector< int32 > *  active_parents_out  )

static

Definition at line 129 of file regression-tree.cc.

References KALDI_ASSERT.

Referenced by RegressionTree::GatherStats().

                                                                {
  KALDI_ASSERT(parents.size() == is_active.size());
  KALDI_ASSERT(static_cast<size_t>(node) < parents.size());
  active_parents_out->clear();

  if (node == static_cast<int32> (parents.size() - 1)) {  // root node
    if (is_active[node]) {
      active_parents_out->push_back(node);
      return true;
    } else {
      return false;
    }
  }

  bool ret_val = false;
  while (node < static_cast<int32> (parents.size() - 1)) {  // exclude the root
    node = parents[node];
    if (is_active[node]) {
      active_parents_out->push_back(node);
      ret_val = true;
    }
  }
  return ret_val;  // will return if not starting from root
}

GetBootstrapWERInterval()

void kaldi::GetBootstrapWERInterval	(	const std::vector< std::pair< int32, int32 > > &	edit_word_per_hyp,
		int32	replications,
		BaseFloat *	mean,
		BaseFloat *	interval
	)

Definition at line 113 of file compute-wer-bootci.cc.

References rnnlm::i, rnnlm::j, and RandInt().

Referenced by main().

                                            {
    BaseFloat wer_accum = 0.0, wer_mult_accum = 0.0;

    for (int32 i = 0; i < replications; ++i) {
      int32 num_words = 0, word_errs = 0;
      for (int32 j = 0; j < edit_word_per_hyp.size(); ++j) {
        int32 random_pos = kaldi::RandInt(0, edit_word_per_hyp.size() - 1);
        word_errs += edit_word_per_hyp[random_pos].first;
        num_words += edit_word_per_hyp[random_pos].second;
        }

      BaseFloat wer_rep = static_cast<BaseFloat>(word_errs) / num_words;
      wer_accum += wer_rep;
      wer_mult_accum += wer_rep*wer_rep;
    }

    // Compute mean WER and std WER
    *mean = wer_accum / replications;
    *interval = 1.96*sqrt(wer_mult_accum/replications-(*mean)*(*mean));
}

GetBootstrapWERTwoSystemComparison()

void kaldi::GetBootstrapWERTwoSystemComparison	(	const std::vector< std::pair< int32, int32 > > &	edit_word_per_hyp,
		const std::vector< std::pair< int32, int32 > > &	edit_word_per_hyp2,
		int32	replications,
		BaseFloat *	p_improv
	)

Definition at line 137 of file compute-wer-bootci.cc.

References rnnlm::i, rnnlm::j, and RandInt().

Referenced by main().

                                               {
    int32 improv_accum = 0.0;

    for (int32 i = 0; i < replications; ++i) {
      int32 word_errs = 0;
      for (int32 j = 0; j < edit_word_per_hyp.size(); ++j) {
        int32 random_pos = kaldi::RandInt(0, edit_word_per_hyp.size() - 1);
        word_errs += edit_word_per_hyp[random_pos].first -
                        edit_word_per_hyp2[random_pos].first;
        }
      if(word_errs > 0)
        ++improv_accum;
    }
    // Compute mean WER and std WER
    *p_improv = static_cast<BaseFloat>(improv_accum) / replications;
}

GetCount()

int32 kaldi::GetCount

(

double

expected_count

)

Definition at line 29 of file nnet3-discriminative-copy-egs.cc.

References KALDI_ASSERT, and WithProb().

                                      {
  KALDI_ASSERT(expected_count >= 0.0);
  int32 ans = floor(expected_count);
  expected_count -= ans;
  if (WithProb(expected_count))
    ans++;
  return ans;
}

GetDefaultTopology()

HmmTopology GetDefaultTopology

(

const std::vector< int32 > &

phones

)

This function returns a HmmTopology object giving a normal 3-state topology, covering all phones in the list "phones".

This is mainly of use in testing code.

Definition at line 50 of file hmm-test-utils.cc.

References rnnlm::i, IsSortedAndUniq(), KALDI_ASSERT, and HmmTopology::Read().

Referenced by GenRandTopology(), TestHmmTopology(), kaldi::nnet2::UnitTestAmNnet(), and kaldi::nnet2::UnitTestNnetDecodable().

                                                                  {
  std::vector<int32> phones(phones_in);
  std::sort(phones.begin(), phones.end());
  KALDI_ASSERT(IsSortedAndUniq(phones) && !phones.empty());

  std::ostringstream topo_string;
  topo_string <<  "<Topology>\n"
      "<TopologyEntry>\n"
      "<ForPhones> ";
  for (size_t i = 0; i < phones.size(); i++)
    topo_string << phones[i] << " ";

  topo_string << "</ForPhones>\n"
      "<State> 0 <PdfClass> 0\n"
      "<Transition> 0 0.5\n"
      "<Transition> 1 0.5\n"
      "</State> \n"
      "<State> 1 <PdfClass> 1 \n"
      "<Transition> 1 0.5\n"
      "<Transition> 2 0.5\n"
      "</State>  \n"
      " <State> 2 <PdfClass> 2\n"
      " <Transition> 2 0.5\n"
      " <Transition> 3 0.5\n"
      " </State>   \n"
      " <State> 3 </State>\n"
      " </TopologyEntry>\n"
      " </Topology>\n";

  HmmTopology topo;
  std::istringstream iss(topo_string.str());
  topo.Read(iss, false);
  return topo;

}

GetDiagnosticsAndPrintOutput()

void GetDiagnosticsAndPrintOutput	(	const std::string &	utt,
		const fst::SymbolTable *	word_syms,
		const CompactLattice &	clat,
		int64 *	tot_num_frames,
		double *	tot_like
	)

Definition at line 31 of file online2-wav-gmm-latgen-faster.cc.

References CompactLatticeShortestPath(), fst::ConvertLattice(), fst::GetLinearSymbolSequence(), rnnlm::i, KALDI_ERR, KALDI_VLOG, KALDI_WARN, LatticeWeightTpl< FloatType >::Value1(), LatticeWeightTpl< FloatType >::Value2(), and words.

Referenced by main().

                                                    {
  if (clat.NumStates() == 0) {
    KALDI_WARN << "Empty lattice.";
    return;
  }
  CompactLattice best_path_clat;
  CompactLatticeShortestPath(clat, &best_path_clat);
  
  Lattice best_path_lat;
  ConvertLattice(best_path_clat, &best_path_lat);
  
  double likelihood;
  LatticeWeight weight;
  int32 num_frames;
  std::vector<int32> alignment;
  std::vector<int32> words;
  GetLinearSymbolSequence(best_path_lat, &alignment, &words, &weight);
  num_frames = alignment.size();
  likelihood = -(weight.Value1() + weight.Value2());
  *tot_num_frames += num_frames;
  *tot_like += likelihood;
  KALDI_VLOG(2) << "Likelihood per frame for utterance " << utt << " is "
                << (likelihood / num_frames) << " over " << num_frames
                << " frames.";
             
  if (word_syms != NULL) {
    std::cerr << utt << ' ';
    for (size_t i = 0; i < words.size(); i++) {
      std::string s = word_syms->Find(words[i]);
      if (s == "")
        KALDI_ERR << "Word-id " << words[i] << " not in symbol table.";
      std::cerr << s << ' ';
    }
    std::cerr << std::endl;
  }
}

GetEditsDualHyp()

void kaldi::GetEditsDualHyp	(	const std::string &	hyp_rspecifier,
		const std::string &	hyp_rspecifier2,
		const std::string &	ref_rspecifier,
		const std::string &	mode,
		std::vector< std::pair< int32, int32 > > &	edit_word_per_hyp,
		std::vector< std::pair< int32, int32 > > &	edit_word_per_hyp2
	)

Definition at line 63 of file compute-wer-bootci.cc.

References SequentialTableReader< Holder >::Done(), RandomAccessTableReader< Holder >::HasKey(), KALDI_ERR, SequentialTableReader< Holder >::Key(), LevenshteinEditDistance(), SequentialTableReader< Holder >::Next(), RandomAccessTableReader< Holder >::Value(), and SequentialTableReader< Holder >::Value().

Referenced by main().

                                                              {

    // Both text and integers are loaded as vector of strings,
    SequentialTokenVectorReader ref_reader(ref_rspecifier);
    RandomAccessTokenVectorReader hyp_reader(hyp_rspecifier);
    RandomAccessTokenVectorReader hyp_reader2(hyp_rspecifier2);
    int32 num_words = 0, word_errs = 0,
            num_ins = 0, num_del = 0, num_sub = 0;

    // Main loop, store WER stats per hyp,
    for (; !ref_reader.Done(); ref_reader.Next()) {
      std::string key = ref_reader.Key();
      const std::vector<std::string> &ref_sent = ref_reader.Value();
      std::vector<std::string> hyp_sent, hyp_sent2;
      if (mode == "strict" &&
              (!hyp_reader.HasKey(key) || !hyp_reader2.HasKey(key))) {
          KALDI_ERR << "No hypothesis for key " << key << " in both transcripts "
              "comparison is not possible.";
      } else if (mode == "present" &&
              (!hyp_reader.HasKey(key) || !hyp_reader2.HasKey(key)))
          continue;

      num_words = ref_sent.size();

      //all mode, if a hypothesis is not present, consider as an error
      if(hyp_reader.HasKey(key)){
        hyp_sent = hyp_reader.Value(key);
        word_errs = LevenshteinEditDistance(ref_sent, hyp_sent,
                                            &num_ins, &num_del, &num_sub);
      }
      else
        word_errs = num_words;
      edit_word_per_hyp.push_back(std::pair<int32, int32>(word_errs, num_words));

      if(hyp_reader2.HasKey(key)){
        hyp_sent2 = hyp_reader2.Value(key);
        word_errs = LevenshteinEditDistance(ref_sent, hyp_sent2,
                                            &num_ins, &num_del, &num_sub);
      }
      else
        word_errs = num_words;
      edit_word_per_hyp2.push_back(std::pair<int32, int32>(word_errs, num_words));
    }
}

GetEditsSingleHyp()

void kaldi::GetEditsSingleHyp	(	const std::string &	hyp_rspecifier,
		const std::string &	ref_rspecifier,
		const std::string &	mode,
		std::vector< std::pair< int32, int32 > > &	edit_word_per_hyp
	)

Definition at line 32 of file compute-wer-bootci.cc.

References SequentialTableReader< Holder >::Done(), RandomAccessTableReader< Holder >::HasKey(), KALDI_ERR, SequentialTableReader< Holder >::Key(), LevenshteinEditDistance(), SequentialTableReader< Holder >::Next(), RandomAccessTableReader< Holder >::Value(), and SequentialTableReader< Holder >::Value().

Referenced by main().

                                                             {

    // Both text and integers are loaded as vector of strings,
    SequentialTokenVectorReader ref_reader(ref_rspecifier);
    RandomAccessTokenVectorReader hyp_reader(hyp_rspecifier);
    int32 num_words = 0, word_errs = 0, num_ins = 0, num_del = 0, num_sub = 0;

    // Main loop, store WER stats per hyp,
    for (; !ref_reader.Done(); ref_reader.Next()) {
      std::string key = ref_reader.Key();
      const std::vector<std::string> &ref_sent = ref_reader.Value();
      std::vector<std::string> hyp_sent;
      if (!hyp_reader.HasKey(key)) {
        if (mode == "strict")
          KALDI_ERR << "No hypothesis for key " << key << " and strict "
              "mode specifier.";
        if (mode == "present")  // do not score this one.
          continue;
      } else {
        hyp_sent = hyp_reader.Value(key);
      }
      num_words = ref_sent.size();
      word_errs = LevenshteinEditDistance(ref_sent, hyp_sent,
                                            &num_ins, &num_del, &num_sub);
      edit_word_per_hyp.push_back(std::pair<int32, int32>(word_errs, num_words));
    }
}

GetEventKeys()

static void kaldi::GetEventKeys ( const EventType &  vec, std::vector< EventKeyType > *  keys  )

static

Definition at line 81 of file build-tree-utils.cc.

Referenced by FindAllKeys().

                                                                              {
  keys->resize(vec.size());
  EventType::const_iterator iter = vec.begin(), end = vec.end();
  std::vector<EventKeyType>::iterator out_iter = keys->begin();
  for (; iter!= end; ++iter, ++out_iter)
    *out_iter = iter->first;
}

GetFeatDeriv()

void kaldi::GetFeatDeriv	(	const DiagGmm &	gmm,
		const Matrix< BaseFloat > &	feats,
		Matrix< BaseFloat > *	deriv
	)

Definition at line 32 of file fmpe-test.cc.

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::AddVecVec(), DiagGmm::ComponentPosteriors(), rnnlm::i, DiagGmm::inv_vars(), kTrans, DiagGmm::means_invvars(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), and VectorBase< Real >::Scale().

Referenced by TestFmpe().

                                            {
  
  deriv->Resize(feats.NumRows(), feats.NumCols());

  Vector<BaseFloat> gauss_posteriors;
  Vector<BaseFloat> temp_vec(feats.NumCols());
  for (int32 i = 0; i < feats.NumRows(); i++) {
    SubVector<BaseFloat> this_feat(feats, i);
    SubVector<BaseFloat> this_deriv(*deriv, i);
    gmm.ComponentPosteriors(this_feat, &gauss_posteriors);
    BaseFloat weight = 1.0;
    gauss_posteriors.Scale(weight);
    // The next line does: to i'th row of deriv, add
    // means_invvars^T * gauss_posteriors,
    // where each row of means_invvars is the mean times
    // diagonal inverse covariance... after transposing,
    // this becomes a weighted of these rows, weighted by
    // the posteriors.  This comes from the term
    //  feat^T * inv_var * mean
    // in the objective function.
    this_deriv.AddMatVec(1.0, gmm.means_invvars(), kTrans,
                         gauss_posteriors, 1.0);

    // next line does temp_vec == inv_vars^T * gauss_posteriors,
    // which sets temp_vec to a weighted sum of the inv_vars,
    // weighed by Gaussian posterior.
    temp_vec.AddMatVec(1.0, gmm.inv_vars(), kTrans,
                       gauss_posteriors, 0.0);
    // Add to the derivative, -(this_feat .* temp_vec),
    // which is the term that comes from the -0.5 * inv_var^T feat_sq,
    // in the objective function (where inv_var is a vector, and feat_sq
    // is a vector of squares of the feature values).
    this_deriv.AddVecVec(-1.0, this_feat, temp_vec, 1.0);
  }
}

GetFeatureMeanAndVariance()

void kaldi::GetFeatureMeanAndVariance	(	const std::string &	feat_rspecifier,
		Vector< BaseFloat > *	inv_var_out,
		Vector< BaseFloat > *	mean_out
	)

Definition at line 33 of file gmm-init-model-flat.cc.

References VectorBase< Real >::AddVec(), VectorBase< Real >::AddVec2(), VectorBase< Real >::CopyFromVec(), count, VectorBase< Real >::Dim(), SequentialTableReader< Holder >::Done(), rnnlm::i, VectorBase< Real >::InvertElements(), KALDI_ERR, VectorBase< Real >::Min(), SequentialTableReader< Holder >::Next(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Vector< Real >::Resize(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), and SequentialTableReader< Holder >::Value().

Referenced by main().

                                                            {
  double count = 0.0;
  Vector<double> x_stats, x2_stats;

  SequentialDoubleMatrixReader feat_reader(feat_rspecifier);
  for (; !feat_reader.Done(); feat_reader.Next()) {
    const Matrix<double> &mat = feat_reader.Value();
    if (x_stats.Dim() == 0) {
      int32 dim = mat.NumCols();
      x_stats.Resize(dim);
      x2_stats.Resize(dim);
    }
    for (int32 i = 0; i < mat.NumRows(); i++) {
      count += 1.0;
      x_stats.AddVec(1.0, mat.Row(i));
      x2_stats.AddVec2(1.0, mat.Row(i));
    }
  }
  if (count == 0) { KALDI_ERR << "No features were read!"; }
  x_stats.Scale(1.0/count);
  x2_stats.Scale(1.0/count);
  x2_stats.AddVec2(-1.0, x_stats);
  if (x2_stats.Min() <= 0.0)
    KALDI_ERR << "Variance is zero or negative!";
  x2_stats.InvertElements();
  int32 dim = x_stats.Dim();
  inv_var_out->Resize(dim);
  mean_out->Resize(dim);
  inv_var_out->CopyFromVec(x2_stats);
  mean_out->CopyFromVec(x_stats);
}

GetFullBiphoneStubMap()

EventMap* kaldi::GetFullBiphoneStubMap	(	const std::vector< std::vector< int32 > > &	phone_sets,
		const std::vector< int32 > &	phone2num_pdf_classes,
		const std::vector< int32 > &	ci_phones_list,
		const std::vector< std::vector< int32 > > &	bi_counts,
		int32	biphone_min_count,
		const std::vector< int32 > &	mono_counts,
		int32	mono_min_count
	)

Definition at line 53 of file gmm-init-biphone.cc.

References rnnlm::i, IsSortedAndUniq(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, KALDI_VLOG, and kPdfClass.

Referenced by BiphoneContextDependencyFull().

                                             {

  {  // Check the inputs
    KALDI_ASSERT(!phone_sets.empty());
    std::set<int32> all_phones;
    for (size_t i = 0; i < phone_sets.size(); i++) {
      KALDI_ASSERT(IsSortedAndUniq(phone_sets[i]));
      KALDI_ASSERT(!phone_sets[i].empty());
      for (size_t j = 0; j < phone_sets[i].size(); j++) {
        KALDI_ASSERT(all_phones.count(phone_sets[i][j]) == 0);  // Check not present.
        all_phones.insert(phone_sets[i][j]);
      }
    }
  }


  int32 numpdfs_per_phone = phone2num_pdf_classes[1];
  int32 current_pdfid = 0;
  std::map<EventValueType, EventMap*> level1_map;  // key is 1

  for (size_t i = 0; i < ci_phones_list.size(); i++) {
    std::map<EventValueType, EventAnswerType> level2_map;
    level2_map[0] = current_pdfid++;
    if (numpdfs_per_phone == 2) level2_map[1] = current_pdfid++;
    level1_map[ci_phones_list[i]] = new TableEventMap(kPdfClass, level2_map);
  }

  // If there is not enough data for a biphone, we will revert to monophone
  // and if there is not enough data for the monophone either, we will revert
  // to zerophone (which is like a global garbage pdf) after initializing it.
  int32 zerophone_pdf = -1;
  // If a monophone state is created for a phone-set, the corresponding pdf will
  // be stored in this vector.
  std::vector<int32> monophone_pdf(phone_sets.size(), -1);

  for (size_t i = 0; i < phone_sets.size(); i++) {

    if (numpdfs_per_phone == 1) {
      // Create an event map for level2:
      std::map<EventValueType, EventAnswerType> level2_map;  // key is 0
      level2_map[0] = current_pdfid++;  // no-left-context case
      for (size_t j = 0; j < phone_sets.size(); j++) {
        int32 pdfid = current_pdfid++;
        std::vector<int32> pset = phone_sets[j];  // All these will have a
                                                  // shared pdf with id=pdfid
        for (size_t k = 0; k < pset.size(); k++)
          level2_map[pset[k]] = pdfid;
      }
      std::vector<int32> pset = phone_sets[i];  // All these will have a
                                                // shared event-map child
      for (size_t k = 0; k < pset.size(); k++)
        level1_map[pset[k]] = new TableEventMap(0, level2_map);
    } else {
      KALDI_ASSERT(numpdfs_per_phone == 2);
      std::vector<int32> right_phoneset = phone_sets[i];  // All these will have a shared
                                                // event-map child
      // Create an event map for level2:
      std::map<EventValueType, EventMap*> level2_map;  // key is 0
      {  // Handle CI phones
        std::map<EventValueType, EventAnswerType> level3_map;  // key is kPdfClass
        level3_map[0] = current_pdfid++;
        level3_map[1] = current_pdfid++;
        level2_map[0] = new TableEventMap(kPdfClass, level3_map);  // no-left-context case
        for (size_t i = 0; i < ci_phones_list.size(); i++)  // ci-phone left-context cases
          level2_map[ci_phones_list[i]] = new TableEventMap(kPdfClass, level3_map);
      }
      for (size_t j = 0; j < phone_sets.size(); j++) {
        std::vector<int32> left_phoneset = phone_sets[j];  // All these will have a
        // shared subtree with 2 pdfids
        std::map<EventValueType, EventAnswerType> level3_map;  // key is kPdfClass
        if (bi_counts.empty() ||
            bi_counts[left_phoneset[0]][right_phoneset[0]] >= biphone_min_count) {
          level3_map[0] = current_pdfid++;
          level3_map[1] = current_pdfid++;
        } else if (mono_counts.empty() ||
                   mono_counts[right_phoneset[0]] > mono_min_count) {
          //  Revert to mono.
          KALDI_VLOG(2) << "Reverting to mono for biphone (" << left_phoneset[0]
                        << "," << right_phoneset[0] << ")";
          if (monophone_pdf[i] == -1) {
            KALDI_VLOG(1) << "Reserving mono PDFs for phone-set " << i;
            monophone_pdf[i] = current_pdfid++;
            current_pdfid++; // num-pdfs-per-phone is 2
          }
          level3_map[0] = monophone_pdf[i];
          level3_map[1] = monophone_pdf[i] + 1;
        } else {
          KALDI_VLOG(2) << "Reverting to zerophone for biphone ("
                        << left_phoneset[0]
                        << "," << right_phoneset[0] << ")";
          // Revert to zerophone
          if (zerophone_pdf == -1) {
            KALDI_VLOG(1) << "Reserving zero PDFs.";
            zerophone_pdf = current_pdfid++;
            current_pdfid++; // num-pdfs-per-phone is 2
          }
          level3_map[0] = zerophone_pdf;
          level3_map[1] = zerophone_pdf + 1;
        }

        for (size_t k = 0; k < left_phoneset.size(); k++) {
          int32 left_phone = left_phoneset[k];
          level2_map[left_phone] = new TableEventMap(kPdfClass, level3_map);
        }
      }
      for (size_t k = 0; k < right_phoneset.size(); k++) {
        std::map<EventValueType, EventMap*> level2_copy;
        for (auto const& kv: level2_map)
          level2_copy[kv.first] = kv.second->Copy(std::vector<EventMap*>());
        int32 right_phone = right_phoneset[k];
        level1_map[right_phone] = new TableEventMap(0, level2_copy);
      }
    }

  }
  KALDI_LOG << "Num PDFs: " << current_pdfid;
  return new TableEventMap(1, level1_map);
}

GetGmmLike()

BaseFloat kaldi::GetGmmLike	(	const DiagGmm &	gmm,
		const Matrix< BaseFloat > &	feats
	)

Definition at line 71 of file fmpe-test.cc.

References rnnlm::i, DiagGmm::LogLikelihood(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::Row().

Referenced by TestFmpe().

                                                     {
  BaseFloat ans = 0.0;
  for (int32 i = 0; i < feats.NumRows(); i++)
    ans += gmm.LogLikelihood(feats.Row(i));
  return ans;
}

GetLatticeTimeSpan()

int32 kaldi::GetLatticeTimeSpan

(

const Lattice &

lat

)

Definition at line 96 of file online2-tcp-nnet3-decode-faster.cc.

References LatticeStateTimes().

Referenced by main().

                                             {
  std::vector<int32> times;
  LatticeStateTimes(lat, &times);
  return times.back();
}

GetLogDetNoFailure()

static double kaldi::GetLogDetNoFailure ( const SpMatrix< double > &  var )

static

Definition at line 345 of file ivector-extractor.cc.

References SpMatrix< Real >::Eig(), KALDI_WARN, SpMatrix< Real >::LogPosDefDet(), and PackedMatrix< Real >::NumRows().

Referenced by IvectorExtractor::GetPriorAuxf().

                                                              {
  try {
    return var.LogPosDefDet();
  } catch (...) {
    Vector<double> eigs(var.NumRows());
    var.Eig(&eigs);
    int32 floored;
    eigs.ApplyFloor(1.0e-20, &floored);
    if (floored > 0)
      KALDI_WARN << "Floored " << floored << " eigenvalues of variance.";
    eigs.ApplyLog();
    return eigs.Sum();
  }
}

GetOccs()

void kaldi::GetOccs	(	const BuildTreeStatsType &	stats,
		const EventMap &	to_pdf_map,
		Vector< BaseFloat > *	occs
	)

Get state occupation counts.

Definition at line 92 of file gmm-init-model.cc.

References VectorBase< Real >::Dim(), KALDI_ASSERT, EventMap::MaxResult(), Vector< Real >::Resize(), SplitStatsByMap(), and SumNormalizer().

Referenced by main().

                                      {

    // Get stats split by tree-leaf ( == pdf):
  std::vector<BuildTreeStatsType> split_stats;
  SplitStatsByMap(stats, to_pdf_map, &split_stats);
  if (split_stats.size() != to_pdf_map.MaxResult()+1) {
    KALDI_ASSERT(split_stats.size() < to_pdf_map.MaxResult()+1);
    split_stats.resize(to_pdf_map.MaxResult()+1);
  }
  occs->Resize(split_stats.size());
  for (int32 pdf = 0; pdf < occs->Dim(); pdf++)
    (*occs)(pdf) = SumNormalizer(split_stats[pdf]);
}

GetOptionImpl()

static bool kaldi::GetOptionImpl ( const std::string &  key, T *  value, std::map< std::string, T *> &  some_map  )

static

Definition at line 130 of file simple-options.cc.

Referenced by SimpleOptions::GetOption().

                                                           {
  typename std::map<std::string, T*>::iterator it  = some_map.find(key);
  if (it != some_map.end()) {
    *value = *(it->second);
    return true;
  }
  return false;
}

GetOutput() [1/2]

void kaldi::GetOutput	(	OnlineFeatureInterface *	a,
		Matrix< BaseFloat > *	output
	)

Definition at line 29 of file online-feature-test.cc.

References OnlineCacheFeature::ClearCache(), MatrixBase< Real >::CopyRowFromVec(), OnlineFeatureInterface::Dim(), OnlineCacheFeature::GetFrame(), rnnlm::i, OnlineCacheFeature::IsLastFrame(), KALDI_ASSERT, OnlineFeatureInterface::NumFramesReady(), and Matrix< Real >::Resize().

Referenced by PldaEstimator::Dim(), TestOnlineAppendFeature(), TestOnlineCmnInput(), TestOnlineDeltaFeature(), TestOnlineDeltaInput(), TestOnlineLdaInput(), TestOnlineMatrixCacheFeature(), TestOnlineMatrixInput(), TestOnlineMfcc(), TestOnlinePlp(), TestOnlineSpliceFrames(), and TestOnlineTransform().

                                          {
  int32 dim = a->Dim();
  int32 frame_num = 0;
  OnlineCacheFeature cache(a);

  std::vector<Vector<BaseFloat>* > cached_frames;
  while (true) {
    Vector<BaseFloat> garbage(dim);
    cache.GetFrame(frame_num, &garbage);
    cached_frames.push_back(new Vector<BaseFloat>(garbage));
    if (cache.IsLastFrame(frame_num))
      break;
    frame_num++;
  }

  KALDI_ASSERT(cached_frames.size() == a->NumFramesReady());

  output->Resize(cached_frames.size(), dim);
  for (int32 i = 0; i < cached_frames.size(); i++) {
    output->CopyRowFromVec(*(cached_frames[i]), i);
    delete cached_frames[i];
  }
  cached_frames.clear();
  cache.ClearCache();
}

GetOutput() [2/2]

void kaldi::GetOutput	(	OnlineFeatInputItf *	a,
		Matrix< BaseFloat > *	output
	)

Definition at line 81 of file online-feat-test.cc.

References OnlineCacheInput::Compute(), OnlineFeatInputItf::Dim(), OnlineCacheInput::GetCachedData(), Rand(), and Matrix< Real >::Resize().

                                          {
  int32 dim = a->Dim();
  OnlineCacheInput cache(a);
  while (true) {
    Matrix<BaseFloat> garbage;
    int32 batch_size = 1 + Rand() % 10;
    garbage.Resize(batch_size, dim); // some random requested amount.
    if (!cache.Compute(&garbage)) // returns false when done.
      break;
  }
  cache.GetCachedData(output);
}

GetPerFrameAcousticCosts()

void GetPerFrameAcousticCosts	(	const Lattice &	nbest,
		Vector< BaseFloat > *	per_frame_loglikes
	)

This function extracts the per-frame log likelihoods from a linear lattice (which we refer to as an 'nbest' lattice elsewhere in Kaldi code).

The dimension of *per_frame_loglikes will be set to the number of input symbols in 'nbest'. The elements of '*per_frame_loglikes' will be set to the .Value2() elements of the lattice weights, which represent the acoustic costs; you may want to scale this vector afterward by -1/acoustic_scale to get the original loglikes. If there are acoustic costs on input-epsilon arcs or the final-prob in 'nbest' (and this should not normally be the case in situations where it makes sense to call this function), they will be included to the cost of the preceding input symbol, or the following input symbol for input-epsilons encountered prior to any input symbol. If 'nbest' has no input symbols, 'per_frame_loglikes' will be set to the empty vector.

Definition at line 36 of file lattice-functions.cc.

References KALDI_ASSERT.

Referenced by AlignUtteranceWrapper().

                                                                                           {
  using namespace fst;
  typedef Lattice::Arc::Weight Weight;
  vector<BaseFloat> loglikes;

  int32 cur_state = nbest.Start();
  int32 prev_frame = -1;
  BaseFloat eps_acwt = 0.0;
  while(1) {
    Weight w = nbest.Final(cur_state);
    if (w != Weight::Zero()) {
      KALDI_ASSERT(nbest.NumArcs(cur_state) == 0);
      if (per_frame_loglikes != NULL)  {
        SubVector<BaseFloat> subvec(&(loglikes[0]), loglikes.size());
        Vector<BaseFloat> vec(subvec);
        *per_frame_loglikes = vec;
      }
      break;
    } else {
      KALDI_ASSERT(nbest.NumArcs(cur_state) == 1);
      fst::ArcIterator<Lattice> iter(nbest, cur_state);
      const Lattice::Arc &arc = iter.Value();
      BaseFloat acwt = arc.weight.Value2();
      if (arc.ilabel != 0) {
        if (eps_acwt > 0) {
          acwt += eps_acwt;
          eps_acwt = 0.0;
        }
        loglikes.push_back(acwt);
        prev_frame++;
      } else if (acwt == acwt){
        if (prev_frame > -1) {
          loglikes[prev_frame] += acwt;
        } else {
          eps_acwt += acwt;
        }
      }
      cur_state = arc.nextstate;
    }
  }
}

GetRandChar()

char kaldi::GetRandChar

(

)

Definition at line 28 of file text-utils-test.cc.

References Rand().

Referenced by TestSplitStringToVector().

                   {
  return static_cast<char>(32 + Rand() % 95);  // between ' ' and '~'
}

GetRandDelim()

char kaldi::GetRandDelim

(

)

Definition at line 33 of file text-utils-test.cc.

References Rand().

Referenced by TestSplitStringToVector().

                    {
  if (Rand() % 2 == 0)
    return static_cast<char>(33 + Rand() % 94);  // between '!' and '~';
  else
    return ws_delim[Rand() % 4];
}

GetScaledTransitionLogProb()

static BaseFloat kaldi::GetScaledTransitionLogProb ( const TransitionModel &  trans_model, int32  trans_id, BaseFloat  transition_scale, BaseFloat  self_loop_scale  )

static

Definition at line 1065 of file hmm-utils.cc.

References TransitionModel::GetNonSelfLoopLogProb(), TransitionModel::GetTransitionLogProb(), TransitionModel::GetTransitionLogProbIgnoringSelfLoops(), TransitionModel::IsSelfLoop(), and TransitionModel::TransitionIdToTransitionState().

Referenced by AddTransitionProbs().

                                                                       {
  if (transition_scale == self_loop_scale) {
    return trans_model.GetTransitionLogProb(trans_id) * transition_scale;
  } else {
    if (trans_model.IsSelfLoop(trans_id)) {
      return self_loop_scale * trans_model.GetTransitionLogProb(trans_id);
    } else {
      int32 trans_state = trans_model.TransitionIdToTransitionState(trans_id);
      return self_loop_scale * trans_model.GetNonSelfLoopLogProb(trans_state)
          + transition_scale * trans_model.GetTransitionLogProbIgnoringSelfLoops(trans_id);
      // This could be simplified to
      // (self_loop_scale - transition_scale) * trans_model.GetNonSelfLoopLogProb(trans_state)
      // + trans_model.GetTransitionLogProb(trans_id);
      // this simplifies if self_loop_scale == 0.0
    }
  }
}

GetSeenPhones()

void kaldi::GetSeenPhones	(	BuildTreeStatsType &	stats,
		int	P,
		std::vector< int32 > *	phones_out
	)

Definition at line 32 of file build-tree-two-level.cc.

References CopySetToVector(), rnnlm::i, rnnlm::j, and KALDI_ASSERT.

Referenced by main().

                                                                                   {
  // Get list of phones that we saw (in the central position P, although it
  // shouldn't matter what position).

  std::set<int32> phones_set;
  for (size_t i = 0 ; i < stats.size(); i++) {
    const EventType &evec = stats[i].first;
    for (size_t j = 0; j < evec.size(); j++) {
      if (evec[j].first == P) {  // "key" is position P
        KALDI_ASSERT(evec[j].second != 0);
        phones_set.insert(evec[j].second);  // insert "value" of this
        // phone.
      }
    }
    CopySetToVector(phones_set, phones_out);
  }
}

GetShortFileName()

static const char* kaldi::GetShortFileName ( const char *  path )

static

Definition at line 63 of file kaldi-error.cc.

Referenced by MessageLogger::MessageLogger().

                                                      {
  if (path == nullptr)
    return "";

  const char *prev = path, *last = path;
  while ((path = std::strpbrk(path, "\\/")) != nullptr) {
    ++path;
    prev = last;
    last = path;
  }
  return prev;
}

GetSingleStatsDerivative()

void kaldi::GetSingleStatsDerivative	(	double	ml_count,
		double	ml_x_stats,
		double	ml_x2_stats,
		double	disc_count,
		double	disc_x_stats,
		double	disc_x2_stats,
		double	model_mean,
		double	model_var,
		BaseFloat	min_variance,
		double *	ml_x_stats_deriv,
		double *	ml_x2_stats_deriv
	)

Definition at line 25 of file indirect-diff-diag-gmm.cc.

References KALDI_VLOG.

Referenced by GetStatsDerivative().

                                                         {
  
  double model_inv_var = 1.0/model_var,
      model_inv_var_sq = model_inv_var*model_inv_var,
      model_mean_sq = model_mean*model_mean;

  // First get derivative of discriminative objective function w.r.t. the
  // model mean and variance.
  // Below: eqs. 11 and 13 in 2005 ICASSP paper on fMPE.  Note: the factor of
  // kappa (in the fMPE case) is assumed to have been accounted for by
  // scaling the num and den accs at the command-line level.  We substituted
  // eq. 12 into 13 and rearranged to get the second expression.
  double diff_wrt_model_mean = (1.0/model_var) * (disc_x_stats - model_mean*disc_count),
      diff_wrt_model_var =
      0.5 * ((disc_x2_stats - 2*model_mean*disc_x_stats + disc_count*model_mean_sq)
             * model_inv_var_sq
             - disc_count*model_inv_var);

  double stats_mean = ml_x_stats / ml_count,
      stats_var = ml_x2_stats / ml_count - (ml_x_stats / ml_count)*(ml_x_stats / ml_count);

  // We assume the "rescaling" update will be as follows.  Apologies if this is
  // a bit confusing.  The idea is that if the mean and var from (stats versus
  // model) differ we assume that the model will be updated with
  // DoRescalingUpdate(), which takes two sets of ML accs (old and new).  The old ML
  // accs given to the update will be the current ml accumulators we have here in
  // this function, and the new ML accs will be affected by change in fMPE transform.
  // The update in DoRescalingUpdate() will preserve any current difference between
  // the ml stats and the model [represented as a shift in mean and factor in variance].
  // Concretely: the update in DoRescalingUpdate() will do:
  //
  // new_model_mean := old_model_mean + new_stats_mean - old_stats_mean   (eq. 1)
  // new_model_var := max(min_variance, old_model_var * new_stats_var / old_stats_var).  (eq. 2)
  //
  // We're differentiating back through this process to new_stats_mean.
  // If the model and the stats were actually the same (e.g. we had been doing ML updates),
  // then all this is equivalent to what was in the original fMPE paper.  It's just
  // extended to make sense outside of that scenario where you're doing ML.
  
  double diff_wrt_stats_mean = diff_wrt_model_mean; // This comes from eq. 1 above.
  double diff_wrt_stats_var;
  if (model_var <= min_variance*1.01) {
    diff_wrt_stats_var = 0.0; // model would be "pinned" at minimum variance.
    KALDI_VLOG(2) << "Variance derivative is zero (min variance)";
  } else {
    diff_wrt_stats_var = diff_wrt_model_var * model_var / stats_var; // note:
    // the factor "model_var / stats_var" comes from "old_model_var / old_stats_var" in eq. 2.
    // Also note: the {old_,new_} versions of variables are numerically the same here, at the
    // point where we're differentiating.
  }

  // The next equations don't appear in the paper but represent the backpropagation
  // of the derivative through the equations:
  // stats_mean := ml_x_stats / ml_count
  // stats_var := ml_x2_stats / ml_count - (ml_x_stats/ml_count)^2
  // [we use stats_mean = ml_x_stats/ml_count, here].
  *ml_x_stats_deriv = diff_wrt_stats_mean / ml_count - 2 * diff_wrt_stats_var * stats_mean / ml_count;
  *ml_x2_stats_deriv = diff_wrt_stats_var / ml_count;
}

GetSkipLayers()

std::vector<bool> kaldi::GetSkipLayers	(	const std::string &	skip_layers_str,
		const int32	first_layer_idx,
		const int32	last_layer_idx
	)

Definition at line 58 of file nnet-am-average.cc.

References KALDI_ERR, and SplitStringToIntegers().

Referenced by main().

                                                            {

  std::vector<bool> skip_layers(last_layer_idx, false);

  if (skip_layers_str.empty()) {
    return skip_layers;
  }

  std::vector<int> layer_indices;
  bool ret = SplitStringToIntegers(skip_layers_str, ":", true, &layer_indices);
  if (!ret) {
    KALDI_ERR << "Cannot parse the skip layers specifier. It should be"
              << "colon-separated list of integers";
  }

  int min_elem = std::numeric_limits<int>().max(),
      max_elem = std::numeric_limits<int>().min();

  std::vector<int>::iterator it;
  for ( it = layer_indices.begin(); it != layer_indices.end(); ++it ) {
    if ( *it < 0 )
      *it = last_layer_idx + *it;  // convert the negative indices to
                                       // correct indices -- -1 would be the
                                       // last one, -2 the one before the last
                                       // and so on.
    if (*it > max_elem)
      max_elem = *it;

    if (*it < min_elem)
      min_elem = *it;
  }

  if (max_elem >= last_layer_idx) {
    KALDI_ERR << "--skip-layers option has to be a colon-separated list"
              << "of indices which are supposed to be skipped.\n"
              << "Maximum expected index: " << last_layer_idx
              << " got: " << max_elem ;
  }
  if (min_elem < first_layer_idx) {
    KALDI_ERR << "--skip-layers option has to be a colon-separated list"
              << "of indices which are supposed to be skipped.\n"
              << "Minimum expected index: " << first_layer_idx
              << " got: " << min_elem ;
  }

  for ( it = layer_indices.begin(); it != layer_indices.end(); ++it ) {
    skip_layers[*it] = true;
  }
  return skip_layers;
}

GetSplitTargets()

void GetSplitTargets	(	const Vector< BaseFloat > &	state_occs,
		int32	target_components,
		BaseFloat	power,
		BaseFloat	min_count,
		std::vector< int32 > *	targets
	)

Get Gaussian-mixture or substate-mixture splitting targets, according to a power rule (e.g.

typically power = 0.2). Returns targets for number of mixture components (Gaussians, or sub-states), allocating the Gaussians or whatever according to a power of occupancy in order to acheive the total supplied "target". During splitting we ensure that each Gaussian [or sub-state] would get a count of at least "min-count", assuming counts were evenly distributed between Gaussians in a state. The vector "targets" will be resized to the appropriate dimension; its value at input is ignored.

Definition at line 116 of file model-common.cc.

References CountStats::CountStats(), VectorBase< Real >::Dim(), KALDI_WARN, CountStats::num_components, CountStats::occupancy, and CountStats::pdf_index.

Referenced by AmDiagGmm::MergeByCount(), LogisticRegression::MixUp(), SoftmaxComponent::MixUp(), AmDiagGmm::SplitByCount(), and AmSgmm2::SplitSubstates().

                                                {
  std::priority_queue<CountStats> split_queue;
  int32 num_pdfs = state_occs.Dim();
  
  for (int32 pdf_index = 0; pdf_index < num_pdfs; pdf_index++) {
    BaseFloat occ = pow(state_occs(pdf_index), power);
    // initialize with one Gaussian per PDF, to put a floor
    // of 1 on the #Gauss
    split_queue.push(CountStats(pdf_index, 1, occ));
  }
  
  for (int32 num_gauss = num_pdfs; num_gauss < target_components;) {
    CountStats state_to_split = split_queue.top();
    if (state_to_split.occupancy == 0) {
      KALDI_WARN << "Could not split up to " << target_components
                 << " due to min-count = " << min_count
                 << " (or no counts at all)\n";
      break;
    }
    split_queue.pop();
    BaseFloat orig_occ = state_occs(state_to_split.pdf_index);
    if ((state_to_split.num_components+1) * min_count >= orig_occ) {
      state_to_split.occupancy = 0; // min-count active -> disallow splitting
      // this state any more by setting occupancy = 0.
    } else {
      state_to_split.num_components++;
      num_gauss++;
    }
    split_queue.push(state_to_split);
  }
  targets->resize(num_pdfs);  
  while (!split_queue.empty()) {
    int32 pdf_index = split_queue.top().pdf_index;
    int32 pdf_tgt_comp = split_queue.top().num_components;
    (*targets)[pdf_index] = pdf_tgt_comp;
    split_queue.pop();
  }
}

GetStatsDerivative() [1/2]

void kaldi::GetStatsDerivative	(	const DiagGmm &	gmm,
		const AccumDiagGmm &	num_acc,
		const AccumDiagGmm &	den_acc,
		const AccumDiagGmm &	ml_acc,
		BaseFloat	min_variance,
		BaseFloat	min_gaussian_occupancy,
		AccumDiagGmm *	out_accs
	)

Definition at line 94 of file indirect-diff-diag-gmm.cc.

References AccumDiagGmm::AddStatsForComponent(), rnnlm::d, DiagGmm::Dim(), AccumDiagGmm::Dim(), AccumDiagGmm::Flags(), GetSingleStatsDerivative(), KALDI_ASSERT, KALDI_WARN, kGmmAll, kGmmMeans, kGmmVariances, AccumDiagGmm::mean_accumulator(), DiagGmmNormal::means_, DiagGmm::NumGauss(), AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy(), AccumDiagGmm::Resize(), AccumDiagGmm::variance_accumulator(), and DiagGmmNormal::vars_.

Referenced by GetStatsDerivative(), and main().

                                                {
  out_accs->Resize(gmm, kGmmAll);
  int32 num_gauss = gmm.NumGauss(), dim = gmm.Dim();
  KALDI_ASSERT(num_gauss == num_acc.NumGauss() && dim == num_acc.Dim());
  KALDI_ASSERT(num_gauss == den_acc.NumGauss()); // don't check den dim--
  // in the "compressed" form of stats (where num acc stores diff),
  // it could be zero.
  KALDI_ASSERT(num_gauss == ml_acc.NumGauss() && dim == ml_acc.Dim());

  KALDI_ASSERT((ml_acc.Flags() & (kGmmMeans|kGmmVariances)) ==
               (kGmmMeans|kGmmVariances));
  KALDI_ASSERT((num_acc.Flags() & (kGmmMeans|kGmmVariances)) ==
               (kGmmMeans|kGmmVariances));
  DiagGmmNormal gmm_normal(gmm);

  // if have_den_stats == false, we assume the num and den have been
  // "compressed" by putting the difference in mean and var stats in num.
  bool have_den_stats = ((den_acc.Flags() & (kGmmMeans|kGmmVariances)) != 0);

  for (int32 gauss = 0; gauss < num_gauss; gauss++) {
    Vector<double> x_stats_deriv(dim), x2_stats_deriv(dim);
    double num_count = num_acc.occupancy()(gauss),
        den_count = den_acc.occupancy()(gauss),
        ml_count = ml_acc.occupancy()(gauss);
    
    if (ml_count <= min_gaussian_occupancy) {
      // This Gaussian won't be updated since has small count
      KALDI_WARN << "Skipping Gaussian because very small ML count: (num,den,ml) = "
                 << num_count << ", " << den_count << ", " << ml_count;
    } else {
      double disc_count = num_count - den_count;
      for (int32 d = 0; d < dim; d++) {
        double disc_x_acc = num_acc.mean_accumulator()(gauss, d)
            - (have_den_stats ? den_acc.mean_accumulator()(gauss, d) : 0.0),
            disc_x2_acc = num_acc.variance_accumulator()(gauss, d)
            - (have_den_stats ? den_acc.variance_accumulator()(gauss, d) : 0.0),
            ml_x_acc = ml_acc.mean_accumulator()(gauss, d),
            ml_x2_acc = ml_acc.variance_accumulator()(gauss, d),
            model_mean = gmm_normal.means_(gauss, d),
            model_var = gmm_normal.vars_(gauss, d);

        double x_acc_deriv = 0.0, x2_acc_deriv = 0.0;
        GetSingleStatsDerivative(ml_count, ml_x_acc, ml_x2_acc,
                                 disc_count, disc_x_acc, disc_x2_acc,
                                 model_mean, model_var, min_variance,
                                 &x_acc_deriv, &x2_acc_deriv);

        x_stats_deriv(d) = x_acc_deriv;
        x2_stats_deriv(d) = x2_acc_deriv;
      }
      // set the stats to these quantities (we're adding, but the stats
      // are currently zero).
      out_accs->AddStatsForComponent(gauss, 0.0, x_stats_deriv, x2_stats_deriv);
    }
  }
}

GetStatsDerivative() [2/2]

void GetStatsDerivative	(	const AmDiagGmm &	gmm,
		const AccumAmDiagGmm &	num_accs,
		const AccumAmDiagGmm &	den_accs,
		const AccumAmDiagGmm &	ml_accs,
		BaseFloat	min_variance,
		BaseFloat	min_gaussian_occupancy,
		AccumAmDiagGmm *	out_accs
	)

Definition at line 157 of file indirect-diff-diag-gmm.cc.

References AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), GetStatsDerivative(), AccumAmDiagGmm::Init(), KALDI_ASSERT, kGmmAll, AccumAmDiagGmm::NumAccs(), and AmDiagGmm::NumPdfs().

                                                  {
  out_accs->Init(gmm, kGmmAll);
  int32 num_pdfs = gmm.NumPdfs();
  KALDI_ASSERT(num_accs.NumAccs() == num_pdfs);
  KALDI_ASSERT(den_accs.NumAccs() == num_pdfs);
  KALDI_ASSERT(ml_accs.NumAccs() == num_pdfs);
  for (int32 pdf = 0; pdf < num_pdfs; pdf++)
    GetStatsDerivative(gmm.GetPdf(pdf), num_accs.GetAcc(pdf), den_accs.GetAcc(pdf),
                       ml_accs.GetAcc(pdf), min_variance, min_gaussian_occupancy,
                       &(out_accs->GetAcc(pdf)));
  
}

GetTimeString()

std::string kaldi::GetTimeString	(	int32	t_beg,
		int32	t_end,
		BaseFloat	time_unit
	)

Definition at line 88 of file online2-tcp-nnet3-decode-faster.cc.

Referenced by main().

                                                                       {
  char buffer[100];
  double t_beg2 = t_beg * time_unit;
  double t_end2 = t_end * time_unit;
  snprintf(buffer, 100, "%.2f %.2f", t_beg2, t_end2);
  return std::string(buffer);
}

GetToLengthMap()

EventMap* kaldi::GetToLengthMap	(	const BuildTreeStatsType &	stats,
		int32	P,
		const std::vector< EventValueType > *	phones,
		int32	default_length
	)

Definition at line 760 of file build-tree-utils.cc.

References rnnlm::i, KALDI_ERR, kPdfClass, and SplitStatsByKey().

                                               {
  std::vector<BuildTreeStatsType> stats_by_phone;
  try {
    SplitStatsByKey(stats, P, &stats_by_phone);
  } catch(const KaldiFatalError &) {
    KALDI_ERR <<
        "You seem to have provided invalid stats [no central-phone key].";
  }
  std::map<EventValueType, EventAnswerType> phone_to_length;
  for (size_t p = 0; p < stats_by_phone.size(); p++) {
    if (! stats_by_phone[p].empty()) {
      std::vector<BuildTreeStatsType> stats_by_length;
      try {
        SplitStatsByKey(stats_by_phone[p], kPdfClass, &stats_by_length);
      } catch(const KaldiFatalError &) {
        KALDI_ERR <<
            "You seem to have provided invalid stats [no position key].";
      }
      size_t length = stats_by_length.size();
      for (size_t i = 0; i < length; i++) {
        if (stats_by_length[i].empty()) {
          KALDI_ERR << "There are no stats available for position " << i
                    << " of phone " << p;
        }
      }
      phone_to_length[p] = length;
    }
  }
  if (phones != NULL) {  // set default length for unseen phones.
    for (size_t i = 0; i < phones->size(); i++) {
      if (phone_to_length.count( (*phones)[i] ) == 0) {  // unseen.
        phone_to_length[(*phones)[i]] = default_length;
      }
    }
  }
  EventMap *ans = new TableEventMap(P, phone_to_length);
  return ans;
}

GetTotalPosterior()

static BaseFloat kaldi::GetTotalPosterior ( const std::vector< std::pair< int32, BaseFloat > > &  post_entry )

inlinestatic

Definition at line 429 of file posterior.cc.

Referenced by VectorToPosteriorEntry().

                                                             {
  BaseFloat tot = 0.0;
  std::vector<std::pair<int32, BaseFloat> >::const_iterator
      iter =  post_entry.begin(), end = post_entry.end();
  for (; iter != end; ++iter) {
    tot += iter->second;
  }
  return tot;
}

GetTreeStructure()

bool GetTreeStructure	(	const EventMap &	map,
		int32 *	num_leaves,
		std::vector< int32 > *	parents
	)

This function gets the tree structure of the EventMap "map" in a convenient form.

If "map" corresponds to a tree structure (not necessarily binary) with leaves uniquely numbered from 0 to num_leaves-1, then the function will return true, output "num_leaves", and set "parent" to a vector of size equal to the number of nodes in the tree (nonleaf and leaf), where each index corresponds to a node and the leaf indices correspond to the values returned by the EventMap from that leaf; for an index i, parent[i] equals the parent of that node in the tree structure, where parent[i] > i, except for the last (root) node where parent[i] == i. If the EventMap does not have this structure (e.g. if multiple different leaf nodes share the same number), then it will return false.

Definition at line 429 of file event-map.cc.

References GetTreeStructureInternal(), rnnlm::i, IsLeafNode(), KALDI_ASSERT, and EventMap::Map().

Referenced by TestEventMap().

                                                 {
  KALDI_ASSERT (num_leaves != NULL && parents != NULL);
  
  if (IsLeafNode(&map)) { // handle degenerate case where root is a leaf.
    int32 leaf;
    if (!map.Map(EventType(), &leaf)
        || leaf != 0) return false;
    *num_leaves = 1;
    parents->resize(1);
    (*parents)[0] = 0;
    return true;
  }

  
  // This vector gives the address of nonleaf nodes in the tree,
  // in a numbering where 0 is the root and children always come
  // after parents.
  std::vector<const EventMap*> nonleaf_nodes;

  // Map from each nonleaf node to its parent node
  // (or to itself for the root node).
  std::map<const EventMap*, const EventMap*> nonleaf_parents;

  // Map from leaf nodes to their parent nodes.
  std::vector<const EventMap*> leaf_parents;

  if (!GetTreeStructureInternal(map, &nonleaf_nodes,
                               &nonleaf_parents,
                                &leaf_parents)) return false;

  *num_leaves = leaf_parents.size();
  int32 num_nodes = leaf_parents.size() + nonleaf_nodes.size();
  
  std::map<const EventMap*, int32> nonleaf_indices;

  // number the nonleaf indices so they come after the leaf
  // indices and the root is last.
  for (size_t i = 0; i < nonleaf_nodes.size(); i++)
    nonleaf_indices[nonleaf_nodes[i]] = num_nodes - i - 1;

  parents->resize(num_nodes);
  for (size_t i = 0; i < leaf_parents.size(); i++) {
    KALDI_ASSERT(nonleaf_indices.count(leaf_parents[i]) != 0);
    (*parents)[i] = nonleaf_indices[leaf_parents[i]];
  }
  for (size_t i = 0; i < nonleaf_nodes.size(); i++) {
    KALDI_ASSERT(nonleaf_indices.count(nonleaf_nodes[i]) != 0);
    KALDI_ASSERT(nonleaf_parents.count(nonleaf_nodes[i]) != 0);
    KALDI_ASSERT(nonleaf_indices.count(nonleaf_parents[nonleaf_nodes[i]]) != 0);
    int32 index = nonleaf_indices[nonleaf_nodes[i]],
        parent_index = nonleaf_indices[nonleaf_parents[nonleaf_nodes[i]]];
    KALDI_ASSERT(index > 0 && parent_index >= index);
    (*parents)[index] = parent_index;
  }
  for (int32 i = 0; i < num_nodes; i++)
    KALDI_ASSERT ((*parents)[i] > i || (i+1==num_nodes && (*parents)[i] == i));
  return true;
}

GetTreeStructureInternal()

static bool kaldi::GetTreeStructureInternal ( const EventMap &  map, std::vector< const EventMap *> *  nonleaf_nodes, std::map< const EventMap *, const EventMap *> *  nonleaf_parents, std::vector< const EventMap *> *  leaf_parents  )

static

Definition at line 375 of file event-map.cc.

References EventMap::GetChildren(), rnnlm::i, IsLeafNode(), KALDI_ASSERT, KALDI_WARN, and EventMap::Map().

Referenced by GetTreeStructure().

                                              {

  std::vector<const EventMap*> queue; // parents to be processed.

  const EventMap *top_node = &map;
    
  queue.push_back(top_node);
  nonleaf_nodes->push_back(top_node);
  (*nonleaf_parents)[top_node] = top_node;
  
  while (!queue.empty()) {
    const EventMap *parent = queue.back();
    queue.pop_back();
    std::vector<EventMap*> children;
    parent->GetChildren(&children);
    KALDI_ASSERT(!children.empty());
    for (size_t i = 0; i < children.size(); i++) {
      EventMap *child = children[i];
      if (IsLeafNode(child)) {
        int32 leaf;
        if (!child->Map(EventType(), &leaf)
            || leaf < 0) return false;
        if (static_cast<int32>(leaf_parents->size()) <= leaf)
          leaf_parents->resize(leaf+1, NULL);
        if ((*leaf_parents)[leaf] != NULL) {
          KALDI_WARN << "Repeated leaf! Did you suppress leaf clustering when building the tree?";
          return false; // repeated leaf.
        }
        (*leaf_parents)[leaf] = parent;
      } else {
        nonleaf_nodes->push_back(child);
        (*nonleaf_parents)[child] = parent;
        queue.push_back(child);
      }
    }
  }

  for (size_t i = 0; i < leaf_parents->size(); i++) 
    if ((*leaf_parents)[i] == NULL) {
      KALDI_WARN << "non-consecutively numbered leaves";
      return false; 
    }
    // non-consecutively numbered leaves.
  
  KALDI_ASSERT(!leaf_parents->empty()); // or no leaves.
  
  return true;
}

GetUtterancePairs()

void kaldi::GetUtterancePairs	(	const std::string &	reco2file_and_channel_rxfilename,
		std::vector< std::vector< std::string > > *	utt_pairs
	)

Definition at line 34 of file compute-cmvn-stats-two-channel.cc.

References rnnlm::i, KALDI_ERR, KALDI_WARN, PrintableRxfilename(), SplitStringToVector(), and Input::Stream().

Referenced by main().

                                                                    {
  Input ki(reco2file_and_channel_rxfilename);
  std::string line;
  std::map<std::string, std::vector<std::string> > call_to_uttlist;
  while (std::getline(ki.Stream(), line)) {
    std::vector<std::string> split_line;
    SplitStringToVector(line, " \t\r", true, &split_line);
    if (split_line.size() != 3) {
      KALDI_ERR << "Expecting 3 fields per line of reco2file_and_channel file "
                << PrintableRxfilename(reco2file_and_channel_rxfilename)
                << ", got: " << line;
    }
    // lines like: sw02001-A sw02001 A
    std::string utt = split_line[0],
        call = split_line[1];
    call_to_uttlist[call].push_back(utt);
  }
  for (std::map<std::string, std::vector<std::string> >::const_iterator
         iter = call_to_uttlist.begin(); iter != call_to_uttlist.end(); ++iter) {
    const std::vector<std::string> &uttlist = iter->second;
    if (uttlist.size() == 2) {
      utt_pairs->push_back(uttlist);
    } else {
      KALDI_WARN << "Call " << iter->first << " has " << uttlist.size()
                 << " utterances, expected two; treating them singly.";
      for (size_t i = 0; i < uttlist.size(); i++) {
        std::vector<std::string> singleton_list;
        singleton_list.push_back(uttlist[i]);
        utt_pairs->push_back(singleton_list);
      }
    }
  }
}

GetWeights()

void GetWeights	(	const std::string &	weights_str,
		int32	num_inputs,
		std::vector< BaseFloat > *	weights
	)

Definition at line 30 of file nnet-am-average.cc.

References rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, and SplitStringToFloats().

Referenced by main().

                                               {
  KALDI_ASSERT(num_inputs >= 1);
  if (!weights_str.empty()) {
    SplitStringToFloats(weights_str, ":", true, weights);
    if (weights->size() != num_inputs) {
      KALDI_ERR << "--weights option must be a colon-separated list "
                << "with " << num_inputs << " elements, got: "
                << weights_str;
    }
  } else {
    for (int32 i = 0; i < num_inputs; i++)
      weights->push_back(1.0 / num_inputs);
  }
  // normalize the weights to sum to one.
  float weight_sum = 0.0;
  for (int32 i = 0; i < num_inputs; i++)
    weight_sum += (*weights)[i];
  for (int32 i = 0; i < num_inputs; i++)
    (*weights)[i] = (*weights)[i] / weight_sum;
  if (fabs(weight_sum - 1.0) > 0.01) {
    KALDI_WARN << "Normalizing weights to sum to one, sum was " << weight_sum;
  }
}

Givens()

void kaldi::Givens ( Real  a, Real  b, Real *  c, Real *  s  )

inline

Create Givens rotations, as in Golub and Van Loan 3rd ed., page 216.

Definition at line 221 of file qr.cc.

Referenced by QrStep().

                                                     {
  if (b == 0) {
    *c = 1;
    *s = 0;
  } else {
    if (std::abs(b) > std::abs(a)) {
      Real tau = -a / b;
      *s = 1 / std::sqrt(1 + tau*tau);
      *c = *s * tau;
    } else {
      Real tau = -b / a;
      *c = 1 / std::sqrt(1 + tau*tau);
      *s = *c * tau;
    }
  }
}

GmmFlagsToString()

std::string GmmFlagsToString

(

GmmFlagsType

flags

)

Convert GMM flags to string.

Definition at line 43 of file model-common.cc.

References kGmmMeans, kGmmTransitions, kGmmVariances, and kGmmWeights.

Referenced by AccumFullGmm::Read(), AccumDiagGmm::Read(), UnitTestEstimateMmieDiagGmm(), and UpdateEbwDiagGmm().

                                               {
  std::string ans;
  if (flags & kGmmMeans) ans += "m";
  if (flags & kGmmVariances) ans += "v";
  if (flags & kGmmWeights) ans += "w";
  if (flags & kGmmTransitions) ans += "t";
  return ans;
}

HandleOutput()

void kaldi::HandleOutput	(	bool	determinize,
		const fst::SymbolTable *	word_syms,
		nnet3::NnetBatchDecoder *	decoder,
		CompactLatticeWriter *	clat_writer,
		LatticeWriter *	lat_writer
	)

Definition at line 35 of file nnet3-latgen-faster-batch.cc.

References NnetBatchDecoder::GetOutput(), and TableWriter< Holder >::Write().

Referenced by main().

                                             {
  // Write out any lattices that are ready.
  std::string output_utterance_id, sentence;
  if (determinize) {
    CompactLattice clat;
    while (decoder->GetOutput(&output_utterance_id, &clat, &sentence)) {
      if (word_syms != NULL)
        std::cerr << output_utterance_id << ' ' << sentence << '\n';
      clat_writer->Write(output_utterance_id, clat);
    }
  } else {
    Lattice lat;
    while (decoder->GetOutput(&output_utterance_id, &lat, &sentence)) {
      if (word_syms != NULL)
        std::cerr << output_utterance_id << ' ' << sentence << '\n';
      lat_writer->Write(output_utterance_id, lat);
    }
  }
}

HouseBackward()

void kaldi::HouseBackward	(	MatrixIndexT	dim,
		const Real *	x,
		Real *	v,
		Real *	beta
	)

Definition at line 102 of file qr.cc.

References cblas_Xscal(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_ISFINITE, KALDI_ISINF, and KALDI_ISNAN.

Referenced by SpMatrix< float >::Tridiagonalize().

                                                                         {
  KALDI_ASSERT(dim > 0);
  // To avoid overflow, we first compute the max of x_ (or
  // one if that's zero, and we'll replace "x" by x/max(x_i)
  // below.  The householder vector is anyway invariant to
  // the magnitude of x.  We could actually avoid this extra loop
  // over x if we wanted to be a bit smarter, but anyway this
  // doesn't dominate the O(N) performance of the algorithm.
  Real s; // s is a scale on x.
  {
    Real max_x = std::numeric_limits<Real>::min();
    for (MatrixIndexT i = 0; i < dim; i++)
      max_x = std::max(max_x, (x[i] < 0 ? -x[i] : x[i]));
    s = 1.0 / max_x;
  }
  Real sigma = 0.0;
  v[dim-1] = 1.0;
  for (MatrixIndexT i = 0; i + 1  < dim; i++) {
    sigma += (x[i] * s) * (x[i] * s);
    v[i] = x[i] * s;
  }
  KALDI_ASSERT(KALDI_ISFINITE(sigma) &&
               "Tridiagonalizing matrix that is too large or has NaNs.");
  if (sigma == 0.0) *beta = 0.0;
  else {
    Real x1 = x[dim-1] * s, mu = std::sqrt(x1 * x1 + sigma);
    if (x1 <= 0) {
      v[dim-1] = x1 - mu;
    } else {
      v[dim-1] = -sigma / (x1 + mu);
      KALDI_ASSERT(KALDI_ISFINITE(v[dim-1]));
    }
    Real v1 = v[dim-1];
    Real v1sq = v1 * v1;
    *beta = 2 * v1sq / (sigma + v1sq);
    Real inv_v1 = 1.0 / v1;
    if (KALDI_ISINF(inv_v1)) {
      // can happen if v1 is denormal.
      KALDI_ASSERT(v1 == v1 && v1 != 0.0);
      for (MatrixIndexT i = 0; i < dim; i++) v[i] /= v1;
    } else {
      cblas_Xscal(dim, inv_v1, v, 1);
    }
    if (KALDI_ISNAN(inv_v1)) {
      KALDI_ERR << "NaN encountered in HouseBackward";
    }
  }
}

Hypot() [1/2]

double kaldi::Hypot ( double  x, double  y  )

inline

Definition at line 354 of file kaldi-math.h.

Referenced by EigenvalueDecomposition< Real >::Tql2().

{  return hypot(x, y); }

Hypot() [2/2]

float kaldi::Hypot ( float  x, float  y  )

inline

Definition at line 355 of file kaldi-math.h.

{  return hypotf(x, y); }

IncreaseTransformDimension()

void IncreaseTransformDimension	(	int32	new_dimension,
		Matrix< BaseFloat > *	mat
	)

Definition at line 26 of file extend-transform-dim.cc.

References VectorBase< Real >::CopyColFromMat(), rnnlm::d, rnnlm::i, KALDI_ERR, kCopyData, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and Matrix< Real >::Resize().

Referenced by main().

                                               {
  int32 d = mat->NumRows();
  if (new_dimension < d)
    KALDI_ERR << "--new-dimension argument invalid or not specified: "
              << new_dimension << " < " << d;
  if (mat->NumCols() == d) { // linear transform d->d
    mat->Resize(new_dimension, new_dimension, kCopyData);
    for (int32 i = d; i < new_dimension; i++)
      (*mat)(i, i) = 1.0; // set new dims to unit matrix.
  } else if (mat->NumCols() == d+1) { // affine transform d->d.
    Vector<BaseFloat> offset(mat->NumRows());
    offset.CopyColFromMat(*mat, d);
    mat->Resize(d, d, kCopyData); // remove offset from mat->
    mat->Resize(new_dimension, new_dimension+1, kCopyData); // extend with zeros.
    for (int32 i = d; i < new_dimension; i++)
      (*mat)(i, i) = 1.0; // set new dims to unit matrix.
    for (int32 i = 0; i < d; i++) // and set offset [last column]
      (*mat)(i, new_dimension) = offset(i);          
  } else {
    KALDI_ERR << "Input matrix has unexpected dimension " << d
              << " x " << mat->NumCols();
  }  
}

InitAmGmm()

void kaldi::InitAmGmm	(	const BuildTreeStatsType &	stats,
		const EventMap &	to_pdf_map,
		AmDiagGmm *	am_gmm,
		const TransitionModel &	trans_model,
		BaseFloat	var_floor
	)

InitAmGmm initializes the GMM with one Gaussian per state.

Definition at line 35 of file gmm-init-model.cc.

References AmDiagGmm::AddPdf(), count, GaussClusterable::count(), DeletePointers(), GetPhonesForPdfs(), rnnlm::i, KALDI_ASSERT, KALDI_WARN, EventMap::MaxResult(), SplitStatsByMap(), SumClusterable(), and SumStatsVec().

Referenced by main().

                                    {
  // Get stats split by tree-leaf ( == pdf):
  std::vector<BuildTreeStatsType> split_stats;
  SplitStatsByMap(stats, to_pdf_map, &split_stats);

  split_stats.resize(to_pdf_map.MaxResult() + 1); // ensure that
  // if the last leaf had no stats, this vector still has the right size.
  
  // Make sure each leaf has stats.
  for (size_t i = 0; i < split_stats.size(); i++) {
    if (split_stats[i].empty()) {
      std::vector<int32> bad_pdfs(1, i), bad_phones;
      GetPhonesForPdfs(trans_model, bad_pdfs, &bad_phones);
      std::ostringstream ss;
      for (int32 idx = 0; idx < bad_phones.size(); idx ++)
        ss << bad_phones[idx] << ' ';
      KALDI_WARN << "Tree has pdf-id " << i 
          << " with no stats; corresponding phone list: " << ss.str();
      /*
        This probably means you have phones that were unseen in training 
        and were not shared with other phones in the roots file. 
        You should modify your roots file as necessary to fix this.
        (i.e. share that phone with a similar but seen phone on one line 
        of the roots file). Be sure to regenerate roots.int from roots.txt, 
        if using s5 scripts. To work out the phone, search for 
        pdf-id  i  in the output of show-transitions (for this model). */
    }
  }
  std::vector<Clusterable*> summed_stats;
  SumStatsVec(split_stats, &summed_stats);
  Clusterable *avg_stats = SumClusterable(summed_stats);
  KALDI_ASSERT(avg_stats != NULL && "No stats available in gmm-init-model.");
  for (size_t i = 0; i < summed_stats.size(); i++) {
    GaussClusterable *c =
        static_cast<GaussClusterable*>(summed_stats[i] != NULL ? summed_stats[i] : avg_stats);
    DiagGmm gmm(*c, var_floor);
    am_gmm->AddPdf(gmm);
    BaseFloat count = c->count();
    if (count < 100) {
      std::vector<int32> bad_pdfs(1, i), bad_phones;
      GetPhonesForPdfs(trans_model, bad_pdfs, &bad_phones);
      std::ostringstream ss;
      for (int32 idx = 0; idx < bad_phones.size(); idx ++)
        ss << bad_phones[idx] << ' ';
      KALDI_WARN << "Very small count for state " << i << ": " 
                 << count << "; corresponding phone list: " << ss.str();
    }
  }
  DeletePointers(&summed_stats);
  delete avg_stats;
}

InitAmGmmFromOld()

void kaldi::InitAmGmmFromOld	(	const BuildTreeStatsType &	stats,
		const EventMap &	to_pdf_map,
		int32	N,
		int32	P,
		const std::string &	old_tree_rxfilename,
		const std::string &	old_model_rxfilename,
		BaseFloat	var_floor,
		AmDiagGmm *	am_gmm
	)

InitAmGmmFromOld initializes the GMM based on a previously trained model and tree, which must require no more phonetic context than the current tree.

It does this by finding the closest PDF in the old model, to any given PDF in the new model. Here, "closest" is defined as: has the largest count in common from the tree stats.

Definition at line 116 of file gmm-init-model.cc.

References AmDiagGmm::AddPdf(), ContextDependency::CentralPosition(), ContextDependency::ContextWidth(), ConvertStats(), AmDiagGmm::GetPdf(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, EventMap::Map(), EventMap::MaxResult(), AmDiagGmm::NumPdfs(), AmDiagGmm::Read(), ContextDependency::Read(), TransitionModel::Read(), SplitStatsByMap(), Input::Stream(), SumStats(), and ContextDependency::ToPdfMap().

Referenced by main().

                                         {

  AmDiagGmm old_am_gmm;
  ContextDependency old_tree;
  {  // Read old_gm_gmm
    bool binary_in;
    TransitionModel old_trans_model;
    Input ki(old_model_rxfilename, &binary_in);
    old_trans_model.Read(ki.Stream(), binary_in);
    old_am_gmm.Read(ki.Stream(), binary_in);
  }
  {  // Read tree.
    bool binary_in;
    Input ki(old_tree_rxfilename, &binary_in);
    old_tree.Read(ki.Stream(), binary_in);
  }


  // Get stats split by (new) tree-leaf ( == pdf):
  std::vector<BuildTreeStatsType> split_stats;
  SplitStatsByMap(stats, to_pdf_map, &split_stats);
  // Make sure each leaf has stats.
  for (size_t i = 0; i < split_stats.size(); i++) {
    if (split_stats[i].empty()) {
      KALDI_WARN << "Leaf " << i << " of new tree has no stats.";
    }
  }
  if (static_cast<int32>(split_stats.size()) != to_pdf_map.MaxResult() + 1) {
    KALDI_ASSERT(static_cast<int32>(split_stats.size()) <
                 to_pdf_map.MaxResult() + 1);
    KALDI_WARN << "Tree may have final leaf with no stats.";
    split_stats.resize(to_pdf_map.MaxResult() + 1);
    // avoid indexing errors later.
  }

  int32 oldN = old_tree.ContextWidth(), oldP = old_tree.CentralPosition();

  // avg_stats will be used for leaves that have no stats.
  Clusterable *avg_stats = SumStats(stats);
  GaussClusterable *avg_stats_gc = dynamic_cast<GaussClusterable*>(avg_stats);
  KALDI_ASSERT(avg_stats_gc != NULL && "Empty stats input.");
  DiagGmm avg_gmm(*avg_stats_gc, var_floor);
  delete avg_stats;
  avg_stats = NULL;
  avg_stats_gc = NULL;
  
  const EventMap &old_map = old_tree.ToPdfMap();

  KALDI_ASSERT(am_gmm->NumPdfs() == 0);
  int32 num_pdfs = static_cast<int32>(split_stats.size());
  for (int32 pdf = 0; pdf < num_pdfs; pdf++) {
    BuildTreeStatsType &my_stats = split_stats[pdf];
    // The next statement converts the stats to a possibly narrower older
    // context-width (e.g. triphone -> monophone).
    // note: don't get confused by the "old" and "new" in the parameters
    // to ConvertStats.  The next line is correct.
    bool ret = ConvertStats(N, P, oldN, oldP, &my_stats);
    if (!ret)
      KALDI_ERR << "InitAmGmmFromOld: old system has wider context "
          "so cannot convert stats.";
    // oldpdf_to_count works out a map from old pdf-id to count (for stats
    // that align to this "new" pdf... we'll use it to work out the old pdf-id
    // that's "closest" in stats overlap to this new pdf ("pdf").
    std::map<int32, BaseFloat> oldpdf_to_count;
    for (size_t i = 0; i < my_stats.size(); i++) {
      EventType evec = my_stats[i].first;
      EventAnswerType ans;
      bool ret = old_map.Map(evec, &ans);
      if (!ret) { KALDI_ERR << "Could not map context using old tree."; }
      KALDI_ASSERT(my_stats[i].second != NULL);
      BaseFloat stats_count = my_stats[i].second->Normalizer();
      if (oldpdf_to_count.count(ans) == 0) oldpdf_to_count[ans] = stats_count;
      else oldpdf_to_count[ans] += stats_count;
    }
    BaseFloat max_count = 0; int32 max_old_pdf = -1;
    for (std::map<int32, BaseFloat>::const_iterator iter = oldpdf_to_count.begin();
        iter != oldpdf_to_count.end();
        ++iter) {
      if (iter->second > max_count) {
        max_count = iter->second;
        max_old_pdf = iter->first;
      }
    }
    if (max_count == 0) {  // no overlap - probably a leaf with no stats at all.
      KALDI_WARN << "Leaf " << pdf << " of new tree being initialized with "
                 << "globally averaged stats.";
      am_gmm->AddPdf(avg_gmm);
    } else {
      am_gmm->AddPdf(old_am_gmm.GetPdf(max_old_pdf));  // Here is where we copy the relevant old PDF.
    }
  }
}

InitCmvnStats()

void InitCmvnStats	(	int32	dim,
		Matrix< double > *	stats
	)

This function initializes the matrix to dimension 2 by (dim+1); 1st "dim" elements of 1st row are mean stats, 1st "dim" elements of 2nd row are var stats, last element of 1st row is count, last element of 2nd row is zero.

Definition at line 25 of file cmvn.cc.

References KALDI_ASSERT, and Matrix< Real >::Resize().

Referenced by main().

                                                     {
  KALDI_ASSERT(dim > 0);
  stats->Resize(2, dim+1);
}

InitFmllr()

void kaldi::InitFmllr ( int32  dim, Matrix< BaseFloat > *  out_fmllr  )

inline

Definition at line 161 of file fmllr-diag-gmm.h.

References ComputeFmllrDiagGmm(), Matrix< Real >::Resize(), and MatrixBase< Real >::SetUnit().

                                                    {
  out_fmllr->Resize(dim, dim+1);
  out_fmllr->SetUnit();  // sets diagonal elements to one.
}

InitGmmFromRandomFrames()

void kaldi::InitGmmFromRandomFrames	(	const Matrix< BaseFloat > &	feats,
		DiagGmm *	gmm
	)

Definition at line 32 of file gmm-global-init-from-feats.cc.

References VectorBase< Real >::AddVec2(), DiagGmm::ComputeGconsts(), DiagGmm::CopyFromNormal(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, VectorBase< Real >::Max(), DiagGmmNormal::means_, MatrixBase< Real >::NumCols(), DiagGmm::NumGauss(), MatrixBase< Real >::NumRows(), RandInt(), MatrixBase< Real >::Row(), DiagGmmNormal::vars_, and DiagGmmNormal::weights_.

Referenced by main().

                                                                           {
  int32 num_gauss = gmm->NumGauss(), num_frames = feats.NumRows(),
      dim = feats.NumCols();
  KALDI_ASSERT(num_frames >= 10 * num_gauss && "Too few frames to train on");
  Vector<double> mean(dim), var(dim);
  for (int32 i = 0; i < num_frames; i++) {
    mean.AddVec(1.0 / num_frames, feats.Row(i));
    var.AddVec2(1.0 / num_frames, feats.Row(i));
  }
  var.AddVec2(-1.0, mean);
  if (var.Max() <= 0.0)
    KALDI_ERR << "Features do not have positive variance " << var;
  
  DiagGmmNormal gmm_normal(*gmm);

  std::set<int32> used_frames;
  for (int32 g = 0; g < num_gauss; g++) {
    int32 random_frame = RandInt(0, num_frames - 1);
    while (used_frames.count(random_frame) != 0)
      random_frame = RandInt(0, num_frames - 1);
    used_frames.insert(random_frame);
    gmm_normal.weights_(g) = 1.0 / num_gauss;
    gmm_normal.means_.Row(g).CopyFromVec(feats.Row(random_frame));
    gmm_normal.vars_.Row(g).CopyFromVec(var);
  }
  gmm->CopyFromNormal(gmm_normal);
  gmm->ComputeGconsts();
}

InitKaldiInputStream()

bool InitKaldiInputStream ( std::istream &  is, bool *  binary  )

inline

Initialize an opened stream for reading by detecting the binary header and.

InitKaldiInputStream initializes an opened stream for reading by detecting the binary header and setting the "binary" value appropriately; It will typically not be called by users directly.

Definition at line 306 of file io-funcs-inl.h.

Referenced by main(), Input::OpenInternal(), PosteriorHolder::Read(), KaldiObjectHolder< KaldiType >::Read(), GaussPostHolder::Read(), BasicHolder< BasicType >::Read(), BasicVectorHolder< BasicType >::Read(), BasicVectorVectorHolder< BasicType >::Read(), BasicPairVectorHolder< BasicType >::Read(), ReadBasicType(), UnitTestCompressedMatrix(), UnitTestGeneralMatrix(), UnitTestIo(), and UnitTestIoCross().

                                                               {
  // Sets the 'binary' variable.
  // Throws exception in the very unusual situation that stream
  // starts with '\0' but not then 'B'.

  if (is.peek() == '\0') {  // seems to be binary
    is.get();
    if (is.peek() != 'B') {
      return false;
    }
    is.get();
    *binary = true;
    return true;
  } else {
    *binary = false;
    return true;
  }
}

InitKaldiOutputStream()

void InitKaldiOutputStream ( std::ostream &  os, bool  binary  )

inline

InitKaldiOutputStream initializes an opened stream for writing by writing an optional binary header and modifying the floating-point precision; it will typically not be called by users directly.

Definition at line 291 of file io-funcs-inl.h.

Referenced by Output::Open(), ReadBasicType(), UnitTestCompressedMatrix(), UnitTestGeneralMatrix(), UnitTestIo(), UnitTestIoCross(), KaldiObjectHolder< KaldiType >::Write(), PosteriorHolder::Write(), GaussPostHolder::Write(), BasicHolder< BasicType >::Write(), BasicVectorHolder< BasicType >::Write(), BasicVectorVectorHolder< BasicType >::Write(), and BasicPairVectorHolder< BasicType >::Write().

                                                               {
  // This does not throw exceptions (does not check for errors).
  if (binary) {
    os.put('\0');
    os.put('B');
  }
  // Note, in non-binary mode we may at some point want to mess with
  // the precision a bit.
  // 7 is a bit more than the precision of float..
  if (os.precision() < 7)
    os.precision(7);
}

InitRand() [1/4]

static void kaldi::InitRand ( SpMatrix< Real > *  M )

static

Definition at line 42 of file cu-test.cc.

References SpMatrix< Real >::Cond(), rnnlm::i, rnnlm::j, PackedMatrix< Real >::NumRows(), and RandGauss().

                                        {
  do {
    for (MatrixIndexT i = 0; i < M->NumRows(); i++) {
      for (MatrixIndexT j = 0; j <= i; j++ ) {
    (*M)(i,j) = RandGauss();
      }
    }
  } while (M->NumRows() != 0 && M->Cond() > 100);
}

InitRand() [2/4]

static void kaldi::InitRand ( VectorBase< Real > *  v )

static

Definition at line 45 of file cu-matrix-test.cc.

References VectorBase< Real >::Dim(), rnnlm::i, and RandGauss().

Referenced by Questions::Questions(), UnitTestCuMatrixAddVecToCols(), UnitTestCuMatrixAddVecToRows(), UnitTestCuMatrixDivRowsVec(), UnitTestCuMatrixInvertElements(), UnitTestCuMatrixMulColsVec(), UnitTestCuMatrixMulRowsVec(), UnitTestCuVectorAddColSumMat(), UnitTestCuVectorAddColSumMatLarge(), UnitTestCuVectorAddRowSumMat(), UnitTestCuVectorAddRowSumMatLarge(), UnitTestCuVectorAddTpVec(), UnitTestCuVectorAddVec(), UnitTestCuVectorInvertElements(), UnitTestCuVectorMulTp(), UnitTestMatrixRandomizer(), and UnitTestVectorRandomizer().

                                          {
  for (MatrixIndexT i = 0; i < v->Dim(); i++)
    (*v)(i) = RandGauss();
}

InitRand() [3/4]

static void kaldi::InitRand ( MatrixBase< Real > *  M )

static

Definition at line 53 of file cu-matrix-test.cc.

References MatrixBase< Real >::Cond(), rnnlm::i, rnnlm::j, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and RandGauss().

                                          {
  do {
    for (MatrixIndexT i = 0;i < M->NumRows();i++)
      for (MatrixIndexT j = 0;j < M->NumCols();j++)
        (*M)(i, j) = RandGauss();
  } while (M->NumRows() != 0 && M->Cond() > 100);
}

InitRand() [4/4]

static void kaldi::InitRand ( VectorBase< Real > *  v )

static

Definition at line 53 of file cu-test.cc.

References VectorBase< Real >::Dim(), rnnlm::i, and RandGauss().

                                          {
  for (MatrixIndexT i = 0; i < v->Dim(); i++) {
    (*v)(i) = RandGauss();
  }
}

InitRandNonsingular() [1/2]

static void kaldi::InitRandNonsingular ( MatrixBase< Real > *  M )

static

Definition at line 56 of file matrix-lib-test.cc.

References MatrixBase< Real >::Cond(), rnnlm::i, rnnlm::j, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and RandGauss().

Referenced by CholeskyUnitTestTr(), UnitTestAxpy(), UnitTestDeterminant(), UnitTestDeterminantSign(), UnitTestEig(), UnitTestEigSp(), UnitTestFloorChol(), UnitTestInverse(), UnitTestNonsymmetricPower(), UnitTestRow(), UnitTestSimpleForMat(), UnitTestTridiagonalize(), and UnitTestTridiagonalizeAndQr().

                                                                             {
start:
  for (MatrixIndexT i = 0;i < M->NumRows();i++)
    for (MatrixIndexT j = 0;j < M->NumCols();j++)
      (*M)(i, j) = RandGauss();
  if (M->NumRows() != 0 && M->Cond() > 100) {
    printf("Condition number of random matrix large %f, trying again (this is normal)\n",
           (float) M->Cond());
    goto start;
  }
}

InitRandNonsingular() [2/2]

static void kaldi::InitRandNonsingular ( SpMatrix< Real > *  M )

static

Definition at line 69 of file matrix-lib-test.cc.

References SpMatrix< Real >::Cond(), rnnlm::i, rnnlm::j, PackedMatrix< Real >::NumRows(), and RandGauss().

                                                                           {
start:
  for (MatrixIndexT i = 0;i < M->NumRows();i++)
    for (MatrixIndexT j = 0;j<=i;j++)
      (*M)(i, j) = RandGauss();
  if (M->NumRows() != 0 && M->Cond() > 100)
    goto start;
}

InitRandomGmm()

void InitRandomGmm

(

DiagGmm *

gmm_in

)

Definition at line 27 of file diag-gmm-test.cc.

References DiagGmm::ComputeGconsts(), Exp(), rnnlm::i, rnnlm::j, DiagGmm::Perturb(), Rand(), RandGauss(), RandUniform(), DiagGmm::Resize(), VectorBase< Real >::Scale(), DiagGmm::SetInvVarsAndMeans(), DiagGmm::SetWeights(), and VectorBase< Real >::Sum().

Referenced by UnitTestDiagGmmGenerate(), UnitTestFmllrDiagGmm(), UnitTestFmllrDiagGmmDiagonal(), UnitTestFmllrDiagGmmOffset(), and UnitTestFmllrRaw().

                                    {
  int32 num_gauss = 10 + Rand() % 5;
  int32 dim = 10 + Rand() % 10;
  DiagGmm &gmm(*gmm_in);
  gmm.Resize(num_gauss, dim);
  Matrix<BaseFloat> inv_vars(num_gauss, dim),
      means(num_gauss, dim);
  Vector<BaseFloat> weights(num_gauss);
  for (int32 i = 0; i < num_gauss; i++) {
    for (int32 j = 0; j < dim; j++) {
      inv_vars(i, j) = Exp(RandGauss() * (1.0 / (1 + j)));
      means(i, j) = RandGauss() * (1.0 / (1 + j));
    }
    weights(i) = Exp(RandGauss());
  }
  weights.Scale(1.0 / weights.Sum());
  gmm.SetWeights(weights);
  gmm.SetInvVarsAndMeans(inv_vars, means);
  gmm.Perturb(0.5 * RandUniform());
  gmm.ComputeGconsts();  // this is unnecessary; computed in Perturb
}

IsLeafNode()

static bool kaldi::IsLeafNode ( const EventMap *  e )

static

Definition at line 354 of file event-map.cc.

References EventMap::GetChildren().

Referenced by GetTreeStructure(), and GetTreeStructureInternal().

                                          {
  std::vector<EventMap*> children;
  e->GetChildren(&children);
  return children.empty();
}

IsLine()

bool IsLine

(

const std::string &

line

)

Returns true if "line" is free of
characters and unprintable characters, and does not contain leading or trailing whitespace.

Definition at line 154 of file text-utils.cc.

Referenced by ConvertStringToInteger(), and TestIsLine().

                                   {
  if (line.find('\n') != std::string::npos) return false;
  if (line.empty()) return true;
  if (isspace(*(line.begin()))) return false;
  if (isspace(*(line.rbegin()))) return false;
  std::string::const_iterator iter = line.begin(), end = line.end();
  for (; iter != end; iter++)
    if (!isprint(*iter)) return false;
  return true;
}

IsmoothStatsAmDiagGmm()

void IsmoothStatsAmDiagGmm	(	const AccumAmDiagGmm &	src_stats,
		double	tau,
		AccumAmDiagGmm *	dst_stats
	)

Smooth "dst_stats" with "src_stats".

They don't have to be different.

Definition at line 358 of file ebw-diag-gmm.cc.

References AccumAmDiagGmm::GetAcc(), IsmoothStatsDiagGmm(), KALDI_ASSERT, and AccumAmDiagGmm::NumAccs().

Referenced by main(), and EbwWeightOptions::Register().

                                                      {
  int num_pdfs = src_stats.NumAccs();
  KALDI_ASSERT(num_pdfs == dst_stats->NumAccs());
  for (int32 pdf = 0; pdf < num_pdfs; pdf++)
    IsmoothStatsDiagGmm(src_stats.GetAcc(pdf), tau, &(dst_stats->GetAcc(pdf)));
}

IsmoothStatsAmDiagGmmFromModel()

void IsmoothStatsAmDiagGmmFromModel	(	const AmDiagGmm &	src_model,
		double	tau,
		AccumAmDiagGmm *	dst_stats
	)

This version of the I-smoothing function takes a model as input.

Definition at line 367 of file ebw-diag-gmm.cc.

References DiagGmmToStats(), AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), IsmoothStatsDiagGmm(), KALDI_ASSERT, kGmmAll, AccumAmDiagGmm::NumAccs(), and AmDiagGmm::NumPdfs().

Referenced by main(), and EbwWeightOptions::Register().

                                                               {
  int num_pdfs = src_model.NumPdfs();
  KALDI_ASSERT(num_pdfs == dst_stats->NumAccs());
  for (int32 pdf = 0; pdf < num_pdfs; pdf++) {
    AccumDiagGmm tmp_stats;
    double occ = 1.0; // its value doesn't matter.
    DiagGmmToStats(src_model.GetPdf(pdf), kGmmAll, occ, &tmp_stats);
    IsmoothStatsDiagGmm(tmp_stats, tau, &(dst_stats->GetAcc(pdf)));
  }
}

IsmoothStatsDiagGmm()

void IsmoothStatsDiagGmm	(	const AccumDiagGmm &	src_stats,
		double	tau,
		AccumDiagGmm *	dst_stats
	)

I-Smooth the stats. src_stats and dst_stats do not have to be different.

Definition at line 318 of file ebw-diag-gmm.cc.

References AccumDiagGmm::AddStatsForComponent(), VectorBase< Real >::CopyFromVec(), AccumDiagGmm::Dim(), AccumDiagGmm::Flags(), KALDI_ASSERT, kGmmMeans, kGmmVariances, AccumDiagGmm::mean_accumulator(), AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy(), VectorBase< Real >::Scale(), and AccumDiagGmm::variance_accumulator().

Referenced by IsmoothStatsAmDiagGmm(), IsmoothStatsAmDiagGmmFromModel(), EbwWeightOptions::Register(), and UnitTestEstimateMmieDiagGmm().

                                                  {
  KALDI_ASSERT(src_stats.NumGauss() == dst_stats->NumGauss());
  int32 dim = src_stats.Dim(), num_gauss = src_stats.NumGauss();
  for (int32 g = 0; g < num_gauss; g++) {
    double occ = src_stats.occupancy()(g);
    if (occ != 0.0) { // can only do this for nonzero occupancies...
      Vector<double> x_stats(dim), x2_stats(dim);
      if (dst_stats->Flags() & kGmmMeans)
        x_stats.CopyFromVec(src_stats.mean_accumulator().Row(g));
      if (dst_stats->Flags() & kGmmVariances)
        x2_stats.CopyFromVec(src_stats.variance_accumulator().Row(g));
      x_stats.Scale(tau / occ);
      x2_stats.Scale(tau / occ);
      dst_stats->AddStatsForComponent(g, tau, x_stats, x2_stats);
    }
  }
}

IsPlausibleWord() [1/2]

static bool kaldi::IsPlausibleWord ( const WordBoundaryInfo &  info, const TransitionModel &  tmodel, const std::vector< int32 > &  transition_ids  )

static

Definition at line 543 of file word-align-lattice.cc.

References rnnlm::i, TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), WordBoundaryInfo::kWordBeginAndEndPhone, WordBoundaryInfo::kWordBeginPhone, WordBoundaryInfo::kWordEndPhone, WordBoundaryInfo::reorder, TransitionModel::TransitionIdToPhone(), and WordBoundaryInfo::TypeOfPhone().

                                                                    {
  if (transition_ids.empty()) return false;
  int32 first_phone = tmodel.TransitionIdToPhone(transition_ids.front()),
      last_phone = tmodel.TransitionIdToPhone(transition_ids.back());
  if ( (info.TypeOfPhone(first_phone) == WordBoundaryInfo::kWordBeginAndEndPhone
        && first_phone == last_phone)
       ||
       (info.TypeOfPhone(first_phone) == WordBoundaryInfo::kWordBeginPhone &&
        info.TypeOfPhone(last_phone) == WordBoundaryInfo::kWordEndPhone) ) {
    if (! info.reorder) {
      return (tmodel.IsFinal(transition_ids.back()));
    } else {
      int32 i = transition_ids.size() - 1;
      while (i > 0 && tmodel.IsSelfLoop(transition_ids[i])) i--;
      return tmodel.IsFinal(transition_ids[i]);
    }
  } else return false;
}

IsPlausibleWord() [2/2]

static bool kaldi::IsPlausibleWord ( const WordAlignLatticeLexiconInfo &  lexicon_info, const TransitionModel &  tmodel, int32  word_id, const std::vector< int32 > &  transition_ids  )

static

Definition at line 745 of file word-align-lattice-lexicon.cc.

References rnnlm::i, WordAlignLatticeLexiconInfo::IsValidEntry(), KALDI_ASSERT, KALDI_WARN, SplitToPhones(), and TransitionModel::TransitionIdToPhone().

Referenced by LatticeWordAligner::ComputationState::OutputArcForce(), and TestWordAlignedLattice().

                                                                    {

  std::vector<std::vector<int32> > split_alignment; // Split into phones.
  if (!SplitToPhones(tmodel, transition_ids, &split_alignment)) {
    KALDI_WARN << "Could not split word into phones correctly (forced-out?)";
  }
  std::vector<int32> phones(split_alignment.size());
  for (size_t i = 0; i < split_alignment.size(); i++) {
    KALDI_ASSERT(!split_alignment[i].empty());
    phones[i] = tmodel.TransitionIdToPhone(split_alignment[i][0]);
  }
  std::vector<int32> lexicon_entry;
  lexicon_entry.push_back(word_id);
  lexicon_entry.insert(lexicon_entry.end(), phones.begin(), phones.end());

  if (!lexicon_info.IsValidEntry(lexicon_entry)) {
    std::ostringstream ostr;
    for (size_t i = 0; i < lexicon_entry.size(); i++)
      ostr << lexicon_entry[i] << ' ';
    KALDI_WARN << "Invalid arc in aligned lattice (code error?) lexicon-entry is " << ostr.str();
    return false;
  } else {
    return true;
  }
}

IsReordered()

static bool kaldi::IsReordered ( const TransitionModel &  trans_model, const std::vector< int32 > &  alignment  )

static

Definition at line 625 of file hmm-utils.cc.

References rnnlm::i, TransitionModel::IsSelfLoop(), KALDI_ASSERT, and TransitionModel::TransitionIdToTransitionState().

Referenced by ConvertAlignmentInternal(), and SplitToPhones().

                                                           {
  for (size_t i = 0; i + 1 < alignment.size(); i++) {
    int32 tstate1 = trans_model.TransitionIdToTransitionState(alignment[i]),
        tstate2 = trans_model.TransitionIdToTransitionState(alignment[i+1]);
    if (tstate1 != tstate2) {
      bool is_loop_1 = trans_model.IsSelfLoop(alignment[i]),
          is_loop_2 = trans_model.IsSelfLoop(alignment[i+1]);
      KALDI_ASSERT(!(is_loop_1 && is_loop_2));  // Invalid.
      if (is_loop_1) return true;  // Reordered. self-loop is last.
      if (is_loop_2) return false;  // Not reordered.  self-loop is first.
    }
  }

  // Just one trans-state in whole sequence.
  if (alignment.empty()) return false;
  else {
    bool is_loop_front = trans_model.IsSelfLoop(alignment.front()),
        is_loop_back = trans_model.IsSelfLoop(alignment.back());
    if (is_loop_front) return false;  // Not reordered.  Self-loop is first.
    if (is_loop_back) return true;  // Reordered.  Self-loop is last.
    return false;  // We really don't know in this case but calling code should
    // not care.
  }
}

IsSorted()

bool kaldi::IsSorted ( const std::vector< T > &  vec )

inline

Returns true if the vector is sorted.

Definition at line 47 of file stl-utils.h.

Referenced by QuestionsForKey::Check(), DiscriminativeSupervisionSplitter::LatticeInfo::Check(), fst::CheckPhones(), PldaStats::Sort(), SplitEventMap::SplitEventMap(), TestIsSorted(), TestMergePairVectorSumming(), and Uniq().

                                              {
  typename std::vector<T>::const_iterator iter = vec.begin(), end = vec.end();
  if (iter == end) return true;
  while (1) {
    typename std::vector<T>::const_iterator next_iter = iter;
    ++next_iter;
    if (next_iter == end) return true;  // end of loop and nothing out of order
    if (*next_iter < *iter) return false;
    iter = next_iter;
  }
}

IsSortedAndUniq()

bool kaldi::IsSortedAndUniq ( const std::vector< T > &  vec )

inline

Returns true if the vector is sorted and contains each element only once.

Definition at line 63 of file stl-utils.h.

Referenced by AccumulateTreeStatsInfo::AccumulateTreeStatsInfo(), AddTransitionProbs(), AutomaticallyObtainQuestions(), RegressionTree::BuildTree(), BuildTree(), BuildTreeTwoLevel(), ConvolutionModel::Check(), ComputationGraphBuilder::Check(), Compiler::CompileBackwardFromSubmatLocations(), ExampleMergingConfig::ComputeDerived(), kaldi::nnet3::ComputeMatrixAccesses(), kaldi::nnet3::ComputeVariableAccesses(), ComputationRenumberer::CreateRenumbering(), FeatureTransformEstimateMulti::Estimate(), FilterStatsByKey(), ComputationLoopedOptimizer::FindActiveMatrices(), GenRandContextDependency(), GenRandContextDependencyLarge(), GenRandTopology(), GetDefaultTopology(), GetFullBiphoneStubMap(), ContextDependency::GetPdfInfo(), GetPdfsForPhones(), GetPhonesForPdfs(), kaldi::nnet3::time_height_convolution::GetRandomConvolutionIndexes(), GetStubMap(), SpliceComponent::Init(), TimeHeightConvolutionComponent::InitFromConfig(), KMeansClusterPhones(), LatticeActivePhones(), LatticeBoost(), main(), kaldi::nnet3::time_height_convolution::MakeComputation(), ObtainSetsOfPhones(), HmmTopology::Read(), ReadRootsFile(), ReadSharedPhonesList(), kaldi::nnet3::time_height_convolution::RegularizeTList(), DiagGmm::RemoveComponents(), FullGmm::RemoveComponents(), TestIsSortedAndUniq(), TrailingSilenceLength(), and TrainingGraphCompiler::TrainingGraphCompiler().

                                                     {
  typename std::vector<T>::const_iterator iter = vec.begin(), end = vec.end();
  if (iter == end) return true;
  while (1) {
    typename std::vector<T>::const_iterator next_iter = iter;
    ++next_iter;
    if (next_iter == end) return true;  // end of loop and nothing out of order
    if (*next_iter <= *iter) return false;
    iter = next_iter;
  }
}

IsToken()

bool IsToken

(

const std::string &

token

)

Returns true if "token" is nonempty, and all characters are printable and whitespace-free.

Definition at line 105 of file text-utils.cc.

References rnnlm::i.

Referenced by ConvertStringToInteger(), RandomAccessTableReader< kaldi::TokenHolder >::HasKey(), RandomAccessTableReaderScriptImpl< Holder >::HasKeyInternal(), IsNotToken(), Nnet::ProcessComponentConfigLine(), SplitArgOnEquals(), TestIsToken(), TokenHolder::Write(), TokenVectorHolder::Write(), TableWriterArchiveImpl< Holder >::Write(), TableWriterScriptImpl< Holder >::Write(), TableWriterBothImpl< Holder >::Write(), and WriteScriptFile().

                                     {
  size_t l = token.length();
  if (l == 0) return false;
  for (size_t i = 0; i < l; i++) {
    unsigned char c = token[i];
    if ((!isprint(c) || isspace(c)) && (isascii(c) || c == (unsigned char)255))
      return false;
    // The "&& (isascii(c) || c == 255)" was added so that we won't reject
    // non-ASCII characters such as French characters with accents [except for
    // 255 which is "nbsp", a form of space].
  }
  return true;
}

IsValidName()

bool IsValidName

(

const std::string &

name

)

Returns true if 'name' would be a valid name for a component or node in a nnet3Nnet.

This is a nonempty string beginning with A-Za-z_, and containing only '-', '_', '.', A-Z, a-z, or 0-9.

Definition at line 553 of file text-utils.cc.

References rnnlm::i.

Referenced by Nnet::AddComponent(), kaldi::nnet3::DescriptorTokenize(), ConfigLine::ParseLine(), Nnet::RemoveRedundantConfigLines(), and Nnet::SetNodeName().

                                        {
  if (name.size() == 0) return false;
  for (size_t i = 0; i < name.size(); i++) {
    if (i == 0 && !isalpha(name[i]) && name[i] != '_')
      return false;
    if (!isalnum(name[i]) && name[i] != '_' && name[i] != '-' && name[i] != '.')
      return false;
  }
  return true;
}

JoinVectorToString()

void JoinVectorToString	(	const std::vector< std::string > &	vec_in,
		const char *	delim,
		bool	omit_empty_strings,
		std::string *	str_out
	)

Joins the elements of a vector of strings into a single string using "delim" as the delimiter.

If omit_empty_strings == true, any empty strings in the vector are skipped. A vector of empty strings results in an empty string on the output.

Definition at line 77 of file text-utils.cc.

References rnnlm::i.

Referenced by TestSplitStringToVector().

                                            {
  std::string tmp_str;
  for (size_t i = 0; i < vec_in.size(); i++) {
    if (!omit_empty_strings || !vec_in[i].empty()) {
      tmp_str.append(vec_in[i]);
      if (i < vec_in.size() - 1)
        if (!omit_empty_strings || !vec_in[i+1].empty())
          tmp_str.append(delim);
    }
  }
  str_out->swap(tmp_str);
}

KaldiGetStackTrace()

static std::string kaldi::KaldiGetStackTrace ( )

static

Definition at line 133 of file kaldi-error.cc.

References rnnlm::i.

Referenced by MessageLogger::LogMessage().

                                      {
  std::string ans;
#ifdef HAVE_EXECINFO_H
  const size_t KALDI_MAX_TRACE_SIZE = 50;
  const size_t KALDI_MAX_TRACE_PRINT = 50; // Must be even.
  // Buffer for the trace.
  void *trace[KALDI_MAX_TRACE_SIZE];
  // Get the trace.
  size_t size = backtrace(trace, KALDI_MAX_TRACE_SIZE);
  // Get the trace symbols.
  char **trace_symbol = backtrace_symbols(trace, size);
  if (trace_symbol == NULL)
    return ans;

  // Compose a human-readable backtrace string.
  ans += "[ Stack-Trace: ]\n";
  if (size <= KALDI_MAX_TRACE_PRINT) {
    for (size_t i = 0; i < size; i++) {
      ans += Demangle(trace_symbol[i]) + "\n";
    }
  } else { // Print out first+last (e.g.) 5.
    for (size_t i = 0; i < KALDI_MAX_TRACE_PRINT / 2; i++) {
      ans += Demangle(trace_symbol[i]) + "\n";
    }
    ans += ".\n.\n.\n";
    for (size_t i = size - KALDI_MAX_TRACE_PRINT / 2; i < size; i++) {
      ans += Demangle(trace_symbol[i]) + "\n";
    }
    if (size == KALDI_MAX_TRACE_SIZE)
      ans += ".\n.\n.\n"; // Stack was too long, probably a bug.
  }

  // We must free the array of pointers allocated by backtrace_symbols(),
  // but not the strings themselves.
  free(trace_symbol);
#endif // HAVE_EXECINFO_H
  return ans;
}

LatticeAcousticRescore()

void kaldi::LatticeAcousticRescore	(	const TransitionModel &	trans_model,
		const Matrix< BaseFloat > &	log_likes,
		const std::vector< int32 > &	state_times,
		Lattice *	lat
	)

Definition at line 31 of file lattice-rescore-mapped.cc.

References rnnlm::i, KALDI_ASSERT, KALDI_ERR, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and TransitionModel::TransitionIdToPdf().

Referenced by main().

                                          {
  kaldi::uint64 props = lat->Properties(fst::kFstProperties, false);
  if (!(props & fst::kTopSorted))
    KALDI_ERR << "Input lattice must be topologically sorted.";

  KALDI_ASSERT(!state_times.empty());
  std::vector<std::vector<int32> > time_to_state(log_likes.NumRows());
  for (size_t i = 0; i < state_times.size(); i++) {
    KALDI_ASSERT(state_times[i] >= 0);
    if (state_times[i] < log_likes.NumRows()) // end state may be past this..
      time_to_state[state_times[i]].push_back(i);
    else
      KALDI_ASSERT(state_times[i] == log_likes.NumRows()
                   && "There appears to be lattice/feature mismatch.");
  }

  for (int32 t = 0; t < log_likes.NumRows(); t++) {
    for (size_t i = 0; i < time_to_state[t].size(); i++) {
      int32 state = time_to_state[t][i];
      for (fst::MutableArcIterator<Lattice> aiter(lat, state); !aiter.Done();
           aiter.Next()) {
        LatticeArc arc = aiter.Value();
        int32 trans_id = arc.ilabel;
        if (trans_id != 0) {  // Non-epsilon input label on arc
          int32 pdf_id = trans_model.TransitionIdToPdf(trans_id);
          if (pdf_id > log_likes.NumCols())
            KALDI_ERR << "Pdf-id " << pdf_id << " is out of the range of "
                      << "input log-likelihoods " << log_likes.NumCols()
                      << " (probably some kind of mismatch).";
          BaseFloat ll = log_likes(t, pdf_id);
          arc.weight.SetValue2(-ll + arc.weight.Value2());
          aiter.SetValue(arc);
        }
      }
    }
  }
}

LatticeActivePhones() [1/2]

void kaldi::LatticeActivePhones	(	const Lattice &	lat,
		const TransitionModel &	trans,
		const std::vector< int32 > &	sil_phones,
		std::vector< std::set< int32 > > *	active_phones
	)

Given a lattice, and a transition model to map pdf-ids to phones, outputs for each frame the set of phones active on that frame.

If sil_phones (which must be sorted and uniq) is nonempty, it excludes phones in this list.

Definition at line 399 of file lattice-functions.cc.

References IsSortedAndUniq(), KALDI_ASSERT, LatticeStateTimes(), and TransitionModel::TransitionIdToPhone().

                                                                 {
  KALDI_ASSERT(IsSortedAndUniq(silence_phones));
  vector<int32> state_times;
  int32 num_states = lat.NumStates();
  int32 max_time = LatticeStateTimes(lat, &state_times);
  active_phones->clear();
  active_phones->resize(max_time);
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = state_times[state];
    for (fst::ArcIterator<Lattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      const LatticeArc &arc = aiter.Value();
      if (arc.ilabel != 0) {  // Non-epsilon arc
        int32 phone = trans.TransitionIdToPhone(arc.ilabel);
        if (!std::binary_search(silence_phones.begin(),
                                silence_phones.end(), phone))
          (*active_phones)[cur_time].insert(phone);
      }
    }  // end looping over arcs
  }  // end looping over states
}

LatticeActivePhones() [2/2]

void kaldi::LatticeActivePhones	(	const Lattice &	lat,
		const TransitionModel &	trans,
		const std::vector< int32 > &	sil_phones,
		std::vector< std::set< int32 > > *	active_phones
	)

Given a lattice, and a transition model to map pdf-ids to phones, outputs for each frame the set of phones active on that frame.

If sil_phones (which must be sorted and uniq) is nonempty, it excludes phones in this list.

Definition at line 399 of file lattice-functions.cc.

References IsSortedAndUniq(), KALDI_ASSERT, LatticeStateTimes(), and TransitionModel::TransitionIdToPhone().

                                                                 {
  KALDI_ASSERT(IsSortedAndUniq(silence_phones));
  vector<int32> state_times;
  int32 num_states = lat.NumStates();
  int32 max_time = LatticeStateTimes(lat, &state_times);
  active_phones->clear();
  active_phones->resize(max_time);
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = state_times[state];
    for (fst::ArcIterator<Lattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      const LatticeArc &arc = aiter.Value();
      if (arc.ilabel != 0) {  // Non-epsilon arc
        int32 phone = trans.TransitionIdToPhone(arc.ilabel);
        if (!std::binary_search(silence_phones.begin(),
                                silence_phones.end(), phone))
          (*active_phones)[cur_time].insert(phone);
      }
    }  // end looping over arcs
  }  // end looping over states
}

LatticeBoost()

bool LatticeBoost	(	const TransitionModel &	trans,
		const std::vector< int32 > &	alignment,
		const std::vector< int32 > &	silence_phones,
		BaseFloat	b,
		BaseFloat	max_silence_error,
		Lattice *	lat
	)

Boosts LM probabilities by b * [number of frame errors]; equivalently, adds -b*[number of frame errors] to the graph-component of the cost of each arc/path.

There is a frame error if a particular transition-id on a particular frame corresponds to a phone not matching transcription's alignment for that frame. This is used in "margin-inspired" discriminative training, esp. Boosted MMI. The TransitionModel is used to map transition-ids in the lattice input-side to phones; the phones appearing in "silence_phones" are treated specially in that we replace the frame error f (either zero or 1) for a frame, with the minimum of f or max_silence_error. For the normal recipe, max_silence_error would be zero. Returns true on success, false if there was some kind of mismatch. At input, silence_phones must be sorted and unique.

Definition at line 735 of file lattice-functions.cc.

References IsSortedAndUniq(), KALDI_ASSERT, KALDI_WARN, LatticeStateTimes(), TransitionModel::NumTransitionIds(), TopSortLatticeIfNeeded(), and TransitionModel::TransitionIdToPhone().

Referenced by DiscriminativeComputation::Compute(), NnetDiscriminativeUpdater::LatticeComputations(), and main().

                                {
  TopSortLatticeIfNeeded(lat);

  // get all stored properties (test==false means don't test if not known).
  uint64 props = lat->Properties(fst::kFstProperties,
                                 false);

  KALDI_ASSERT(IsSortedAndUniq(silence_phones));
  KALDI_ASSERT(max_silence_error >= 0.0 && max_silence_error <= 1.0);
  vector<int32> state_times;
  int32 num_states = lat->NumStates();
  int32 num_frames = LatticeStateTimes(*lat, &state_times);
  KALDI_ASSERT(num_frames == static_cast<int32>(alignment.size()));
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = state_times[state];
    for (fst::MutableArcIterator<Lattice> aiter(lat, state); !aiter.Done();
         aiter.Next()) {
      LatticeArc arc = aiter.Value();
      if (arc.ilabel != 0) {  // Non-epsilon arc
        if (arc.ilabel < 0 || arc.ilabel > trans.NumTransitionIds()) {
          KALDI_WARN << "Lattice has out-of-range transition-ids: "
                     << "lattice/model mismatch?";
          return false;
        }
        int32 phone = trans.TransitionIdToPhone(arc.ilabel),
            ref_phone = trans.TransitionIdToPhone(alignment[cur_time]);
        BaseFloat frame_error;
        if (phone == ref_phone) {
          frame_error = 0.0;
        } else { // an error...
          if (std::binary_search(silence_phones.begin(), silence_phones.end(), phone))
            frame_error = max_silence_error;
          else
            frame_error = 1.0;
        }
        BaseFloat delta_cost = -b * frame_error; // negative cost if
        // frame is wrong, to boost likelihood of arcs with errors on them.
        // Add this cost to the graph part.
        arc.weight.SetValue1(arc.weight.Value1() + delta_cost);
        aiter.SetValue(arc);
      }
    }
  }
  // All we changed is the weights, so any properties that were
  // known before, are still known, except for whether or not the
  // lattice was weighted.
  lat->SetProperties(props,
                     ~(fst::kWeighted|fst::kUnweighted));

  return true;
}

LatticeForwardBackward()

BaseFloat LatticeForwardBackward	(	const Lattice &	lat,
		Posterior *	arc_post,
		double *	acoustic_like_sum = NULL
	)

This function does the forward-backward over lattices and computes the posterior probabilities of the arcs.

It returns the total log-probability of the lattice. The Posterior quantities contain pairs of (transition-id, weight) on each frame. If the pointer "acoustic_like_sum" is provided, this value is set to the sum over the arcs, of the posterior of the arc times the acoustic likelihood [i.e. negated acoustic score] on that link. This is used in combination with other quantities to work out the objective function in MMI discriminative training.

Definition at line 314 of file lattice-functions.cc.

References ApproxEqual(), fst::ConvertToCost(), Exp(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, kLogZeroDouble, LatticeStateTimes(), LogAdd(), and MergePairVectorSumming().

Referenced by SingleUtteranceGmmDecoder::GetGaussianPosteriors(), LatticeForwardBackwardMmi(), main(), and TestWordAlignedLattice().

                                                            {
  // Note, Posterior is defined as follows:  Indexed [frame], then a list
  // of (transition-id, posterior-probability) pairs.
  // typedef std::vector<std::vector<std::pair<int32, BaseFloat> > > Posterior;
  using namespace fst;
  typedef Lattice::Arc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  if (acoustic_like_sum) *acoustic_like_sum = 0.0;

  // Make sure the lattice is topologically sorted.
  if (lat.Properties(fst::kTopSorted, true) == 0)
    KALDI_ERR << "Input lattice must be topologically sorted.";
  KALDI_ASSERT(lat.Start() == 0);

  int32 num_states = lat.NumStates();
  vector<int32> state_times;
  int32 max_time = LatticeStateTimes(lat, &state_times);
  std::vector<double> alpha(num_states, kLogZeroDouble);
  std::vector<double> &beta(alpha); // we re-use the same memory for
  // this, but it's semantically distinct so we name it differently.
  double tot_forward_prob = kLogZeroDouble;

  post->clear();
  post->resize(max_time);

  alpha[0] = 0.0;
  // Propagate alphas forward.
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = alpha[s];
    for (ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight);
      alpha[arc.nextstate] = LogAdd(alpha[arc.nextstate], this_alpha + arc_like);
    }
    Weight f = lat.Final(s);
    if (f != Weight::Zero()) {
      double final_like = this_alpha - (f.Value1() + f.Value2());
      tot_forward_prob = LogAdd(tot_forward_prob, final_like);
      KALDI_ASSERT(state_times[s] == max_time &&
                   "Lattice is inconsistent (final-prob not at max_time)");
    }
  }
  for (StateId s = num_states-1; s >= 0; s--) {
    Weight f = lat.Final(s);
    double this_beta = -(f.Value1() + f.Value2());
    for (ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight),
          arc_beta = beta[arc.nextstate] + arc_like;
      this_beta = LogAdd(this_beta, arc_beta);
      int32 transition_id = arc.ilabel;

      // The following "if" is an optimization to avoid un-needed exp().
      if (transition_id != 0 || acoustic_like_sum != NULL) {
        double posterior = Exp(alpha[s] + arc_beta - tot_forward_prob);

        if (transition_id != 0) // Arc has a transition-id on it [not epsilon]
          (*post)[state_times[s]].push_back(std::make_pair(transition_id,
                                                           static_cast<kaldi::BaseFloat>(posterior)));
        if (acoustic_like_sum != NULL)
          *acoustic_like_sum -= posterior * arc.weight.Value2();
      }
    }
    if (acoustic_like_sum != NULL && f != Weight::Zero()) {
      double final_logprob = - ConvertToCost(f),
          posterior = Exp(alpha[s] + final_logprob - tot_forward_prob);
      *acoustic_like_sum -= posterior * f.Value2();
    }
    beta[s] = this_beta;
  }
  double tot_backward_prob = beta[0];
  if (!ApproxEqual(tot_forward_prob, tot_backward_prob, 1e-8)) {
    KALDI_WARN << "Total forward probability over lattice = " << tot_forward_prob
              << ", while total backward probability = " << tot_backward_prob;
  }
  // Now combine any posteriors with the same transition-id.
  for (int32 t = 0; t < max_time; t++)
    MergePairVectorSumming(&((*post)[t]));
  return tot_backward_prob;
}

LatticeForwardBackwardMmi()

BaseFloat LatticeForwardBackwardMmi	(	const TransitionModel &	trans,
		const Lattice &	lat,
		const std::vector< int32 > &	num_ali,
		bool	drop_frames,
		bool	convert_to_pdf_ids,
		bool	cancel,
		Posterior *	arc_post
	)

This function can be used to compute posteriors for MMI, with a positive contribution for the numerator and a negative one for the denominator.

This function is not actually used in our normal MMI training recipes, where it's instead done using various command line programs that each do a part of the job. This function was written for use in neural-net MMI training.

Parameters

[in]	trans	The transition model. Used to map the transition-ids to phones or pdfs.
[in]	lat	The denominator lattice
[in]	num_ali	The numerator alignment
[in]	drop_frames	If "drop_frames" is true, it will not compute any posteriors on frames where the num and den have disjoint pdf-ids.
[in]	convert_to_pdf_ids	If "convert_to_pdfs_ids" is true, it will convert the output to be at the level of pdf-ids, not transition-ids.
[in]	cancel	If "cancel" is true, it will cancel out any positive and negative parts from the same transition-id (or pdf-id, if convert_to_pdf_ids == true).
[out]	arc_post	The output MMI posteriors of transition-ids (or pdf-ids if convert_to_pdf_ids == true) at each frame i.e. the difference between the numerator and denominator posteriors.

It returns the forward-backward likelihood of the lattice.

Definition at line 1414 of file lattice-functions.cc.

References AlignmentToPosterior(), ConvertPosteriorToPdfs(), LatticeForwardBackward(), MergePosteriors(), and ScalePosterior().

Referenced by DiscriminativeComputation::ComputeObjfAndDeriv(), kaldi::nnet2::ExampleToPdfPost(), and NnetDiscriminativeUpdater::GetDiscriminativePosteriors().

                     {
  // First compute the MMI posteriors.

  Posterior den_post;
  BaseFloat ans = LatticeForwardBackward(lat,
                                         &den_post,
                                         NULL);

  Posterior num_post;
  AlignmentToPosterior(num_ali, &num_post);

  // Now negate the MMI posteriors and add the numerator
  // posteriors.
  ScalePosterior(-1.0, &den_post);

  if (convert_to_pdf_ids) {
    Posterior num_tmp;
    ConvertPosteriorToPdfs(tmodel, num_post, &num_tmp);
    num_tmp.swap(num_post);
    Posterior den_tmp;
    ConvertPosteriorToPdfs(tmodel, den_post, &den_tmp);
    den_tmp.swap(den_post);
  }

  MergePosteriors(num_post, den_post,
                  cancel, drop_frames, post);

  return ans;
}

LatticeForwardBackwardMpeVariants()

BaseFloat LatticeForwardBackwardMpeVariants	(	const TransitionModel &	trans,
		const std::vector< int32 > &	silence_phones,
		const Lattice &	lat,
		const std::vector< int32 > &	num_ali,
		std::string	criterion,
		bool	one_silence_class,
		Posterior *	post
	)

This function implements either the MPFE (minimum phone frame error) or SMBR (state-level minimum bayes risk) forward-backward, depending on whether "criterion" is "mpfe" or "smbr".

It returns the MPFE criterion of SMBR criterion for this utterance, and outputs the posteriors (which may be positive or negative) into "post".

Parameters

[in]	trans	The transition model. Used to map the transition-ids to phones or pdfs.
[in]	silence_phones	A list of integer ids of silence phones. The silence frames i.e. the frames where num_ali corresponds to a silence phones are treated specially. The behavior is determined by 'one_silence_class' being false (traditional behavior) or true. Usually in our setup, several phones including the silence, vocalized noise, non-spoken noise and unk are treated as "silence phones"
[in]	lat	The denominator lattice
[in]	num_ali	The numerator alignment
[in]	criterion	The objective function. Must be "mpfe" or "smbr" for MPFE (minimum phone frame error) or sMBR (state minimum bayes risk) training.
[in]	one_silence_class	Determines how the silence frames are treated. Setting this to false gives the old traditional behavior, where the silence frames (according to num_ali) are treated as incorrect. However, this means that the insertions are not penalized by the objective. Setting this to true gives the new behaviour, where we treat silence as any other phone, except that all pdfs of silence phones are collapsed into a single class for the frame-error computation. This can possible reduce the insertions in the trained model. This is closer to the WER metric that we actually care about, since WER is generally computed after filtering out noises, but does penalize insertions.
[out]	post	The "MBR posteriors" i.e. derivatives w.r.t to the pseudo log-likelihoods of states at each frame.

Definition at line 794 of file lattice-functions.cc.

References ApproxEqual(), fst::ConvertToCost(), Exp(), KALDI_ASSERT, KALDI_ERR, KALDI_ISNAN, kLogZeroDouble, LatticeStateTimes(), LogAdd(), MergePairVectorSumming(), TransitionModel::TransitionIdToPdf(), and TransitionModel::TransitionIdToPhone().

Referenced by DiscriminativeComputation::ComputeObjfAndDeriv(), kaldi::nnet2::ExampleToPdfPost(), NnetDiscriminativeUpdater::GetDiscriminativePosteriors(), and main().

                     {
  using namespace fst;
  typedef Lattice::Arc Arc;
  typedef Arc::Weight Weight;
  typedef Arc::StateId StateId;

  KALDI_ASSERT(criterion == "mpfe" || criterion == "smbr");
  bool is_mpfe = (criterion == "mpfe");

  if (lat.Properties(fst::kTopSorted, true) == 0)
    KALDI_ERR << "Input lattice must be topologically sorted.";
  KALDI_ASSERT(lat.Start() == 0);

  int32 num_states = lat.NumStates();
  vector<int32> state_times;
  int32 max_time = LatticeStateTimes(lat, &state_times);
  KALDI_ASSERT(max_time == static_cast<int32>(num_ali.size()));
  std::vector<double> alpha(num_states, kLogZeroDouble),
      alpha_smbr(num_states, 0), //forward variable for sMBR
      beta(num_states, kLogZeroDouble),
      beta_smbr(num_states, 0); //backward variable for sMBR

  double tot_forward_prob = kLogZeroDouble;
  double tot_forward_score = 0;

  post->clear();
  post->resize(max_time);

  alpha[0] = 0.0;
  // First Pass Forward,
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = alpha[s];
    for (ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight);
      alpha[arc.nextstate] = LogAdd(alpha[arc.nextstate], this_alpha + arc_like);
    }
    Weight f = lat.Final(s);
    if (f != Weight::Zero()) {
      double final_like = this_alpha - (f.Value1() + f.Value2());
      tot_forward_prob = LogAdd(tot_forward_prob, final_like);
      KALDI_ASSERT(state_times[s] == max_time &&
                   "Lattice is inconsistent (final-prob not at max_time)");
    }
  }
  // First Pass Backward,
  for (StateId s = num_states-1; s >= 0; s--) {
    Weight f = lat.Final(s);
    double this_beta = -(f.Value1() + f.Value2());
    for (ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight),
          arc_beta = beta[arc.nextstate] + arc_like;
      this_beta = LogAdd(this_beta, arc_beta);
    }
    beta[s] = this_beta;
  }
  // First Pass Forward-Backward Check
  double tot_backward_prob = beta[0];
  // may loose the condition somehow here 1e-6 (was 1e-8)
  if (!ApproxEqual(tot_forward_prob, tot_backward_prob, 1e-6)) {
    KALDI_ERR << "Total forward probability over lattice = " << tot_forward_prob
              << ", while total backward probability = " << tot_backward_prob;
  }

  alpha_smbr[0] = 0.0;
  // Second Pass Forward, calculate forward for MPFE/SMBR
  for (StateId s = 0; s < num_states; s++) {
    double this_alpha = alpha[s];
    for (ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight);
      double frame_acc = 0.0;
      if (arc.ilabel != 0) {
        int32 cur_time = state_times[s];
        int32 phone = trans.TransitionIdToPhone(arc.ilabel),
            ref_phone = trans.TransitionIdToPhone(num_ali[cur_time]);
        bool phone_is_sil = std::binary_search(silence_phones.begin(),
                                               silence_phones.end(),
                                               phone),
            ref_phone_is_sil = std::binary_search(silence_phones.begin(),
                                                  silence_phones.end(),
                                                  ref_phone),
            both_sil = phone_is_sil && ref_phone_is_sil;
        if (!is_mpfe) { // smbr.
          int32 pdf = trans.TransitionIdToPdf(arc.ilabel),
              ref_pdf = trans.TransitionIdToPdf(num_ali[cur_time]);
          if (!one_silence_class)  // old behavior
            frame_acc = (pdf == ref_pdf && !phone_is_sil) ? 1.0 : 0.0;
          else
            frame_acc = (pdf == ref_pdf || both_sil) ? 1.0 : 0.0;
        } else {
          if (!one_silence_class)  // old behavior
            frame_acc = (phone == ref_phone && !phone_is_sil) ? 1.0 : 0.0;
          else
            frame_acc = (phone == ref_phone || both_sil) ? 1.0 : 0.0;
        }
      }
      double arc_scale = Exp(alpha[s] + arc_like - alpha[arc.nextstate]);
      alpha_smbr[arc.nextstate] += arc_scale * (alpha_smbr[s] + frame_acc);
    }
    Weight f = lat.Final(s);
    if (f != Weight::Zero()) {
      double final_like = this_alpha - (f.Value1() + f.Value2());
      double arc_scale = Exp(final_like - tot_forward_prob);
      tot_forward_score += arc_scale * alpha_smbr[s];
      KALDI_ASSERT(state_times[s] == max_time &&
                   "Lattice is inconsistent (final-prob not at max_time)");
    }
  }
  // Second Pass Backward, collect Mpe style posteriors
  for (StateId s = num_states-1; s >= 0; s--) {
    for (ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      double arc_like = -ConvertToCost(arc.weight),
          arc_beta = beta[arc.nextstate] + arc_like;
      double frame_acc = 0.0;
      int32 transition_id = arc.ilabel;
      if (arc.ilabel != 0) {
        int32 cur_time = state_times[s];
        int32 phone = trans.TransitionIdToPhone(arc.ilabel),
            ref_phone = trans.TransitionIdToPhone(num_ali[cur_time]);
        bool phone_is_sil = std::binary_search(silence_phones.begin(),
                                               silence_phones.end(), phone),
            ref_phone_is_sil = std::binary_search(silence_phones.begin(),
                                                  silence_phones.end(),
                                                  ref_phone),
            both_sil = phone_is_sil && ref_phone_is_sil;
        if (!is_mpfe) { // smbr.
          int32 pdf = trans.TransitionIdToPdf(arc.ilabel),
              ref_pdf = trans.TransitionIdToPdf(num_ali[cur_time]);
          if (!one_silence_class)  // old behavior
            frame_acc = (pdf == ref_pdf && !phone_is_sil) ? 1.0 : 0.0;
          else
            frame_acc = (pdf == ref_pdf || both_sil) ? 1.0 : 0.0;
        } else {
          if (!one_silence_class)  // old behavior
            frame_acc = (phone == ref_phone && !phone_is_sil) ? 1.0 : 0.0;
          else
            frame_acc = (phone == ref_phone || both_sil) ? 1.0 : 0.0;
        }
      }
      double arc_scale = Exp(beta[arc.nextstate] + arc_like - beta[s]);
      // check arc_scale NAN,
      // this is to prevent partial paths in Lattices
      // i.e., paths don't survive to the final state
      if (KALDI_ISNAN(arc_scale)) arc_scale = 0;
      beta_smbr[s] += arc_scale * (beta_smbr[arc.nextstate] + frame_acc);

      if (transition_id != 0) { // Arc has a transition-id on it [not epsilon]
        double posterior = Exp(alpha[s] + arc_beta - tot_forward_prob);
        double acc_diff = alpha_smbr[s] + frame_acc + beta_smbr[arc.nextstate]
                               - tot_forward_score;
        double posterior_smbr = posterior * acc_diff;
        (*post)[state_times[s]].push_back(std::make_pair(transition_id,
                                                         static_cast<BaseFloat>(posterior_smbr)));
      }
    }
  }

  //Second Pass Forward Backward check
  double tot_backward_score = beta_smbr[0];  // Initial state id == 0
  // may loose the condition somehow here 1e-5/1e-4
  if (!ApproxEqual(tot_forward_score, tot_backward_score, 1e-4)) {
    KALDI_ERR << "Total forward score over lattice = " << tot_forward_score
              << ", while total backward score = " << tot_backward_score;
  }

  // Output the computed posteriors
  for (int32 t = 0; t < max_time; t++)
    MergePairVectorSumming(&((*post)[t]));
  return tot_forward_score;
}

LatticeStateTimes() [1/2]

int32 kaldi::LatticeStateTimes	(	const Lattice &	lat,
		std::vector< int32 > *	times
	)

This function iterates over the states of a topologically sorted lattice and counts the time instance corresponding to each state.

The times are returned in a vector of integers 'times' which is resized to have a size equal to the number of states in the lattice. The function also returns the maximum time in the lattice (this will equal the number of frames in the file).

Definition at line 78 of file lattice-functions.cc.

References KALDI_ASSERT, and KALDI_ERR.

Referenced by DiscriminativeSupervision::Check(), DiscriminativeExampleSplitter::CollapseTransitionIds(), ComputeAcousticScoresMap(), DiscriminativeExampleSplitter::ComputeFrameInfo(), DiscriminativeSupervisionSplitter::ComputeLatticeScores(), DiscriminativeSupervisionSplitter::CreateRangeLattice(), GetLatticeTimeSpan(), LatticeActivePhones(), LatticeBoost(), NnetDiscriminativeUpdater::LatticeComputations(), LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), DiscriminativeComputation::LookupNnetOutput(), main(), DiscriminativeSupervisionSplitter::PrepareLattice(), ReplaceAcousticScoresFromMap(), and RescoreLattice().

                                                                  {
  if (!lat.Properties(fst::kTopSorted, true))
    KALDI_ERR << "Input lattice must be topologically sorted.";
  KALDI_ASSERT(lat.Start() == 0);
  int32 num_states = lat.NumStates();
  times->clear();
  times->resize(num_states, -1);
  (*times)[0] = 0;
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = (*times)[state];
    for (fst::ArcIterator<Lattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      const LatticeArc &arc = aiter.Value();

      if (arc.ilabel != 0) {  // Non-epsilon input label on arc
        // next time instance
        if ((*times)[arc.nextstate] == -1) {
          (*times)[arc.nextstate] = cur_time + 1;
        } else {
          KALDI_ASSERT((*times)[arc.nextstate] == cur_time + 1);
        }
      } else {  // epsilon input label on arc
        // Same time instance
        if ((*times)[arc.nextstate] == -1)
          (*times)[arc.nextstate] = cur_time;
        else
          KALDI_ASSERT((*times)[arc.nextstate] == cur_time);
      }
    }
  }
  return (*std::max_element(times->begin(), times->end()));
}

LatticeStateTimes() [2/2]

int32 kaldi::LatticeStateTimes	(	const Lattice &	lat,
		std::vector< int32 > *	times
	)

This function iterates over the states of a topologically sorted lattice and counts the time instance corresponding to each state.

The times are returned in a vector of integers 'times' which is resized to have a size equal to the number of states in the lattice. The function also returns the maximum time in the lattice (this will equal the number of frames in the file).

Definition at line 78 of file lattice-functions.cc.

References KALDI_ASSERT, and KALDI_ERR.

Referenced by DiscriminativeSupervision::Check(), DiscriminativeExampleSplitter::CollapseTransitionIds(), ComputeAcousticScoresMap(), DiscriminativeExampleSplitter::ComputeFrameInfo(), DiscriminativeSupervisionSplitter::ComputeLatticeScores(), DiscriminativeSupervisionSplitter::CreateRangeLattice(), GetLatticeTimeSpan(), LatticeActivePhones(), LatticeBoost(), NnetDiscriminativeUpdater::LatticeComputations(), LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), DiscriminativeComputation::LookupNnetOutput(), main(), DiscriminativeSupervisionSplitter::PrepareLattice(), ReplaceAcousticScoresFromMap(), and RescoreLattice().

                                                                  {
  if (!lat.Properties(fst::kTopSorted, true))
    KALDI_ERR << "Input lattice must be topologically sorted.";
  KALDI_ASSERT(lat.Start() == 0);
  int32 num_states = lat.NumStates();
  times->clear();
  times->resize(num_states, -1);
  (*times)[0] = 0;
  for (int32 state = 0; state < num_states; state++) {
    int32 cur_time = (*times)[state];
    for (fst::ArcIterator<Lattice> aiter(lat, state); !aiter.Done();
        aiter.Next()) {
      const LatticeArc &arc = aiter.Value();

      if (arc.ilabel != 0) {  // Non-epsilon input label on arc
        // next time instance
        if ((*times)[arc.nextstate] == -1) {
          (*times)[arc.nextstate] = cur_time + 1;
        } else {
          KALDI_ASSERT((*times)[arc.nextstate] == cur_time + 1);
        }
      } else {  // epsilon input label on arc
        // Same time instance
        if ((*times)[arc.nextstate] == -1)
          (*times)[arc.nextstate] = cur_time;
        else
          KALDI_ASSERT((*times)[arc.nextstate] == cur_time);
      }
    }
  }
  return (*std::max_element(times->begin(), times->end()));
}

LatticeToString() [1/2]

std::string kaldi::LatticeToString	(	const Lattice &	lat,
		const fst::SymbolTable &	word_syms
	)

Definition at line 70 of file online2-tcp-nnet3-decode-faster.cc.

References fst::GetLinearSymbolSequence(), rnnlm::i, KALDI_WARN, and words.

Referenced by LatticeToString(), and main().

                                                                               {
  LatticeWeight weight;
  std::vector<int32> alignment;
  std::vector<int32> words;
  GetLinearSymbolSequence(lat, &alignment, &words, &weight);

  std::ostringstream msg;
  for (size_t i = 0; i < words.size(); i++) {
    std::string s = word_syms.Find(words[i]);
    if (s.empty()) {
      KALDI_WARN << "Word-id " << words[i] << " not in symbol table.";
      msg << "<#" << std::to_string(i) << "> ";
    } else
      msg << s << " ";
  }
  return msg.str();
}

LatticeToString() [2/2]

std::string kaldi::LatticeToString	(	const CompactLattice &	clat,
		const fst::SymbolTable &	word_syms
	)

Definition at line 102 of file online2-tcp-nnet3-decode-faster.cc.

References CompactLatticeShortestPath(), fst::ConvertLattice(), KALDI_WARN, and LatticeToString().

                                                                                       {
  if (clat.NumStates() == 0) {
    KALDI_WARN << "Empty lattice.";
    return "";
  }
  CompactLattice best_path_clat;
  CompactLatticeShortestPath(clat, &best_path_clat);

  Lattice best_path_lat;
  ConvertLattice(best_path_clat, &best_path_lat);
  return LatticeToString(best_path_lat, word_syms);
}

Lcm()

I kaldi::Lcm	(	I	m,
		I	n
	)

Returns the least common multiple of two integers.

Will crash unless the inputs are positive.

Definition at line 318 of file kaldi-math.h.

References Gcd(), and KALDI_ASSERT.

Referenced by NnetSimpleComputationOptions::CheckAndFixConfigs(), DecodableNnetSimple::CheckAndFixConfigs(), LinearResample::GetNumOutputSamples(), SwitchingForwardingDescriptor::Modulus(), Nnet::Modulus(), BinarySumDescriptor::Modulus(), Descriptor::Modulus(), and UnitTestGcdLcmTpl().

                                   {
  KALDI_ASSERT(m > 0 && n > 0);
  I gcd = Gcd(m, n);
  return gcd * (m/gcd) * (n/gcd);
}

LevenshteinAlignment()

int32 LevenshteinAlignment	(	const std::vector< T > &	a,
		const std::vector< T > &	b,
		T	eps_symbol,
		std::vector< std::pair< T, T > > *	output
	)

Definition at line 130 of file edit-distance-inl.h.

References rnnlm::i, KALDI_ASSERT, rnnlm::n, and ReverseVector().

Referenced by main(), and TestLevenshteinAlignment().

                                                              {
  // Check inputs:
  {
    KALDI_ASSERT(output != NULL);
    for (size_t i = 0; i < a.size(); i++) KALDI_ASSERT(a[i] != eps_symbol);
    for (size_t i = 0; i < b.size(); i++) KALDI_ASSERT(b[i] != eps_symbol);
  }
  output->clear();
  // This is very memory-inefficiently implemented using a vector of vectors.
  size_t M = a.size(), N = b.size();
  size_t m, n;
  std::vector<std::vector<int32> > e(M+1);
  for (m = 0; m <=M; m++) e[m].resize(N+1);
  for (n = 0; n <= N; n++)
    e[0][n]  = n;
  for (m = 1; m <= M; m++) {
    e[m][0] = e[m-1][0] + 1;
    for (n = 1; n <= N; n++) {
      int32 sub_or_ok = e[m-1][n-1] + (a[m-1] == b[n-1] ? 0 : 1);
      int32 del = e[m-1][n] + 1;  // assumes a == ref, b == hyp.
      int32 ins = e[m][n-1] + 1;
      e[m][n] = std::min(sub_or_ok, std::min(del, ins));
    }
  }
  // get time-reversed output first: trace back.
  m = M;
  n = N;
  while (m != 0 || n != 0) {
    size_t last_m, last_n;
    if (m == 0) {
      last_m = m;
      last_n = n-1;
    } else if (n == 0) {
      last_m = m-1;
      last_n = n;
    } else {
      int32 sub_or_ok = e[m-1][n-1] + (a[m-1] == b[n-1] ? 0 : 1);
      int32 del = e[m-1][n] + 1;  // assumes a == ref, b == hyp.
      int32 ins = e[m][n-1] + 1;
      // choose sub_or_ok if all else equal.
      if (sub_or_ok <= std::min(del, ins)) {
        last_m = m-1;
        last_n = n-1;
      } else {
        if (del <= ins) {  // choose del over ins if equal.
          last_m = m-1;
          last_n = n;
        } else {
          last_m = m;
          last_n = n-1;
        }
      }
    }
    T a_sym, b_sym;
    a_sym = (last_m == m ? eps_symbol : a[last_m]);
    b_sym = (last_n == n ? eps_symbol : b[last_n]);
    output->push_back(std::make_pair(a_sym, b_sym));
    m = last_m;
    n = last_n;
  }
  ReverseVector(output);
  return e[M][N];
}

LevenshteinEditDistance() [1/2]

int32 LevenshteinEditDistance	(	const std::vector< T > &	a,
		const std::vector< T > &	b
	)

Definition at line 30 of file edit-distance-inl.h.

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

Referenced by GetEditsDualHyp(), GetEditsSingleHyp(), main(), TestEditDistance(), TestEditDistance2(), TestEditDistance2String(), TestEditDistanceString(), and TestLevenshteinAlignment().

                                                     {
  // Algorithm:
  //  write A and B for the sequences, with elements a_0 ..
  //  let |A| = M and |B| = N be the lengths, and have
  //  elements a_0 ... a_{M-1} and b_0 ... b_{N-1}.
  //  We are computing the recursion
  //     E(m, n) = min(  E(m-1, n-1) + (1-delta(a_{m-1}, b_{n-1})),
  //                    E(m-1, n) + 1,
  //                    E(m, n-1) + 1).
  //  where E(m, n) is defined for m = 0..M and n = 0..N and out-of-
  //  bounds quantities are considered to be infinity (i.e. the
  //  recursion does not visit them).

  // We do this computation using a vector e of size N+1.
  // The outer iterations range over m = 0..M.

  int M = a.size(), N = b.size();
  std::vector<int32> e(N+1);
  std::vector<int32> e_tmp(N+1);
  // initialize e.
  for (size_t i = 0; i < e.size(); i++)
    e[i] = i;
  for (int32 m = 1; m <= M; m++) {
    // computing E(m, .) from E(m-1, .)
    // handle special case n = 0:
    e_tmp[0] = e[0] + 1;

    for (int32 n = 1; n <= N; n++) {
      int32 term1 = e[n-1] + (a[m-1] == b[n-1] ? 0 : 1);
      int32 term2 = e[n] + 1;
      int32 term3 = e_tmp[n-1] + 1;
      e_tmp[n] = std::min(term1, std::min(term2, term3));
    }
    e = e_tmp;
  }
  return e.back();
}

LevenshteinEditDistance() [2/2]

int32 LevenshteinEditDistance	(	const std::vector< T > &	ref,
		const std::vector< T > &	hyp,
		int32 *	ins,
		int32 *	del,
		int32 *	sub
	)

Definition at line 79 of file edit-distance-inl.h.

References rnnlm::i.

                                                                  {
  // temp sequence to remember error type and stats.
  std::vector<error_stats> e(ref.size()+1);
  std::vector<error_stats> cur_e(ref.size()+1);
  // initialize the first hypothesis aligned to the reference at each
  // position:[hyp_index =0][ref_index]
  for (size_t i =0; i < e.size(); i ++) {
    e[i].ins_num = 0;
    e[i].sub_num = 0;
    e[i].del_num = i;
    e[i].total_cost = i;
  }

  // for other alignments
  for (size_t hyp_index = 1; hyp_index <= hyp.size(); hyp_index ++) {
    cur_e[0] = e[0];
    cur_e[0].ins_num++;
    cur_e[0].total_cost++;
    for (size_t ref_index = 1; ref_index <= ref.size(); ref_index ++) {
     int32 ins_err = e[ref_index].total_cost + 1;
     int32 del_err = cur_e[ref_index-1].total_cost + 1;
     int32 sub_err = e[ref_index-1].total_cost;
      if (hyp[hyp_index-1] != ref[ref_index-1])
       sub_err++;

     if (sub_err < ins_err && sub_err < del_err) {
        cur_e[ref_index] =e[ref_index-1];
        if (hyp[hyp_index-1] != ref[ref_index-1])
          cur_e[ref_index].sub_num++;  // substitution error should be increased
        cur_e[ref_index].total_cost = sub_err;
     } else if (del_err < ins_err) {
        cur_e[ref_index] = cur_e[ref_index-1];
        cur_e[ref_index].total_cost = del_err;
        cur_e[ref_index].del_num++;    // deletion number is increased.
     } else {
        cur_e[ref_index] = e[ref_index];
        cur_e[ref_index].total_cost = ins_err;
        cur_e[ref_index].ins_num++;    // insertion number is increased.
     }
  }
  e = cur_e;  // alternate for the next recursion.
  }
  size_t ref_index = e.size()-1;
  *ins = e[ref_index].ins_num, *del =
    e[ref_index].del_num, *sub = e[ref_index].sub_num;
  return e[ref_index].total_cost;
}

LinearCgd< double >()

template int32 kaldi::LinearCgd< double >	(	const LinearCgdOptions &	opts,
		const SpMatrix< double > &	A,
		const VectorBase< double > &	b,
		VectorBase< double > *	x
	)

Referenced by LinearCgd().

LinearCgd< float >()

template int32 kaldi::LinearCgd< float >	(	const LinearCgdOptions &	opts,
		const SpMatrix< float > &	A,
		const VectorBase< float > &	b,
		VectorBase< float > *	x
	)

Referenced by LinearCgd().

LinearlyInterpolatePitch()

void kaldi::LinearlyInterpolatePitch

(

Matrix< BaseFloat > *

mat

)

Definition at line 252 of file interpolate-pitch.cc.

References rnnlm::i, and MatrixBase< Real >::NumRows().

Referenced by main().

                                                      {
  int32 num_frames = mat->NumRows();
  int i = 0;
  Matrix<BaseFloat> &features = *mat;
  while (i < num_frames) {
    if(features(i, 1) == 0.0) {
      int start = i - 1;
      int end = i;
      while( (features(end, 1)) == 0.0 && (end < num_frames))
        end++;
      BaseFloat end_value = -1, start_value = -1;
      if (end < num_frames) end_value = features(end, 1);
      if (start > 0) start_value = features(start, 1);

      if (start_value < 0 && end_value < 0) {
        // the whole file is unvoiced -> just put an arbitrary value,
        // it will all be normalized out anyway.
        start_value = 1.0;
        end_value = 1.0;
      }
      // If we don't have a value for one end of the range, i.e. at the start or
      // end, set it to 0.9 times the pitch value that we have at the other end
      // of the range.  The reason we don't set it to that value itself, is that
      // then over this segment we would have zero time-derivative, so if we
      // took time derivatives we would have an artificial spike at zero.
      if (start_value < 0.0) start_value = 0.9 * end_value;
      if (end_value < 0.0) end_value = 0.9 * start_value;
      
      for(int k = start + 1; k < end; k++)
        features(k, 1) = start_value +
            (end_value - start_value) / (end - start) * (k - start);
      i = end;
    }
    i++;
  }
}

Log() [1/2]

double kaldi::Log ( double  x )

inline

Definition at line 100 of file kaldi-math.h.

Referenced by VectorBase< float >::ApplyLog(), VectorBase< float >::ApplyLogAndCopy(), VectorBase< float >::ApplyLogSoftMax(), VectorBase< float >::ApplySoftMax(), MatrixBase< float >::ApplySoftMax(), CompactLatticeNormalize(), CuMatrix< float >::CompObjfAndDeriv(), AmSgmm2::ComponentPosteriors(), SpectrogramComputer::Compute(), MfccComputer::Compute(), FbankComputer::Compute(), PlpComputer::Compute(), PitchFrameInfo::ComputeBacktraces(), TransitionModel::ComputeDerivedOfProbs(), FullGmm::ComputeGconsts(), ComputeGconsts(), DiagGmm::ComputeGconsts(), NnetComputer::ComputeLastLayerDeriv(), ComputeLpc(), MleAmSgmm2Updater::ComputeMPrior(), AmSgmm2::ComputeNormalizersInternal(), DiscriminativeComputation::ConvertAnswersToLogLike(), CuVectorUnitTestApplyLog(), CuMatrixBase< float >::DiffXent(), DoRescalingUpdate(), EBWUpdateGaussian(), FbankComputer::FbankComputer(), FmllrInnerUpdate(), GetHmmAsFsa(), GetHmmAsFsaSimple(), GetLogLikeTest(), LogisticRegression::GetObjfAndGrad(), OnlineProcessPitch::GetRawLogPitchFeature(), Rbm::InitData(), TransitionModel::InitializeProbs(), SpMatrix< float >::Invert(), MatrixBase< float >::Invert(), KaldiAssertFailure_(), kaldi::nnet2::KlDivergence(), kaldi::nnet3::KlDivergence(), NnetDiscriminativeUpdater::LatticeComputations(), MatrixBase< float >::Log(), Log1p(), AmSgmm2::LogLikelihood(), SpMatrix< float >::LogPosDefDet(), LogSub(), VectorBase< float >::LogSumExp(), MatrixBase< float >::LogSumExp(), main(), TransitionModel::MapUpdate(), TransitionModel::MapUpdateShared(), DiagGmm::Merge(), DiagGmm::merged_components_logdet(), MfccComputer::MfccComputer(), SoftmaxComponent::MixUp(), TransitionModel::MleUpdate(), TransitionModel::MleUpdateShared(), PushSpecialClass::ModifyFst(), PitchInterpolator::MultiplyObsProb(), OnlinePaSource::OnlinePaSource(), PlpComputer::PlpComputer(), ProcessPovFeatures(), ProcessWindow(), LogSoftmaxComponent::Propagate(), RandGauss(), SpectrogramComputer::SpectrogramComputer(), VectorBase< float >::SumLog(), TakeLogOfPitch(), PushSpecialClass::TestAccuracy(), UnitTestCuDiffXent(), UnitTestDeterminantSign(), UnitTestDiagGmm(), UnitTestEig(), UnitTestFullGmm(), UnitTestLogAddSub(), UnitTestLogSpeed(), UnitTestTrain(), MlltAccs::Update(), OnlineProcessPitch::UpdateNormalizationStats(), MleAmSgmm2Updater::UpdateSubstateWeights(), and VectorToPosteriorEntry().

{ return log(x); }

Log() [2/2]

float kaldi::Log ( float  x )

inline

Definition at line 101 of file kaldi-math.h.

{ return logf(x); }

Log1p() [1/2]

double kaldi::Log1p ( double  x )

inline

Definition at line 104 of file kaldi-math.h.

Referenced by Log1p(), LogAdd(), MatrixBase< float >::SoftHinge(), and UnitTestSoftHinge().

{  return log1p(x); }

Log1p() [2/2]

float kaldi::Log1p ( float  x )

inline

Definition at line 105 of file kaldi-math.h.

References Log(), and Log1p().

{  return log1pf(x); }

LogAdd() [1/2]

double kaldi::LogAdd ( double  x, double  y  )

inline

Definition at line 184 of file kaldi-math.h.

References Exp(), and Log1p().

Referenced by ComputeCompactLatticeAlphas(), ComputeCompactLatticeBetas(), MinimumBayesRisk::EditDistance(), FullGmm::GaussianSelection(), DiagGmm::GaussianSelection(), FullGmm::GaussianSelectionPreselect(), DiagGmm::GaussianSelectionPreselect(), GetLogLikeTest(), LogisticRegression::GetLogPosteriors(), fst::InputDeterminizeSingleState(), GrammarFstPreparer::InsertEpsilonsForState(), LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), LogAddOrMax(), and UnitTestLogAddSub().

                                         {
  double diff;

  if (x < y) {
    diff = x - y;
    x = y;
  } else {
    diff = y - x;
  }
  // diff is negative.  x is now the larger one.

  if (diff >= kMinLogDiffDouble) {
    double res;
    res = x + Log1p(Exp(diff));
    return res;
  } else {
    return x;  // return the larger one.
  }
}

LogAdd() [2/2]

float kaldi::LogAdd ( float  x, float  y  )

inline

Definition at line 206 of file kaldi-math.h.

References Exp(), and Log1p().

                                      {
  float diff;

  if (x < y) {
    diff = x - y;
    x = y;
  } else {
    diff = y - x;
  }
  // diff is negative.  x is now the larger one.

  if (diff >= kMinLogDiffFloat) {
    float res;
    res = x + Log1p(Exp(diff));
    return res;
  } else {
    return x;  // return the larger one.
  }
}

LogAddOrMax()

static double kaldi::LogAddOrMax ( bool  viterbi, double  a, double  b  )

inlinestatic

Definition at line 444 of file lattice-functions.cc.

References LogAdd().

Referenced by ComputeLatticeAlphasAndBetas().

                                                                   {
  if (viterbi)
    return std::max(a, b);
  else
    return LogAdd(a, b);
}

LogSub() [1/2]

double kaldi::LogSub ( double  x, double  y  )

inline

Definition at line 228 of file kaldi-math.h.

References Exp(), KALDI_ERR, KALDI_ISNAN, kLogZeroDouble, and Log().

Referenced by UnitTestLogAddSub().

                                         {
  if (y >= x) {  // Throws exception if y>=x.
    if (y == x)
      return kLogZeroDouble;
    else
      KALDI_ERR << "Cannot subtract a larger from a smaller number.";
  }

  double diff = y - x;  // Will be negative.
  double res = x + Log(1.0 - Exp(diff));

  // res might be NAN if diff ~0.0, and 1.0-exp(diff) == 0 to machine precision
  if (KALDI_ISNAN(res))
    return kLogZeroDouble;
  return res;
}

LogSub() [2/2]

float kaldi::LogSub ( float  x, float  y  )

inline

Definition at line 247 of file kaldi-math.h.

References Exp(), KALDI_ERR, KALDI_ISNAN, kLogZeroDouble, kLogZeroFloat, and Log().

                                      {
  if (y >= x) {  // Throws exception if y>=x.
    if (y == x)
      return kLogZeroDouble;
    else
      KALDI_ERR << "Cannot subtract a larger from a smaller number.";
  }

  float diff = y - x;  // Will be negative.
  float res = x + Log(1.0f - Exp(diff));

  // res might be NAN if diff ~0.0, and 1.0-exp(diff) == 0 to machine precision
  if (KALDI_ISNAN(res))
    return kLogZeroFloat;
  return res;
}

LongestSentenceLength() [1/2]

int32 LongestSentenceLength

(

const Lattice &

lat

)

This function returns the number of words in the longest sentence in a CompactLattice (i.e.

the the maximum of any path, of the count of olabels on that path).

Definition at line 1452 of file lattice-functions.cc.

References KALDI_ASSERT, KALDI_ERR, and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by LongestSentenceLength(), and SentenceLevelConfidence().

                                                {
  typedef Lattice::Arc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;

  if (lat.Properties(fst::kTopSorted, true) == 0) {
    Lattice lat_copy(lat);
    if (!TopSort(&lat_copy))
      KALDI_ERR << "Was not able to topologically sort lattice (cycles found?)";
    return LongestSentenceLength(lat_copy);
  }
  std::vector<int32> max_length(lat.NumStates(), 0);
  int32 lattice_max_length = 0;
  for (StateId s = 0; s < lat.NumStates(); s++) {
    int32 this_max_length = max_length[s];
    for (fst::ArcIterator<Lattice> aiter(lat, s); !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      bool arc_has_word = (arc.olabel != 0);
      StateId nextstate = arc.nextstate;
      KALDI_ASSERT(static_cast<size_t>(nextstate) < max_length.size());
      if (arc_has_word) {
        // A lattice should ideally not have cycles anyway; a cycle with a word
        // on is something very bad.
        KALDI_ASSERT(nextstate > s && "Lattice has cycles with words on.");
        max_length[nextstate] = std::max(max_length[nextstate],
                                         this_max_length + 1);
      } else {
        max_length[nextstate] = std::max(max_length[nextstate],
                                         this_max_length);
      }
    }
    if (lat.Final(s) != LatticeWeight::Zero())
      lattice_max_length = std::max(lattice_max_length, max_length[s]);
  }
  return lattice_max_length;
}

LongestSentenceLength() [2/2]

int32 LongestSentenceLength

(

const CompactLattice &

lat

)

This function returns the number of words in the longest sentence in a CompactLattice, i.e.

the the maximum of any path, of the count of labels on that path... note, in CompactLattice, the ilabels and olabels are identical because it is an acceptor.

Definition at line 1489 of file lattice-functions.cc.

References KALDI_ASSERT, KALDI_ERR, LongestSentenceLength(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

                                                        {
  typedef CompactLattice::Arc Arc;
  typedef Arc::Label Label;
  typedef Arc::StateId StateId;

  if (clat.Properties(fst::kTopSorted, true) == 0) {
    CompactLattice clat_copy(clat);
    if (!TopSort(&clat_copy))
      KALDI_ERR << "Was not able to topologically sort lattice (cycles found?)";
    return LongestSentenceLength(clat_copy);
  }
  std::vector<int32> max_length(clat.NumStates(), 0);
  int32 lattice_max_length = 0;
  for (StateId s = 0; s < clat.NumStates(); s++) {
    int32 this_max_length = max_length[s];
    for (fst::ArcIterator<CompactLattice> aiter(clat, s);
         !aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      bool arc_has_word = (arc.ilabel != 0); // note: olabel == ilabel.
      // also note: for normal CompactLattice, e.g. as produced by
      // determinization, all arcs will have nonzero labels, but the user might
      // decide to remplace some of the labels with zero for some reason, and we
      // want to support this.
      StateId nextstate = arc.nextstate;
      KALDI_ASSERT(static_cast<size_t>(nextstate) < max_length.size());
      KALDI_ASSERT(nextstate > s && "CompactLattice has cycles");
      if (arc_has_word)
        max_length[nextstate] = std::max(max_length[nextstate],
                                         this_max_length + 1);
      else
        max_length[nextstate] = std::max(max_length[nextstate],
                                         this_max_length);
    }
    if (clat.Final(s) != CompactLatticeWeight::Zero())
      lattice_max_length = std::max(lattice_max_length, max_length[s]);
  }
  return lattice_max_length;
}

MachineIsLittleEndian()

int kaldi::MachineIsLittleEndian ( )

inline

Definition at line 83 of file kaldi-utils.h.

References Sleep().

Referenced by SphinxMatrixHolder< kFeatDim >::Read(), ReadHtk(), SphinxMatrixHolder< kFeatDim >::Write(), WriteHtk(), and WriteSphinx().

                                   {
  int check = 1;
  return (*reinterpret_cast<char*>(&check) != 0);
}

MakeEventPair()

std::pair<EventKeyType, EventValueType> kaldi::MakeEventPair ( EventKeyType  k, EventValueType  v  )

inline

Definition at line 62 of file event-map.h.

References EventTypeToString(), ReadEventType(), and WriteEventType().

Referenced by ShareEventMapLeaves(), and TestShareEventMapLeaves().

                                                                                              {
  return std::pair<EventKeyType, EventValueType>(k, v);
}

MakeLatticeFromLinear()

void kaldi::MakeLatticeFromLinear	(	const std::vector< int32 > &	ali,
		const std::vector< int32 > &	words,
		BaseFloat	lm_cost,
		BaseFloat	ac_cost,
		Lattice *	lat_out
	)

Definition at line 27 of file linear-to-nbest.cc.

References rnnlm::i.

Referenced by main().

                                             {
  typedef LatticeArc::StateId StateId;
  typedef LatticeArc::Weight Weight;
  typedef LatticeArc::Label Label;
  lat_out->DeleteStates();
  StateId cur_state = lat_out->AddState(); // will be 0.
  lat_out->SetStart(cur_state);
  for (size_t i = 0; i < ali.size() || i < words.size(); i++) {
    Label ilabel = (i < ali.size()  ? ali[i] : 0);
    Label olabel = (i < words.size()  ? words[i] : 0);
    StateId next_state = lat_out->AddState();
    lat_out->AddArc(cur_state,
                    LatticeArc(ilabel, olabel, Weight::One(), next_state));
    cur_state = next_state;
  }
  lat_out->SetFinal(cur_state, Weight(lm_cost, ac_cost));
}

MakeTrivialAcceptor()

static fst::VectorFst<fst::StdArc>* kaldi::MakeTrivialAcceptor ( int32  label )

inlinestatic

This utility function, used in GetHTransducer(), creates an FSA (finite state acceptor, i.e.

an FST with ilabels equal to olabels) with a single successful path, with a single label on it.

Definition at line 239 of file hmm-utils.cc.

Referenced by GetHTransducer().

                                                                        {
  typedef fst::StdArc Arc;
  typedef Arc::Weight Weight;
  fst::VectorFst<Arc> *ans = new fst::VectorFst<Arc>;
  ans->AddState();
  ans->AddState();
  ans->SetStart(0);
  ans->SetFinal(1, Weight::One());
  ans->AddArc(0, Arc(label, label, Weight::One(), 1));
  return ans;
}

MapAmDiagGmmUpdate()

void MapAmDiagGmmUpdate	(	const MapDiagGmmOptions &	config,
		const AccumAmDiagGmm &	am_diag_gmm_acc,
		GmmFlagsType	flags,
		AmDiagGmm *	am_gmm,
		BaseFloat *	obj_change_out,
		BaseFloat *	count_out
	)

Maximum A Posteriori update.

Definition at line 237 of file mle-am-diag-gmm.cc.

References AmDiagGmm::Dim(), AccumAmDiagGmm::Dim(), AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), rnnlm::i, KALDI_ASSERT, MapDiagGmmUpdate(), AccumAmDiagGmm::NumAccs(), and AmDiagGmm::NumPdfs().

Referenced by main().

                                               {
  KALDI_ASSERT(am_gmm != NULL && am_diag_gmm_acc.Dim() == am_gmm->Dim() &&
               am_diag_gmm_acc.NumAccs() == am_gmm->NumPdfs());
  if (obj_change_out != NULL) *obj_change_out = 0.0;
  if (count_out != NULL) *count_out = 0.0;
  BaseFloat tmp_obj_change, tmp_count;
  BaseFloat *p_obj = (obj_change_out != NULL) ? &tmp_obj_change : NULL,
      *p_count   = (count_out != NULL) ? &tmp_count : NULL;

  for (int32 i = 0; i < am_diag_gmm_acc.NumAccs(); i++) {
    MapDiagGmmUpdate(config, am_diag_gmm_acc.GetAcc(i), flags,
                     &(am_gmm->GetPdf(i)), p_obj, p_count);

    if (obj_change_out != NULL) *obj_change_out += tmp_obj_change;
    if (count_out != NULL) *count_out += tmp_count;
  }
}

MapCygwinPath()

std::string kaldi::MapCygwinPath

(

const std::string &

filename

)

Definition at line 82 of file kaldi-cygwin-io-inl.h.

References KALDI_ERR, MapCygwinPathNoTmp(), and prefixp().

Referenced by UnitTestNativeFilename().

                                                   {
  // /tmp[/....]
  if (filename != "/tmp" && !prefixp("/tmp/", filename)) {
    return MapCygwinPathNoTmp(filename);
  }
  char *tmpdir = std::getenv("TMP");
  if (tmpdir == nullptr)
    tmpdir = std::getenv("TEMP");
  if (tmpdir == nullptr) {
    KALDI_ERR << "Unable to resolve path '" << filename
              << "' - unable to find temporary directory. Set TMP.";
    return filename;
  }
  // Map the value of tmpdir again, as cygwin environment actually may contain
  // unix-style paths.
  return MapCygwinPathNoTmp(std::string(tmpdir) + filename.substr(4));
}

MapCygwinPathNoTmp()

static std::string kaldi::MapCygwinPathNoTmp ( const std::string &  filename )

static

Definition at line 52 of file kaldi-cygwin-io-inl.h.

References KALDI_ERR, KALDI_WARN, and prefixp().

Referenced by MapCygwinPath().

                                                               {
  // UNC(?), relative, native Windows and empty paths are ok already.
  if (prefixp("//", filename) || !prefixp("/", filename))
    return filename;

  // /dev/...
  if (filename == "/dev/null")
    return "\\\\.\\nul";
  if (prefixp("/dev/", filename)) {
      KALDI_ERR << "Unable to resolve path '" << filename
                << "' - only have /dev/null here.";
      return "\\\\.\\invalid";
  }

  // /cygdrive/?[/....]
  int preflen = cygprefix.size();
  if (prefixp(cygprefix, filename)
      && filename.size() >= preflen + 1 && isalpha(filename[preflen])
      && (filename.size() == preflen + 1 || filename[preflen + 1] == '/')) {
    return std::string() + filename[preflen] + ':' +
       (filename.size() > preflen + 1 ? filename.substr(preflen + 1) : "/");
  }

  KALDI_WARN << "Unable to resolve path '" << filename
             << "' - cannot map unix prefix. "
             << "Will go on, but breakage will likely ensue.";
  return filename;
}

MapDiagGmmUpdate()

void MapDiagGmmUpdate	(	const MapDiagGmmOptions &	config,
		const AccumDiagGmm &	diag_gmm_acc,
		GmmFlagsType	flags,
		DiagGmm *	gmm,
		BaseFloat *	obj_change_out,
		BaseFloat *	count_out
	)

Maximum A Posteriori estimation of the model.

Definition at line 410 of file mle-diag-gmm.cc.

References DiagGmm::ComputeGconsts(), MatrixBase< Real >::CopyRowFromVec(), DiagGmmNormal::CopyToDiagGmm(), DiagGmm::Dim(), AccumDiagGmm::Dim(), AccumDiagGmm::Flags(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, kGmmMeans, kGmmVariances, AccumDiagGmm::mean_accumulator(), MapDiagGmmOptions::mean_tau, DiagGmmNormal::means_, MlObjective(), DiagGmm::NumGauss(), AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), AccumDiagGmm::variance_accumulator(), MapDiagGmmOptions::variance_tau, DiagGmmNormal::vars_, MapDiagGmmOptions::weight_tau, and DiagGmmNormal::weights_.

Referenced by MapAmDiagGmmUpdate(), and AccumDiagGmm::Resize().

                                            {
  KALDI_ASSERT(gmm != NULL);

  if (flags & ~diag_gmm_acc.Flags())
    KALDI_ERR << "Flags in argument do not match the active accumulators";

  KALDI_ASSERT(diag_gmm_acc.NumGauss() == gmm->NumGauss() &&
               diag_gmm_acc.Dim() == gmm->Dim());

  int32 num_gauss = gmm->NumGauss();
  double occ_sum = diag_gmm_acc.occupancy().Sum();

  // remember the old objective function value
  gmm->ComputeGconsts();
  BaseFloat obj_old = MlObjective(*gmm, diag_gmm_acc);

  // allocate the gmm in normal representation; all parameters of this will be
  // updated, but only the flagged ones will be transferred back to gmm
  DiagGmmNormal ngmm(*gmm);

  for (int32 i = 0; i < num_gauss; i++) {
    double occ = diag_gmm_acc.occupancy()(i);

    // First update the weight.  The weight_tau is a tau for the
    // whole state.
    ngmm.weights_(i) = (occ + ngmm.weights_(i) * config.weight_tau) /
        (occ_sum + config.weight_tau);


    if (occ > 0.0 && (flags & kGmmMeans)) {
      // Update the Gaussian mean.
      Vector<double> old_mean(ngmm.means_.Row(i));
      Vector<double> mean(diag_gmm_acc.mean_accumulator().Row(i));
      mean.Scale(1.0 / (occ + config.mean_tau));
      mean.AddVec(config.mean_tau / (occ + config.mean_tau), old_mean);
      ngmm.means_.CopyRowFromVec(mean, i);
    }

    if (occ > 0.0 && (flags & kGmmVariances)) {
      // Computing the variance around the updated mean; this is:
      // E( (x - mu)^2 ) = E( x^2 - 2 x mu + mu^2 ) =
      // E(x^2) + mu^2 - 2 mu E(x).
      Vector<double> old_var(ngmm.vars_.Row(i));
      Vector<double> var(diag_gmm_acc.variance_accumulator().Row(i));
      var.Scale(1.0 / occ);
      var.AddVec2(1.0, ngmm.means_.Row(i));
      SubVector<double> mean_acc(diag_gmm_acc.mean_accumulator(), i),
          mean(ngmm.means_, i);
      var.AddVecVec(-2.0 / occ, mean_acc, mean, 1.0);
      // now var is E(x^2) + m^2 - 2 mu E(x).
      // Next we do the appropriate weighting usnig the tau value.
      var.Scale(occ / (config.variance_tau + occ));
      var.AddVec(config.variance_tau / (config.variance_tau + occ), old_var);
      // Now write to the model.
      ngmm.vars_.Row(i).CopyFromVec(var);
    }
  }

  // Copy to natural/exponential representation.
  ngmm.CopyToDiagGmm(gmm, flags);

  gmm->ComputeGconsts();  // or MlObjective will fail.
  BaseFloat obj_new = MlObjective(*gmm, diag_gmm_acc);

  if (obj_change_out)
    *obj_change_out = (obj_new - obj_old);

  if (count_out) *count_out = occ_sum;
}

MapPhone()

static int32 kaldi::MapPhone ( const std::vector< int32 > &  phone_map, int32  phone  )

static

Definition at line 26 of file tree-accu.cc.

References KALDI_ERR.

Referenced by AccumulateTreeStats().

                                   {
  if (phone == 0 || phone_map.empty()) return phone;
  else if (phone < 0 || phone >= phone_map.size()) {
    KALDI_ERR << "Out-of-range phone " << phone << " bad --phone-map option?";
  }
  return phone_map[phone];
}

MapSymbols()

static void kaldi::MapSymbols ( const WordAlignLatticeLexiconInfo &  lexicon_info, CompactLattice *  lat  )

static

Testing code; map word symbols in the lattice "lat" using the equivalence-classes obtained from the lexicon, using the function EquivalenceClassOf in the lexicon_info object.

Definition at line 912 of file word-align-lattice-lexicon.cc.

References WordAlignLatticeLexiconInfo::EquivalenceClassOf(), and KALDI_ASSERT.

Referenced by TestWordAlignedLattice().

                                            {
  typedef CompactLattice::StateId StateId;
  for (StateId s = 0; s < lat->NumStates(); s++) {
    for (fst::MutableArcIterator<CompactLattice> aiter(lat, s);
         !aiter.Done(); aiter.Next()) {
      CompactLatticeArc arc (aiter.Value());
      KALDI_ASSERT(arc.ilabel == arc.olabel);
      arc.ilabel = lexicon_info.EquivalenceClassOf(arc.ilabel);
      arc.olabel = arc.ilabel;
      aiter.SetValue(arc);
    }
  }
}

MatrixUnitSpeedTest()

static void kaldi::MatrixUnitSpeedTest ( )

static

Definition at line 257 of file matrix-lib-speed-test.cc.

                                                          {
  UnitTestRealFftSpeed<Real>();
  UnitTestSplitRadixRealFftSpeed<Real>();
  UnitTestSvdSpeed<Real>();
  UnitTestAddMatMatSpeed<Real>();
  UnitTestAddRowSumMatSpeed<Real>();
  UnitTestAddColSumMatSpeed<Real>();
  UnitTestAddVecToRowsSpeed<Real>();
  UnitTestAddVecToColsSpeed<Real>();
}

MatrixUnitTest()

static void kaldi::MatrixUnitTest ( bool  full_test )

static

Definition at line 4592 of file matrix-lib-test.cc.

References KALDI_LOG, and UnitTestAddVecCross().

                                                                   {
  UnitTestLinearCgd<Real>();
  UnitTestGeneralMatrix<BaseFloat>();
  UnitTestTridiagonalize<Real>();
  UnitTestTridiagonalizeAndQr<Real>();
  UnitTestAddMatSmat<Real>();
  UnitTestFloorChol<Real>();
  UnitTestFloorUnit<Real>();
  UnitTestAddMat2Sp<Real>();
  UnitTestLbfgs<Real>();
  // UnitTestSvdBad<Real>(); // test bug in Jama SVD code.
  UnitTestCompressedMatrix<Real>();
  UnitTestCompressedMatrix2<Real>();
  UnitTestExtractCompressedMatrix<Real>();
  UnitTestResize<Real>();
  UnitTestResizeCopyDataDifferentStrideType<Real>();
  UnitTestNonsymmetricPower<Real>();
  UnitTestEigSymmetric<Real>();
  KALDI_LOG << " Point A";
  UnitTestComplexPower<Real>();
  UnitTestEig<Real>();
  UnitTestEigSp<Real>();
  // commenting these out for now-- they test the speed, but take a while.
  // UnitTestSplitRadixRealFftSpeed<Real>();
  // UnitTestRealFftSpeed<Real>();   // won't exit!/
  UnitTestComplexFt<Real>();
  KALDI_LOG << " Point B";
  UnitTestComplexFft2<Real>();
  UnitTestComplexFft<Real>();
  UnitTestSplitRadixComplexFft<Real>();
  UnitTestSplitRadixComplexFft2<Real>();
  UnitTestDct<Real>();
  UnitTestRealFft<Real>();
  KALDI_LOG << " Point C";
  UnitTestSplitRadixRealFft<Real>();
  UnitTestSvd<Real>();
  UnitTestSvdNodestroy<Real>();
  UnitTestSvdJustvec<Real>();
  UnitTestSpAddDiagVec<Real, float>();
  UnitTestSpAddDiagVec<Real, double>();
  UnitTestSpAddVecVec<Real>();
  UnitTestSpInvert<Real>();
  KALDI_LOG << " Point D";
  UnitTestTpInvert<Real>();
  UnitTestIo<Real>();
  UnitTestIoCross<Real>();
  UnitTestHtkIo<Real>();
  UnitTestScale<Real>();
  UnitTestTrace<Real>();
  KALDI_LOG << " Point E";
  CholeskyUnitTestTr<Real>();
  UnitTestAxpy<Real>();
  UnitTestSimple<Real>();
  UnitTestMmul<Real>();
  UnitTestMmulSym<Real>();
  UnitTestVecmul<Real>();
  UnitTestInverse<Real>();
  UnitTestMulElements<Real>();
  UnitTestDotprod<Real>();
  // UnitTestSvdVariants<Real>();
  UnitTestPower<Real>();
  UnitTestPowerAbs<Real>();
  UnitTestHeaviside<Real>();
  UnitTestCopySp<Real>();
  UnitTestDeterminant<Real>();
  KALDI_LOG << " Point F";
  UnitTestDeterminantSign<Real>();
  UnitTestSger<Real>();
  UnitTestAddOuterProductPlusMinus<Real>();
  UnitTestTraceProduct<Real>();
  UnitTestTransposeScatter<Real>();
  UnitTestRankNUpdate<Real>();
  UnitTestSpVec<Real>();
  UnitTestLimitCondInvert<Real>();
  KALDI_LOG << " Point G";
  UnitTestLimitCond<Real>();
  UnitTestMat2Vec<Real>();
  UnitTestFloorCeiling<Real>();
  KALDI_LOG << " Point H";
  UnitTestCopyRowsAndCols<Real>();
  UnitTestSpliceRows<Real>();
  UnitTestAddSp<Real>();
  UnitTestRemoveRow<Real>();
  UnitTestRow<Real>();
  UnitTestSubvector<Real>();
  UnitTestRange<Real>();
  UnitTestSimpleForVec<Real>();
  UnitTestSetRandn<Real>();
  UnitTestSetRandUniform<Real>();
  UnitTestVectorMax<Real>();
  UnitTestVectorMin<Real>();
  UnitTestSimpleForMat<Real>();
  UnitTestTanh<Real>();
  UnitTestSigmoid<Real>();
  UnitTestSoftHinge<Real>();
  UnitTestNorm<Real>();
  UnitTestCopyCols<Real>();
  UnitTestCopyRows<Real>();
  UnitTestCopyToRows<Real>();
  UnitTestAddRows<Real>();
  UnitTestAddToRows<Real>();
  UnitTestMul<Real>();
  KALDI_LOG << " Point I";
  UnitTestSolve<Real>();
  UnitTestAddMat2<Real>();
  UnitTestSymAddMat2<Real>();
  UnitTestAddMatSelf<Real>();
  UnitTestMaxMin<Real>();
  UnitTestInnerProd<Real>();
  UnitTestApplyExpSpecial<Real>();
  UnitTestScaleDiag<Real>();
  UnitTestSetDiag<Real>();
  UnitTestSetRandn<Real>();
  KALDI_LOG << " Point J";
  UnitTestTraceSpSpLower<Real>();
  UnitTestTranspose<Real>();
  UnitTestAddVec2Sp<Real>();
  UnitTestAddVecToRows<Real>();
  UnitTestAddVecToCols<Real>();
  UnitTestAddVecCross();
  UnitTestTp2Sp<Real>();
  UnitTestTp2<Real>();
  UnitTestAddDiagMat2<Real>();
  UnitTestAddDiagMatMat<Real>();
 //  UnitTestOrthogonalizeRows<Real>();
  UnitTestTopEigs<Real>();
  UnitTestRandCategorical<Real>();
  UnitTestTridiag<Real>();
  UnitTestTridiag<Real>();
  //  SlowMatMul<Real>();
  UnitTestAddDiagVecMat<Real>();
  UnitTestAddMatDiagVec<Real>();
  UnitTestAddMatMatElements<Real>();
  UnitTestAddMatMatNans<Real>();
  UnitTestAddToDiagMatrix<Real>();
  UnitTestAddToDiag<Real>();
  UnitTestMaxAbsEig<Real>();
  UnitTestMax2<Real>();
  UnitTestPca<Real>(full_test);
  UnitTestPca2<Real>(full_test);
  UnitTestAddVecVec<Real>();
  UnitTestReplaceValue<Real>();
  // The next one is slow.  The upshot is that Eig is up to ten times faster
  // than SVD.
  // UnitTestSvdSpeed<Real>();
  KALDI_LOG << " Point K";
  UnitTestTriVecSolver<Real>();
}

MaxAbsolute()

BaseFloat kaldi::MaxAbsolute

(

const Vector< BaseFloat > &

vector

)

Definition at line 52 of file wav-reverberate.cc.

References VectorBase< Real >::Max(), and VectorBase< Real >::Min().

                                                       {
  return std::max(std::abs(vector.Max()), std::abs(vector.Min()));
}

MaybeDoSanityCheck() [1/2]

void MaybeDoSanityCheck

(

const KwsLexicographicFst &

index_transducer

)

Definition at line 325 of file kws-functions.cc.

References DifferenceWrapper(), fst::GetLinearSymbolSequence(), GetVerboseLevel(), rnnlm::i, KALDI_VLOG, and KALDI_WARN.

Referenced by DoFactorMerging(), main(), and MaybeDoSanityCheck().

                                                                     {
  typedef KwsLexicographicFst::Arc::Label Label;
  if (GetVerboseLevel() < 2) return;
  KwsLexicographicFst temp_transducer;
  ShortestPath(index_transducer, &temp_transducer);
  std::vector<Label> isymbols, osymbols;
  KwsLexicographicWeight weight;
  GetLinearSymbolSequence(temp_transducer, &isymbols, &osymbols, &weight);
  std::ostringstream os;
  for (size_t i = 0; i < isymbols.size(); i++)
    os << isymbols[i] << ' ';
  BaseFloat best_cost = weight.Value1().Value();
  KALDI_VLOG(3) << "Best path: " << isymbols.size() << " isymbols " << ", "
                << osymbols.size() << " osymbols, isymbols are " << os.str()
                << ", best cost is " << best_cost;

  // Now get second-best path.  This will exclude the best path, which
  // will generally correspond to the empty word sequence (there will
  // be isymbols and osymbols anyway though, because of the utterance-id
  // having been encoded as an osymbol (and later, the EncodeFst turning it
  // into a transducer).
  KwsLexicographicFst difference_transducer;
  DifferenceWrapper(index_transducer, temp_transducer, &difference_transducer);
  ShortestPath(difference_transducer, &temp_transducer);

  GetLinearSymbolSequence(temp_transducer, &isymbols, &osymbols, &weight);
  std::ostringstream os2;
  for (size_t i = 0; i < isymbols.size(); i++)
    os2 << isymbols[i] << ' ';
  BaseFloat second_best_cost = weight.Value1().Value();
  KALDI_VLOG(3) << "Second-best path: " << isymbols.size()
                << " isymbols " << ", "
                << osymbols.size() << " osymbols, isymbols are " << os2.str()
                << ", second-best cost is " << second_best_cost;
  if (second_best_cost < -0.01) {
    KALDI_WARN << "Negative second-best cost found " << second_best_cost;
  }
}

MaybeDoSanityCheck() [2/2]

void MaybeDoSanityCheck

(

const KwsProductFst &

product_transducer

)

Definition at line 365 of file kws-functions.cc.

References GetVerboseLevel(), and MaybeDoSanityCheck().

                                                                 {
  if (GetVerboseLevel() < 2) return;