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;
  KwsLexicographicFst index_transducer;

  Map(product_transducer,
      &index_transducer,
      KwsProductFstToKwsLexicographicFstMapper());

  MaybeDoSanityCheck(index_transducer);
}

MeanVariance() [1/2]

std::string kaldi::MeanVariance

(

const CuMatrixBase< Real > &

m

)

Definition at line 49 of file cu-rand-speed-test.cc.

References CuMatrixBase< Real >::Add(), CuMatrixBase< Real >::ApplyPow(), CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), CuMatrixBase< Real >::Sum(), and ToString().

Referenced by CuRandGaussianMatrixBaseSpeedTest(), CuRandGaussianMatrixSpeedTest(), CuRandGaussianVectorSpeedTest(), CuRandUniformMatrixBaseSpeedTest(), CuRandUniformMatrixSpeedTest(), and CuRandUniformVectorSpeedTest().

                                                    {
  std::ostringstream os;
  Real mean = m.Sum() / (m.NumRows()*m.NumCols());
  CuMatrix<Real> tmp(m);
  tmp.Add(-mean);
  tmp.ApplyPow(2.0);
  Real var = tmp.Sum() / (tmp.NumRows()*tmp.NumCols());
  return std::string("mean ") + ToString(mean) + ", std-dev " + ToString(std::sqrt(var));
}

MeanVariance() [2/2]

std::string kaldi::MeanVariance

(

const CuVectorBase< Real > &

v

)

Definition at line 60 of file cu-rand-speed-test.cc.

References CuVectorBase< Real >::Add(), CuVectorBase< Real >::ApplyPow(), CuVectorBase< Real >::Dim(), CuVectorBase< Real >::Sum(), and ToString().

                                                    {
  std::ostringstream os;
  Real mean = v.Sum() / v.Dim();
  CuVector<Real> tmp(v);
  tmp.Add(-mean);
  tmp.ApplyPow(2.0);
  Real var = tmp.Sum() / tmp.Dim();
  return std::string("mean ") + ToString(mean) + ", std-dev " + ToString(std::sqrt(var));
}

MergeFullGmm()

void kaldi::MergeFullGmm	(	const FullGmm &	src,
		FullGmm *	dst
	)

merges GMMs by appending Gaussians in "src" to "dst".

Renormalizes weights by allocating weight proportional to #Gauss.

Definition at line 28 of file fgmm-global-merge.cc.

References FullGmm::ComputeGconsts(), FullGmm::CopyFromFullGmm(), FullGmm::Dim(), rnnlm::i, FullGmm::inv_covars(), KALDI_ASSERT, FullGmm::means_invcovars(), FullGmm::NumGauss(), VectorBase< Real >::Range(), MatrixBase< Real >::Range(), FullGmm::Resize(), FullGmm::SetInvCovarsAndMeansInvCovars(), FullGmm::SetWeights(), and FullGmm::weights().

Referenced by main().

                                                    {
  FullGmm dst_copy;
  dst_copy.CopyFromFullGmm(*dst);
  KALDI_ASSERT(src.NumGauss() != 0 && dst_copy.NumGauss()  != 0
               && src.Dim() == dst_copy.Dim());
  int32 src_num_mix = src.NumGauss(), dst_num_mix = dst_copy.NumGauss(),
      num_mix = src_num_mix + dst_num_mix, dim = src.Dim();
  dst->Resize(num_mix, dim);

  std::vector<SpMatrix<BaseFloat> > invcovars(num_mix);
  for(int32 i = 0; i < dst_num_mix; i++) {
    invcovars[i].Resize(dim);
    invcovars[i].CopyFromSp(dst_copy.inv_covars()[i]);
  }
  for(int32 i = 0; i < src_num_mix; i++) {
    invcovars[i+dst_num_mix].Resize(dim);
    invcovars[i+dst_num_mix].CopyFromSp(src.inv_covars()[i]);
  }
  Matrix<BaseFloat> means_invcovars(num_mix, dim);
  means_invcovars.Range(0, dst_num_mix, 0, dim).CopyFromMat(dst_copy.means_invcovars());
  means_invcovars.Range(dst_num_mix, src_num_mix, 0, dim).CopyFromMat(src.means_invcovars());
  dst->SetInvCovarsAndMeansInvCovars(invcovars, means_invcovars);

  Vector<BaseFloat> weights(num_mix); // initialized to zero.
  // weight proportional to #Gaussians, so that if we combine a number of
  // models with same #Gaussians, they all get the same weight.
  BaseFloat src_weight = src_num_mix / static_cast<BaseFloat>(num_mix),
      dst_weight = dst_num_mix / static_cast<BaseFloat>(num_mix);
  weights.Range(0, dst_num_mix).AddVec(dst_weight, dst_copy.weights());
  weights.Range(dst_num_mix, src_num_mix).AddVec(src_weight, src.weights());
  dst->SetWeights(weights);
  dst->ComputeGconsts();
}

MergePairVectorSumming()

void kaldi::MergePairVectorSumming ( std::vector< std::pair< I, F > > *  vec )

inline

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.

This is for where the vector of pairs represents a map from the integer to float component, with an "adding" type of semantics for combining the elements.

Definition at line 288 of file stl-utils.h.

References KALDI_ASSERT_IS_INTEGER_TYPE.

Referenced by LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), MergePosteriors(), TestMergePairVectorSumming(), and OnlineIvectorFeature::UpdateStatsForFrames().

                                                                   {
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  CompareFirstMemberOfPair<I, F> c;
  std::sort(vec->begin(), vec->end(), c);  // sort on 1st element.
  typename std::vector<std::pair<I, F> >::iterator out = vec->begin(),
      in = vec->begin(), end = vec->end();
  // special case: while there is nothing to be changed, skip over
  // initial input (avoids unnecessary copying).
  while (in + 1 < end && in[0].first != in[1].first && in[0].second != 0.0) {
    in++;
    out++;
  }
  while (in < end) {
    // We reach this point only at the first element of
    // each stretch of identical .first elements.
    *out = *in;
    ++in;
    while (in < end && in->first == out->first) {
      out->second += in->second;  // this is the merge operation.
      ++in;
    }
    if (out->second != static_cast<F>(0))  // Don't keep zero elements.
      out++;
  }
  vec->erase(out, end);
}

MleAmDiagGmmUpdate()

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.

Definition at line 187 of file mle-am-diag-gmm.cc.

References count, AmDiagGmm::Dim(), AccumAmDiagGmm::Dim(), AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, KALDI_WARN, MleDiagGmmOptions::min_gaussian_occupancy, MleDiagGmmUpdate(), AccumAmDiagGmm::NumAccs(), AmDiagGmm::NumGauss(), AmDiagGmm::NumPdfs(), MleDiagGmmOptions::remove_low_count_gaussians, and ResizeModel().

Referenced by main(), TestAmDiagGmmAccsIO(), and UnitTestRegtreeFmllrDiagGmm().

                                               {
  if (am_diag_gmm_acc.Dim() != am_gmm->Dim()) {
    KALDI_ASSERT(am_diag_gmm_acc.Dim() != 0);
    KALDI_WARN << "Dimensions of accumulator " << am_diag_gmm_acc.Dim()
               << " and gmm " << am_gmm->Dim() << " do not match, resizing "
               << " GMM and setting to zero-mean, unit-variance.";
    ResizeModel(am_diag_gmm_acc.Dim(), am_gmm);
  }
  
  KALDI_ASSERT(am_gmm != NULL);
  KALDI_ASSERT(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 tot_obj_change = 0.0, tot_count = 0.0;
  int32 tot_elems_floored = 0, tot_gauss_floored = 0,
      tot_gauss_removed = 0;
  for (int32 i = 0; i < am_diag_gmm_acc.NumAccs(); i++) {
    BaseFloat obj_change, count;
    int32 elems_floored, gauss_floored, gauss_removed;
    
    MleDiagGmmUpdate(config, am_diag_gmm_acc.GetAcc(i), flags,
                     &(am_gmm->GetPdf(i)),
                     &obj_change, &count, &elems_floored,
                     &gauss_floored, &gauss_removed);
    tot_obj_change += obj_change;
    tot_count += count;
    tot_elems_floored += elems_floored;
    tot_gauss_floored += gauss_floored;
    tot_gauss_removed += gauss_removed;
  }
  if (obj_change_out != NULL) *obj_change_out = tot_obj_change;
  if (count_out != NULL) *count_out = tot_count;
  KALDI_LOG << tot_elems_floored << " variance elements floored in "
            << tot_gauss_floored << " Gaussians, out of "
            <<  am_gmm->NumGauss();
  if (config.remove_low_count_gaussians) {
    KALDI_LOG << "Removed " << tot_gauss_removed
              << " Gaussians due to counts < --min-gaussian-occupancy="
              <<  config.min_gaussian_occupancy
              << " and --remove-low-count-gaussians=true";
  }
}

MleDiagGmmUpdate()

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.

Update using the DiagGmm: exponential form. Sets, does not increment, objf_change_out, floored_elements_out and floored_gauss_out.

Definition at line 275 of file mle-diag-gmm.cc.

References DiagGmm::ComputeGconsts(), MatrixBase< Real >::CopyRowFromVec(), DiagGmmNormal::CopyToDiagGmm(), VectorBase< Real >::Dim(), DiagGmm::Dim(), AccumDiagGmm::Dim(), AccumDiagGmm::Flags(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_VLOG, KALDI_WARN, kGmmMeans, kGmmVariances, AccumDiagGmm::mean_accumulator(), DiagGmmNormal::means_, MleDiagGmmOptions::min_gaussian_occupancy, MleDiagGmmOptions::min_gaussian_weight, MleDiagGmmOptions::min_variance, MlObjective(), DiagGmm::NumGauss(), AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy(), MleDiagGmmOptions::remove_low_count_gaussians, DiagGmm::RemoveComponents(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), AccumDiagGmm::variance_accumulator(), MleDiagGmmOptions::variance_floor_vector, DiagGmmNormal::vars_, and DiagGmmNormal::weights_.

Referenced by main(), MleAmDiagGmmUpdate(), AccumDiagGmm::Resize(), test_flags_driven_update(), test_io(), TestComponentAcc(), TrainOneIter(), UnitTestDiagGmmGenerate(), and UnitTestEstimateDiagGmm().

                                                    {
  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();

  int32 elements_floored = 0, gauss_floored = 0;

  // remember old objective value
  gmm->ComputeGconsts();
  BaseFloat obj_old = MlObjective(*gmm, diag_gmm_acc);

  // First get the gmm in "normal" representation (not the exponential-model
  // form).
  DiagGmmNormal ngmm(*gmm);

  std::vector<int32> to_remove;
  for (int32 i = 0; i < num_gauss; i++) {
    double occ = diag_gmm_acc.occupancy()(i);
    double prob;
    if (occ_sum > 0.0)
      prob = occ / occ_sum;
    else
      prob = 1.0 / num_gauss;

    if (occ > static_cast<double>(config.min_gaussian_occupancy)
        && prob > static_cast<double>(config.min_gaussian_weight)) {

      ngmm.weights_(i) = prob;

      // copy old mean for later normalizations
      Vector<double> old_mean(ngmm.means_.Row(i));

      // update mean, then variance, as far as there are accumulators
      if (diag_gmm_acc.Flags() & (kGmmMeans|kGmmVariances)) {
        Vector<double> mean(diag_gmm_acc.mean_accumulator().Row(i));
        mean.Scale(1.0 / occ);
        // transfer to estimate
        ngmm.means_.CopyRowFromVec(mean, i);
      }

      if (diag_gmm_acc.Flags() & kGmmVariances) {
        KALDI_ASSERT(diag_gmm_acc.Flags() & kGmmMeans);
        Vector<double> var(diag_gmm_acc.variance_accumulator().Row(i));
        var.Scale(1.0 / occ);
        var.AddVec2(-1.0, ngmm.means_.Row(i));  // subtract squared means.

        // if we intend to only update the variances, we need to compensate by
        // adding the difference between the new and old mean
        if (!(flags & kGmmMeans)) {
          old_mean.AddVec(-1.0, ngmm.means_.Row(i));
          var.AddVec2(1.0, old_mean);
        }
        int32 floored;
        if (config.variance_floor_vector.Dim() != 0) {
          floored = var.ApplyFloor(config.variance_floor_vector);
        } else {
          var.ApplyFloor(config.min_variance, &floored);
        }
        if (floored != 0) {
          elements_floored += floored;
          gauss_floored++;
        }
        // transfer to estimate
        ngmm.vars_.CopyRowFromVec(var, i);
      }
    } else {  // Insufficient occupancy.
      if (config.remove_low_count_gaussians &&
          static_cast<int32>(to_remove.size()) < num_gauss-1) {
        // remove the component, unless it is the last one.
        KALDI_WARN << "Too little data - removing Gaussian (weight "
                   << std::fixed << prob
                   << ", occupation count " << std::fixed << diag_gmm_acc.occupancy()(i)
                   << ", vector size " << gmm->Dim() << ")";
        to_remove.push_back(i);
      } else {
        KALDI_WARN << "Gaussian has too little data but not removing it because"
                   << (config.remove_low_count_gaussians ?
                       " it is the last Gaussian: i = "
                       : " remove-low-count-gaussians == false: g = ") << i
                   << ", occ = " << diag_gmm_acc.occupancy()(i) << ", weight = " << prob;
        ngmm.weights_(i) =
            std::max(prob, static_cast<double>(config.min_gaussian_weight));
      }
    }
  }

  // copy to natural representation according to flags
  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;
  if (floored_elements_out) *floored_elements_out = elements_floored;
  if (floored_gaussians_out) *floored_gaussians_out = gauss_floored;

  if (to_remove.size() > 0) {
    gmm->RemoveComponents(to_remove, true /*renormalize weights*/);
    gmm->ComputeGconsts();
  }
  if (removed_gaussians_out != NULL) *removed_gaussians_out = to_remove.size();

  if (gauss_floored > 0)
    KALDI_VLOG(2) << gauss_floored << " variances floored in " << gauss_floored
                  << " Gaussians.";
}

MleFullGmmUpdate()

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.

Update using the FullGmm exponential form

Definition at line 282 of file mle-full-gmm.cc.

References FullGmm::ComputeGconsts(), MatrixBase< Real >::CopyRowFromVec(), FullGmmNormal::CopyToFullGmm(), AccumFullGmm::covariance_accumulator(), FullGmm::Dim(), AccumFullGmm::Flags(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_WARN, kGmmMeans, kGmmVariances, MleFullGmmOptions::max_condition, AccumFullGmm::mean_accumulator(), FullGmmNormal::means_, MleFullGmmOptions::min_gaussian_occupancy, MleFullGmmOptions::min_gaussian_weight, MlObjective(), FullGmm::NumGauss(), AccumFullGmm::occupancy(), MleFullGmmOptions::remove_low_count_gaussians, FullGmm::RemoveComponents(), MatrixBase< Real >::Row(), PackedMatrix< Real >::Scale(), VectorBase< Real >::Scale(), VectorBase< Real >::Sum(), MleFullGmmOptions::variance_floor, FullGmmNormal::vars_, and FullGmmNormal::weights_.

Referenced by main(), AccumFullGmm::Resize(), test_flags_driven_update(), test_io(), TestComponentAcc(), UnitTestEstimateFullGmm(), and UnitTestFullGmmEst().

                                            {
  KALDI_ASSERT(gmm != NULL);
  
  if (flags & ~fullgmm_acc.Flags())
    KALDI_ERR << "Flags in argument do not match the active accumulators";

  gmm->ComputeGconsts();
  BaseFloat obj_old = MlObjective(*gmm, fullgmm_acc);

  // Korbinian: I removed checks that validate if the referenced gmm matches
  // the accumulator, as this should be responsibility of the caller.
  // Furthermore, the re-estimation of the normal representation is done 
  // regardless of the flags, but the transfer to the natural form is
  // done with respect to the flags.

  int32 num_gauss = gmm->NumGauss();
  double occ_sum = fullgmm_acc.occupancy().Sum();

  int32 tot_floored = 0, gauss_floored = 0;

  // allocate the gmm in normal representation
  FullGmmNormal ngmm(*gmm);

  std::vector<int32> to_remove;
  for (int32 i = 0; i < num_gauss; i++) {
    double occ = fullgmm_acc.occupancy()(i);
    double prob;
    if (occ_sum > 0.0)
      prob = occ / occ_sum;
    else
      prob = 1.0 / num_gauss;
    
    if (occ > static_cast<double> (config.min_gaussian_occupancy)
        && prob > static_cast<double> (config.min_gaussian_weight)) {
      
      ngmm.weights_(i) = prob;

      // copy old mean for later normalizations
      Vector<double> oldmean(ngmm.means_.Row(i));

      // update mean, then variance, as far as there are accumulators
      if (fullgmm_acc.Flags() & (kGmmMeans|kGmmVariances)) {
        Vector<double> mean(fullgmm_acc.mean_accumulator().Row(i));
        mean.Scale(1.0 / occ);

        // transfer to estimate
        ngmm.means_.CopyRowFromVec(mean, i);
      }

      if (fullgmm_acc.Flags() & kGmmVariances) {
        KALDI_ASSERT(fullgmm_acc.Flags() & kGmmMeans);
        SpMatrix<double> covar(fullgmm_acc.covariance_accumulator()[i]);
        covar.Scale(1.0 / occ);
        covar.AddVec2(-1.0, ngmm.means_.Row(i));  // subtract squared means.
        // if we intend to only update the variances, we need to compensate by 
        // adding the difference between the new and old mean
        if (!(flags & kGmmMeans)) {
          oldmean.AddVec(-1.0, ngmm.means_.Row(i));
          covar.AddVec2(1.0, oldmean);
        }

        // Now flooring etc. of variance's eigenvalues.
        BaseFloat floor = std::max(static_cast<double>(config.variance_floor),
                                   covar.MaxAbsEig() / config.max_condition);
        
        int32 floored = covar.ApplyFloor(floor);

        if (floored) {
          tot_floored += floored;
          gauss_floored++;
        }

        // transfer to estimate
        ngmm.vars_[i].CopyFromSp(covar);
      }
    } else {  // Insufficient occupancy
      if (config.remove_low_count_gaussians &&
            static_cast<int32>(to_remove.size()) < num_gauss-1) {
        KALDI_WARN << "Too little data - removing Gaussian (weight "
                   << std::fixed << prob
                   << ", occupation count " << std::fixed << fullgmm_acc.occupancy()(i)
                   << ", vector size " << gmm->Dim() << ")";
        to_remove.push_back(i);
      } else {
        KALDI_WARN << "Gaussian has too little data but not removing it because"
                   << (config.remove_low_count_gaussians ?
                       " it is the last Gaussian: i = "
                       : " remove-low-count-gaussians == false: i = ") << i
                   << ", occ = " << fullgmm_acc.occupancy()(i) << ", weight = " << prob;
        ngmm.weights_(i) =
            std::max(prob, static_cast<double>(config.min_gaussian_weight));
      }
    }
  }

  // copy to natural representation according to flags
  ngmm.CopyToFullGmm(gmm, flags);

  gmm->ComputeGconsts();
  BaseFloat obj_new = MlObjective(*gmm, fullgmm_acc);
  
  if (obj_change_out)
    *obj_change_out = obj_new - obj_old;
  
  if (count_out) 
    *count_out = occ_sum;

  if (to_remove.size() > 0) {
    gmm->RemoveComponents(to_remove, true /* renorm weights */);
    gmm->ComputeGconsts();
  }
  
  if (tot_floored > 0)
    KALDI_WARN << tot_floored << " variances floored in " << gauss_floored
               << " Gaussians.";

}

MllrAuxFunction()

static BaseFloat kaldi::MllrAuxFunction ( const Matrix< BaseFloat > &  xform, const AffineXformStats &  stats  )

static

Definition at line 308 of file regtree-mllr-diag-gmm.cc.

References VectorBase< Real >::AddSpVec(), rnnlm::d, AffineXformStats::G_, AffineXformStats::K_, kTrans, MatrixBase< Real >::Row(), TraceMatMat(), and VecVec().

Referenced by RegtreeMllrDiagGmmAccs::Update().

                                                                {
  int32 dim = 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 = 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;
}

MlObjective() [1/2]

BaseFloat MlObjective	(	const DiagGmm &	gmm,
		const AccumDiagGmm &	diag_gmm_acc
	)

Calc using the DiagGMM exponential form.

Definition at line 261 of file mle-diag-gmm.cc.

References AccumDiagGmm::Flags(), DiagGmm::gconsts(), DiagGmm::inv_vars(), kGmmMeans, kGmmVariances, kTrans, AccumDiagGmm::mean_accumulator(), DiagGmm::means_invvars(), AccumDiagGmm::occupancy(), TraceMatMat(), AccumDiagGmm::variance_accumulator(), and VecVec().

Referenced by MapDiagGmmUpdate(), MleDiagGmmUpdate(), MleFullGmmUpdate(), AccumFullGmm::Resize(), and AccumDiagGmm::Resize().

                                                        {
  GmmFlagsType acc_flags = diag_gmm_acc.Flags();
  Vector<BaseFloat> occ_bf(diag_gmm_acc.occupancy());
  Matrix<BaseFloat> mean_accs_bf(diag_gmm_acc.mean_accumulator());
  Matrix<BaseFloat> variance_accs_bf(diag_gmm_acc.variance_accumulator());
  BaseFloat obj = VecVec(occ_bf, gmm.gconsts());
  if (acc_flags & kGmmMeans)
    obj += TraceMatMat(mean_accs_bf, gmm.means_invvars(), kTrans);
  if (acc_flags & kGmmVariances)
    obj -= 0.5 * TraceMatMat(variance_accs_bf, gmm.inv_vars(), kTrans);
  return obj;
}

MlObjective() [2/2]

BaseFloat MlObjective	(	const FullGmm &	gmm,
		const AccumFullGmm &	fullgmm_acc
	)

Calc using the DiagGMM exponential form.

Definition at line 261 of file mle-full-gmm.cc.

References AccumFullGmm::covariance_accumulator(), FullGmm::Dim(), AccumFullGmm::Flags(), FullGmm::gconsts(), rnnlm::i, FullGmm::inv_covars(), kGmmMeans, kGmmVariances, kTrans, AccumFullGmm::mean_accumulator(), FullGmm::means_invcovars(), FullGmm::NumGauss(), AccumFullGmm::occupancy(), TraceMatMat(), TraceSpSp(), and VecVec().

                                                                           {
  GmmFlagsType flags = fullgmm_acc.Flags();
  Vector<BaseFloat> occ_bf(fullgmm_acc.occupancy());
  Matrix<BaseFloat> mean_accs_bf(fullgmm_acc.mean_accumulator());
  SpMatrix<BaseFloat> covar_accs_bf(gmm.Dim());
 
  BaseFloat obj = VecVec(occ_bf, gmm.gconsts());
  
  if (flags & kGmmMeans)
    obj += TraceMatMat(mean_accs_bf, gmm.means_invcovars(), kTrans);
  
  if (flags & kGmmVariances) {
    for (int32 i = 0; i < gmm.NumGauss(); i++) {
      covar_accs_bf.CopyFromSp(fullgmm_acc.covariance_accumulator()[i]);
      obj -= 0.5 * TraceSpSp(covar_accs_bf, gmm.inv_covars()[i]);
    }
  }
  
  return obj;
}

ModifyGraphForCarefulAlignment()

void ModifyGraphForCarefulAlignment

(

fst::VectorFst< fst::StdArc > *

fst

)

This function modifies the decoding graph for what we call "careful alignment".

The problem we are trying to solve is that if the decoding eats up the words in the graph too fast, it can get stuck at the end, and produce what looks like a valid alignment even though there was really a failure. So what we want to do is to introduce, after the final-states of the graph, a "blind alley" with no final-probs reachable, where the decoding can go to get lost. Our basic idea is to append the decoding-graph to itself using the fst Concat operation; but in order that there should be final-probs at the end of the first but not the second FST, we modify the right-hand argument to the Concat operation so that it has none of the original final-probs, and add a "pre-initial" state that is final.

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

References KALDI_WARN.

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

                                  {
  typedef fst::StdArc Arc;
  typedef Arc::StateId StateId;
  typedef Arc::Label Label;
  typedef Arc::Weight Weight;
  StateId num_states = fst->NumStates();
  if (num_states == 0) {
    KALDI_WARN << "Empty FST input.";
    return;
  }
  Weight zero = Weight::Zero();
  // fst_rhs will be the right hand side of the Concat operation.
  fst::VectorFst<fst::StdArc> fst_rhs(*fst);
  // first remove the final-probs from fst_rhs.
  for (StateId state = 0; state < num_states; state++)
    fst_rhs.SetFinal(state, zero);
  StateId pre_initial = fst_rhs.AddState();
  Arc to_initial(0, 0, Weight::One(), fst_rhs.Start());
  fst_rhs.AddArc(pre_initial, to_initial);
  fst_rhs.SetStart(pre_initial);
  // make the pre_initial state final with probability one;
  // this is equivalent to keeping the final-probs of the first
  // FST when we do concat (otherwise they would get deleted).
  fst_rhs.SetFinal(pre_initial, Weight::One());
  fst::VectorFst<fst::StdArc> fst_concat;
  fst::Concat(fst, fst_rhs);
}

MonophoneContextDependency()

ContextDependency * MonophoneContextDependency	(	const std::vector< int32 > &	phones,
		const std::vector< int32 > &	phone2num_pdf_classes
	)

Definition at line 331 of file context-dep.cc.

References ContextDependency::ContextDependency(), GetStubMap(), and rnnlm::i.

Referenced by main(), TestConvertAlignment(), and TestMonophoneContextDependency().

                                                                          {
  std::vector<std::vector<int32> > phone_sets(phones.size());
  for (size_t i = 0; i < phones.size(); i++) phone_sets[i].push_back(phones[i]);
  std::vector<bool> share_roots(phones.size(), false);  // don't share roots.
  // N is context size, P = position of central phone (must be 0).
  int32 num_leaves = 0, P = 0, N = 1;
  EventMap *pdf_map = GetStubMap(P, phone_sets, phone2num_pdf_classes, share_roots, &num_leaves);
  return new ContextDependency(N, P, pdf_map);
}

MonophoneContextDependencyShared()

ContextDependency * MonophoneContextDependencyShared	(	const std::vector< std::vector< int32 > > &	phone_sets,
		const std::vector< int32 > &	phone2num_pdf_classes
	)

Definition at line 343 of file context-dep.cc.

References ContextDependency::ContextDependency(), and GetStubMap().

Referenced by main().

                                                                                {
  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 num_leaves = 0, P = 0, N = 1;
  EventMap *pdf_map = GetStubMap(P, phone_sets, phone2num_pdf_classes, share_roots, &num_leaves);
  return new ContextDependency(N, P, pdf_map);
}

mul_elements() [1/2]

void kaldi::mul_elements ( const MatrixIndexT  dim, const double *  a, double *  b  )

inline

This is not really a wrapper for CBLAS as CBLAS does not have this; in future we could extend this somehow.

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

References rnnlm::i.

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

               { // does b *= a, elementwise.
  double c1, c2, c3, c4;
  MatrixIndexT i;
  for (i = 0; i + 4 <= dim; i += 4) {
    c1 = a[i] * b[i];
    c2 = a[i+1] * b[i+1];
    c3 = a[i+2] * b[i+2];
    c4 = a[i+3] * b[i+3];
    b[i] = c1;
    b[i+1] = c2;
    b[i+2] = c3;
    b[i+3] = c4;
  }
  for (; i < dim; i++)
    b[i] *= a[i];
}

mul_elements() [2/2]

void kaldi::mul_elements ( const MatrixIndexT  dim, const float *  a, float *  b  )

inline

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

References rnnlm::i.

              { // does b *= a, elementwise.
  float c1, c2, c3, c4;
  MatrixIndexT i;
  for (i = 0; i + 4 <= dim; i += 4) {
    c1 = a[i] * b[i];
    c2 = a[i+1] * b[i+1];
    c3 = a[i+2] * b[i+2];
    c4 = a[i+3] * b[i+3];
    b[i] = c1;
    b[i+1] = c2;
    b[i+2] = c3;
    b[i+3] = c4;
  }
  for (; i < dim; i++)
    b[i] *= a[i];
}

MustBeQuoted()

static bool kaldi::MustBeQuoted ( const std::string &  str, ShellType  st  )

static

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

References rnnlm::d, KALDI_ASSERT, and kBash.

Referenced by ParseOptions::Escape().

                                                             {
  // Only Bash is supported (for the moment).
  KALDI_ASSERT(st == kBash && "Invalid shell type.");

  const char *c = str.c_str();
  if (*c == '\0') {
    return true;  // Must quote empty string
  } else {
    const char *ok_chars[2];

    // These seem not to be interpreted as long as there are no other "bad"
    // characters involved (e.g. "," would be interpreted as part of something
    // like a{b,c}, but not on its own.
    ok_chars[kBash] = "[]~#^_-+=:.,/";

    // Just want to make sure that a space character doesn't get automatically
    // inserted here via an automated style-checking script, like it did before.
    KALDI_ASSERT(!strchr(ok_chars[kBash], ' '));

    for (; *c != '\0'; c++) {
      // For non-alphanumeric characters we have a list of characters which
      // are OK. All others are forbidden (this is easier since the shell
      // interprets most non-alphanumeric characters).
      if (!isalnum(*c)) {
        const char *d;
        for (d = ok_chars[st]; *d != '\0'; d++) if (*c == *d) break;
        // If not alphanumeric or one of the "ok_chars", it must be escaped.
        if (*d == '\0') return true;
      }
    }
    return false;  // The string was OK. No quoting or escaping.
  }
}

MyFunction1()

void kaldi::MyFunction1

(

)

Definition at line 27 of file kaldi-error-test.cc.

References MyFunction2().

Referenced by UnitTestError().

{ MyFunction2(); }

MyFunction2()

void kaldi::MyFunction2

(

)

Definition at line 25 of file kaldi-error-test.cc.

References KALDI_ERR.

Referenced by MyFunction1().

{ KALDI_ERR << "Ignore this error"; }

NameOf()

std::string NameOf

(

)

Definition at line 30 of file matrix-lib-speed-test.cc.

                                           {
  return (sizeof(Real) == 8 ? "<double>" : "<float>");
}

NccfToPov()

BaseFloat kaldi::NccfToPov

(

BaseFloat

n

)

This function processes the NCCF n to a reasonably accurate probability of voicing p by applying the formula:

n' = fabs(n) r = -5.2 + 5.4 * exp(7.5 * (n' - 1.0)) + 4.8 * n' - 2.0 * exp(-10.0 * n') + 4.2 * exp(20.0 * (n' - 1.0)); p = 1.0 / (1 + exp(-1.0 * r));

How did we get this formula? We plotted the empirical log-prob-ratio of voicing r = log( p[voiced] / p[not-voiced] ) [on the Keele database where voicing is marked], as a function of the NCCF at the delay picked by our algorithm. This was done on intervals of the NCCF, so we had enough statistics to get that ratio. The NCCF covers [-1, 1]; almost all of the probability mass is on [0, 1] but the empirical POV seems fairly symmetric with a minimum near zero, so we chose to make it a function of n' = fabs(n).

Then we manually tuned a function (the one you see above) that approximated the log-prob-ratio of voicing fairly well as a function of the absolute-value NCCF n'; however, wasn't a very exact match since we were also trying to make the transformed NCCF fairly Gaussian distributed, with a view to using it as a feature– an idea we later abandoned after a simpler formula worked better.

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

References Exp(), and KALDI_ASSERT.

Referenced by OnlineProcessPitch::UpdateNormalizationStats().

                                 {
  BaseFloat ndash = fabs(n);
  if (ndash > 1.0) ndash = 1.0;  // just in case it was slightly outside [-1, 1]

  BaseFloat r = -5.2 + 5.4 * Exp(7.5 * (ndash - 1.0)) + 4.8 * ndash -
                2.0 * Exp(-10.0 * ndash) + 4.2 * Exp(20.0 * (ndash - 1.0));
  // r is the approximate log-prob-ratio of voicing, log(p/(1-p)).
  BaseFloat p = 1.0 / (1 + Exp(-1.0 * r));
  KALDI_ASSERT(p - p == 0);  // Check for NaN/inf
  return p;
}

NccfToPovFeature()

BaseFloat kaldi::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.

Before doing this, the NCCF distribution is in the range [-1, 1] but has a strong peak just before 1.0, which this function smooths out.

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

References KALDI_ASSERT.

Referenced by OnlineProcessPitch::GetPovFeature().

                                        {
  if (n > 1.0) {
    n = 1.0;
  } else if (n < -1.0) {
    n = -1.0;
  }
  BaseFloat f = pow((1.0001 - n), 0.15) - 1.0;
  KALDI_ASSERT(f - f == 0);  // check for NaN,inf.
  return f;
}

NewCuCompressedMatrix()

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.

It will crash at runtime if called when CUDA is not compiled in, or not enabled.

Definition at line 119 of file cu-compressed-matrix.cc.

References KALDI_ASSERT, KALDI_ERR, kCompressedMatrixInt16, kCompressedMatrixInt8, kCompressedMatrixUint16, and kCompressedMatrixUint8.

Referenced by CuCompressedMatrixTestNonnegative(), CuCompressedMatrixTestSign(), CuCompressedMatrixTestSymmetric(), and NnetComputer::ExecuteCommand().

                                                            {
  if (t == kCompressedMatrixUint8) {
    KALDI_ASSERT(range >= 0);
    return new CuCompressedMatrix<uint8>(range);
  } else if (t == kCompressedMatrixInt8) {
    KALDI_ASSERT(range >= 0);
    return new CuCompressedMatrix<int8>(range);
  } else if (t == kCompressedMatrixUint16) {
    KALDI_ASSERT(range > 0);
    return new CuCompressedMatrix<uint16>(range);
  } else if (t == kCompressedMatrixInt16) {
    KALDI_ASSERT(range > 0);
    return new CuCompressedMatrix<int16>(range);
  } else {
    KALDI_ERR << "Unknown compressed-matrix type";
    return NULL;
  }
}

NonDiagonalness()

static Real kaldi::NonDiagonalness ( const SpMatrix< Real > &  S )

static

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

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

Referenced by UnitTestPca2().

                                                     {
  Real max_diag = 0.0, max_offdiag = 0.0;
  for (MatrixIndexT i = 0; i < S.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++) {
      if (i == j) { max_diag = std::max(max_diag, std::abs(S(i, j))); }
      else {  max_offdiag = std::max(max_offdiag, std::abs(S(i, j))); }
    }
  if (max_diag == 0.0) {
    if (max_offdiag == 0.0) return 0.0; // perfectly diagonal.
    else return 1.0; // perfectly non-diagonal.
  } else {
    return max_offdiag / max_diag;
  }
}

NonOrthogonality()

static Real kaldi::NonOrthogonality ( const MatrixBase< Real > &  M, MatrixTransposeType  transM  )

static

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

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

Referenced by UnitTestPca2().

                                                                                    {
  SpMatrix<Real> S(transM == kTrans ? M.NumCols() : M.NumRows());
  S.SetUnit();
  S.AddMat2(-1.0, M, transM, 1.0);
  Real max = 0.0;
  for (MatrixIndexT i = 0; i < S.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      max = std::max(max, std::abs(S(i, j)));
  return max;
}

NonUnitness()

static Real kaldi::NonUnitness ( const SpMatrix< Real > &  S )

static

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

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

Referenced by UnitTestPca(), UnitTestTopEigs(), UnitTestTridiagonalize(), and UnitTestTridiagonalizeAndQr().

                                                 {
  SpMatrix<Real> tmp(S.NumRows());
  tmp.SetUnit();
  tmp.AddSp(-1.0, S);
  Real max = 0.0;
  for (MatrixIndexT i = 0; i < tmp.NumRows(); i++)
    for (MatrixIndexT j = 0; j <= i; j++)
      max = std::max(max, std::abs(tmp(i, j)));
  return max;
}

ObtainSetsOfPhones()

static void kaldi::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  )

static

ObtainSetsOfPhones is called by AutomaticallyObtainQuestions.

It processes the output of ClusterTopDown to obtain the sets of phones corresponding to both the leaf-level clusters and all the non-leaf-level clusters.

Definition at line 557 of file build-tree.cc.

References rnnlm::i, IsSortedAndUniq(), rnnlm::j, KALDI_ASSERT, and RemoveDuplicates().

Referenced by AutomaticallyObtainQuestions().

                                                                       {
  KALDI_ASSERT(sets_out != NULL);
  sets_out->clear();
  std::vector<std::vector<int32> > raw_sets(clust_assignments.size());

  KALDI_ASSERT(num_leaves < static_cast<int32>(clust_assignments.size()));
  KALDI_ASSERT(assignments.size() == phone_sets.size());
  for (size_t i = 0; i < assignments.size(); i++) {
    int32 clust = assignments[i];  // this is an index into phone_sets.
    KALDI_ASSERT(clust>=0 && clust < num_leaves);
    for (size_t j = 0; j < phone_sets[i].size(); j++) {
      // and not just a hole.
      raw_sets[clust].push_back(phone_sets[i][j]);
    }
  }
  // for all clusters including the top-level cluster:
  // [note that the top-level cluster contains all phones, but it may actually
  //  be useful because sometimes we cluster just the non-silence phones, so
  //  the list of all phones is a way of asking about silence in such a way
  // that epsilon (end-or-begin-of-utterance) gets lumped with silence.
  for (int32 j = 0; j < static_cast<int32>(clust_assignments.size()); j++) {
    int32 parent = clust_assignments[j];
    std::sort(raw_sets[j].begin(), raw_sets[j].end());
    KALDI_ASSERT(IsSortedAndUniq(raw_sets[j]));  // should be no dups.
    if (parent < static_cast<int32>(clust_assignments.size())-1) {  // parent is not out of range [i.e. not the top one]...
      // add all j's phones to its parent.
      raw_sets[parent].insert(raw_sets[parent].end(),
                              raw_sets[j].begin(),
                              raw_sets[j].end());
    }
  }
  // Reverse the 'raw_sets' so the most important things (top-level questions)
  // appear at the front... this will end up mattering because of the
  // --truncate-leftmost-questions option to compile-questions.
  std::reverse(raw_sets.begin(), raw_sets.end());

  // Now add the original sets-of-phones to the raw sets, to make sure all of
  // these are present.  (The main reason they might be absent is if the stats
  // are empty, but we want to ensure they are all there regardless).  note these
  // will be actual singleton sets if the sets-of-phones each contain just one
  // phone, which in some sense is the normal situation.
  for (size_t i = 0; i < phone_sets.size(); i++) {
    raw_sets.push_back(phone_sets[i]);
  }
  // Remove duplicate sets from "raw_sets".
  RemoveDuplicates(&raw_sets);
  sets_out->reserve(raw_sets.size());
  for (size_t i = 0; i < raw_sets.size(); i++)
    if (! raw_sets[i].empty())  // if the empty set is present, remove it...
      sets_out->push_back(raw_sets[i]);
}

OnlineSilenceWeighting::ComputeCurrentTraceback< fst::Fst< fst::StdArc > >() [1/2]

template void kaldi::OnlineSilenceWeighting::ComputeCurrentTraceback< fst::Fst< fst::StdArc > >

(

const LatticeFasterOnlineDecoderTpl< fst::Fst< fst::StdArc > > &

decoder

)

OnlineSilenceWeighting::ComputeCurrentTraceback< fst::Fst< fst::StdArc > >() [2/2]

template void kaldi::OnlineSilenceWeighting::ComputeCurrentTraceback< fst::Fst< fst::StdArc > >

(

const LatticeIncrementalOnlineDecoderTpl< fst::Fst< fst::StdArc > > &

decoder

)

OnlineSilenceWeighting::ComputeCurrentTraceback< fst::GrammarFst >() [1/2]

template void kaldi::OnlineSilenceWeighting::ComputeCurrentTraceback< fst::GrammarFst >

(

const LatticeFasterOnlineDecoderTpl< fst::GrammarFst > &

decoder

)

OnlineSilenceWeighting::ComputeCurrentTraceback< fst::GrammarFst >() [2/2]

template void kaldi::OnlineSilenceWeighting::ComputeCurrentTraceback< fst::GrammarFst >

(

const LatticeIncrementalOnlineDecoderTpl< fst::GrammarFst > &

decoder

)

operator<<() [1/15]

std::ostream & operator<<	(	std::ostream &	out,
		const CuBlockMatrix< Real > &	mat
	)

Print the matrix to stream.

Definition at line 318 of file cu-block-matrix.cc.

                                                                          {
  bool binary = false;
  mat.Write(out, binary);
  return out;
}

operator<<() [2/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuBlockMatrix< float > &	mat
	)

operator<<() [3/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuBlockMatrix< double > &	mat
	)

operator<<() [4/15]

std::ostream & operator<<	(	std::ostream &	out,
		const CuArray< T > &	vec
	)

Print the vector to stream.

I/O.

Definition at line 329 of file cu-array-inl.h.

References rnnlm::i.

                                                                 {
  std::vector<T> tmp;
  vec.CopyToVec(&tmp);
  out << "[";
  for(int32 i=0; i<tmp.size(); i++) {
    out << " " << tmp[i];
  }
  out << " ]\n";
  return out;
}

operator<<() [5/15]

std::ostream & operator<<	(	std::ostream &	out,
		const CuPackedMatrix< Real > &	mat
	)

Print the matrix to stream.

I/O.

Definition at line 386 of file cu-packed-matrix.cc.

                                                                           {
  PackedMatrix<Real> temp(mat.NumRows());
  mat.CopyToPacked(&temp);
  out << temp;
  return out;
}

operator<<() [6/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuPackedMatrix< float > &	mat
	)

operator<<() [7/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuPackedMatrix< double > &	mat
	)

operator<<() [8/15]

std::ostream & operator<<	(	std::ostream &	os,
		const kaldi::DiagGmm &	gmm
	)

ostream operator that calls DiagGMM::Write()

Definition at line 722 of file diag-gmm.cc.

References DiagGmm::Write().

                                                    {
  gmm.Write(os, false);
  return os;
}

operator<<() [9/15]

std::ostream & operator<<	(	std::ostream &	out_stream,
		const kaldi::FullGmm &	gmm
	)

ostream operator that calls FullGmm::Write()

Definition at line 777 of file full-gmm.cc.

References FullGmm::Write().

                                                    {
  gmm.Write(out_stream, false);
  return out_stream;
}

operator<<() [10/15]

std::ostream & operator<<	(	std::ostream &	out,
		const CuVectorBase< Real > &	vec
	)

Print the vector to stream.

I/O.

Definition at line 1119 of file cu-vector.cc.

                                                                         {
  Vector<Real> temp(vec.Dim());
  vec.CopyToVec(&temp);
  out << temp;
  return out;
}

operator<<() [11/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuVectorBase< float > &	vec
	)

operator<<() [12/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuVectorBase< double > &	vec
	)

operator<<() [13/15]

std::ostream & operator<<	(	std::ostream &	out,
		const CuMatrixBase< Real > &	mat
	)

Print the matrix to stream.

I/O.

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

References CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::NumCols(), and CuMatrixBase< Real >::NumRows().

                                                                         {
  Matrix<Real> temp(mat.NumRows(), mat.NumCols());
  mat.CopyToMat(&temp);
  out << temp;
  return out;
}

operator<<() [14/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuMatrixBase< float > &	mat
	)

operator<<() [15/15]

template std::ostream& kaldi::operator<<	(	std::ostream &	out,
		const CuMatrixBase< double > &	mat
	)

operator>()

bool kaldi::operator>	(	const CompBotClustElem &	a,
		const CompBotClustElem &	b
	)

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

References CompBotClustElem::dist.

                                                                       {
  return a.dist > b.dist;
}

operator>>() [1/2]

std::istream & operator>>	(	std::istream &	is,
		kaldi::DiagGmm &	gmm
	)

istream operator that calls DiagGMM::Read()

Definition at line 758 of file diag-gmm.cc.

References DiagGmm::Read().

                                                            {
  gmm.Read(is, false);  // false == non-binary.
  return is;
}

operator>>() [2/2]

std::istream & operator>>	(	std::istream &	in_stream,
		kaldi::FullGmm &	gmm
	)

istream operator that calls FullGmm::Read()

Definition at line 848 of file full-gmm.cc.

References FullGmm::Read().

                                                                    {
  gmm.Read(in_stream, false);  // false == non-binary.
  return in_stream;
}

OptimizeFactorTransducer()

void OptimizeFactorTransducer	(	KwsLexicographicFst *	index_transducer,
		int32	max_states,
		bool	allow_partial
	)

Definition at line 116 of file kws-functions2.cc.

References fst::DeterminizeStar(), KALDI_VLOG, and KALDI_WARN.

Referenced by main().

                                                  {
  using namespace fst;
  KwsLexicographicFst ifst = *index_transducer;
  EncodeMapper<KwsLexicographicArc> encoder(kEncodeLabels, ENCODE);
  Encode(&ifst, &encoder);
  KALDI_VLOG(2) << "OptimizeFactorTransducer: determinization...";
  if (allow_partial) {
    DeterminizeStar(ifst, index_transducer, kDelta, NULL, max_states, true);
  } else {
      try {
        DeterminizeStar(ifst, index_transducer, kDelta, NULL, max_states,
                        false);
      } catch(const std::exception &e) {
        KALDI_WARN << e.what();
        *index_transducer = ifst;
      }
  }
  KALDI_VLOG(2) << "OptimizeFactorTransducer: minimization...";
  Minimize(index_transducer, static_cast<KwsLexicographicFst *>(NULL), fst::kDelta, true);
  Decode(index_transducer, encoder);
}

PaCallback()

int PaCallback	(	const void *	input,
		void *	output,
		long unsigned	frame_count,
		const PaStreamCallbackTimeInfo *	time_info,
		PaStreamCallbackFlags	status_flags,
		void *	user_data
	)

Definition at line 39 of file online-audio-source.cc.

References OnlinePaSource::Callback().

                                {
  OnlinePaSource *pa_src = reinterpret_cast<OnlinePaSource*>(user_data);
  return pa_src->Callback(input, output, frame_count, time_info, status_flags);
}

ParseConfigLines()

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.

The general format is: "command-type bar=baz xx=yyy" etc., although there are subtleties as to what exactly is allowed, see documentation for class ConfigLine for details. This function will die if there was a parsing failure.

Definition at line 579 of file text-utils.cc.

References rnnlm::i, and KALDI_ERR.

                                                           {
  config_lines->resize(lines.size());
  for (size_t i = 0; i < lines.size(); i++) {
    bool ret = (*config_lines)[i].ParseLine(lines[i]);
    if (!ret) {
      KALDI_ERR << "Error parsing config line: " << lines[i];
    }
  }
}

ParseMatrixRangeSpecifier()

bool kaldi::ParseMatrixRangeSpecifier	(	const std::string &	range,
		const int	rows,
		const int	cols,
		std::vector< int32 > *	row_range,
		std::vector< int32 > *	col_range
	)

Definition at line 33 of file kaldi-holder.cc.

References KALDI_ERR, KALDI_WARN, SplitStringToIntegers(), and SplitStringToVector().

Referenced by ExtractObjectRange().

                                                       {
  if (range.empty()) {
    KALDI_ERR << "Empty range specifier.";
    return false;
  }
  std::vector<std::string> splits;
  SplitStringToVector(range, ",", false, &splits);
  if (!((splits.size() == 1 && !splits[0].empty()) ||
        (splits.size() == 2  && !splits[0].empty() && !splits[1].empty()))) {
    KALDI_ERR << "Invalid range specifier for matrix: " << range;
    return false;
  }

  bool status = true;

  if (splits[0] != ":")
    status = SplitStringToIntegers(splits[0], ":", false, row_range);

  if (splits.size() == 2 && splits[1] != ":") {
    status = status && SplitStringToIntegers(splits[1], ":", false, col_range);
  }
  if (row_range->size() == 0) {
    row_range->push_back(0);
    row_range->push_back(rows - 1);
  }
  if (col_range->size() == 0) {
    col_range->push_back(0);
    col_range->push_back(cols - 1);
  }

  // Length tolerance of 3 -- 2 to account for edge effects when
  // frame-length is 25ms and frame-shift is 10ms, and 1 for rounding effects
  // since segments are usually retained up to 2 decimal places.
  int32 length_tolerance = 3;
  if (!(status && row_range->size() == 2 && col_range->size() == 2 &&
        row_range->at(0) >= 0 && row_range->at(0) <= row_range->at(1) &&
        row_range->at(1) < rows + length_tolerance &&
        col_range->at(0) >=0 &&
        col_range->at(0) <= col_range->at(1) && col_range->at(1) < cols)) {
    KALDI_ERR << "Invalid range specifier: " << range
              << " for matrix of size " << rows
              << "x" << cols;
    return false;
  }

  if (row_range->at(1) >= rows)
    KALDI_WARN << "Row range " << row_range->at(0) << ":" << row_range->at(1)
               << " goes beyond the number of rows of the "
               << "matrix " << rows;
  return status;
}

PhoneAlignLattice()

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.

Note: it's possible to have arcs with words on them but no transition-ids at all. Returns true if everything was OK, false if some kind of error was detected (e.g. the "reorder" option was incorrectly specified.)

Definition at line 413 of file phone-align-lattice.cc.

References LatticePhoneAligner::AlignLattice().

Referenced by main(), PhoneAlignLatticeOptions::Register(), and WordAlignLatticeLexicon().

                                                {
  LatticePhoneAligner aligner(lat, tmodel, opts, lat_out);
  return aligner.AlignLattice();
}

PlaceNansInGaps()

void kaldi::PlaceNansInGaps

(

Matrix< Real > *

mat

)

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

References rnnlm::j, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), RandGauss(), RandInt(), MatrixBase< Real >::RowData(), and MatrixBase< Real >::Stride().

Referenced by UnitTestAddMatMatNans(), and UnitTestResizeCopyDataDifferentStrideType().

                                        {
  int32 num_rows = mat->NumRows(), num_cols = mat->NumCols(),
      stride = mat->Stride();
  BaseFloat not_a_number = nan(" ");  // nan is from <cmath>
  for (int32 r = 0; r + 1 < num_rows; r++) {
    for (int32 j = num_cols; j < stride; j++) {
      if (RandInt(0, 1) == 0)
        (mat->RowData(r))[j] = not_a_number;
      else
        (mat->RowData(r))[j] = RandGauss() * 1.5e+31;
    }
  }
}

PosteriorToMatrix< double >()

template void kaldi::PosteriorToMatrix< double >	(	const Posterior &	post,
		const int32	post_dim,
		Matrix< double > *	mat
	)

Referenced by PosteriorToMatrix().

PosteriorToMatrix< float >()

template void kaldi::PosteriorToMatrix< float >	(	const Posterior &	post,
		const int32	post_dim,
		Matrix< float > *	mat
	)

Referenced by PosteriorToMatrix().

PosteriorToPdfMatrix< double >()

template void kaldi::PosteriorToPdfMatrix< double >	(	const Posterior &	post,
		const TransitionModel &	model,
		Matrix< double > *	mat
	)

Referenced by PosteriorToPdfMatrix().

PosteriorToPdfMatrix< float >()

template void kaldi::PosteriorToPdfMatrix< float >	(	const Posterior &	post,
		const TransitionModel &	model,
		Matrix< float > *	mat
	)

Referenced by PosteriorToPdfMatrix().

prefixp()

static bool kaldi::prefixp ( const std::string &  pfx, const std::string &  str  )

static

Definition at line 45 of file kaldi-cygwin-io-inl.h.

References cygprefix().

Referenced by MapCygwinPath(), and MapCygwinPathNoTmp().

                                                                {
  return pfx.length() <= str.length() &&
    std::equal(pfx.begin(), pfx.end(), str.begin());
}

PrepareMap() [1/2]

void kaldi::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.

If the string map_rxfilename is empty, then the mapping is the identity map (e.g., 0 maps to 0, 1 maps to 1, etc), based on the number of classes num_classes. If map_rxfilename is not empty, the mapping is created from that file. The file is expected to be two columns of integers with up to num_classes rows. If an input class is not specified in the file, then the output class label is the same as the input. The first column is the input class and the second column is the output class. For example: 0 0 1 1 2 0

Definition at line 42 of file compute-vad-from-frame-likes.cc.

References rnnlm::i, KALDI_ASSERT, KALDI_ERR, SplitStringToVector(), and Input::Stream().

Referenced by main().

                                                  {
  Input map_input(map_rxfilename);
  for (int32 i = 0; i < num_classes; i++)
    (*map)[i] = i;

  if (!map_rxfilename.empty()) {
    std::string line;
    while (std::getline(map_input.Stream(), line)) {
      if (line.size() == 0) continue;
      int32 start = line.find_first_not_of(" \t");
      int32 end = line.find_first_of('#'); // Ignore trailing comments
      if (start == std::string::npos || start == end) continue;
      end = line.find_last_not_of(" \t", end - 1);
      KALDI_ASSERT(end >= start);
      std::vector<std::string> fields;
      SplitStringToVector(line.substr(start, end - start + 1),
         " \t\n\r", true, &fields);
      if (fields.size() != 2) {
        KALDI_ERR << "Bad line. Expected two fields, got: "
                  << line;
      }
      (*map)[std::atoi(fields[0].c_str())] = std::atoi(fields[1].c_str());
    }
  }

  if (map->size() > num_classes)
    KALDI_ERR << "Map table has " << map->size() << " classes.  "
              << "Expected " << num_classes << " or fewer";
}

PrepareMap() [2/2]

void kaldi::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.

If map_rxfilename is empty, we create a mapping in which a frame is only classified as speech (represented as "1") if both VAD decisions agree on speech, and nonspeech (represented as "0") otherwise. If map_rxfilename is not empty, then that table provides the mapping. If the first set of VAD decisions has N classes and the second has M classes, then the table needs to have NxM rows, and three columns. The first two columns correspond to the labels in the first and second VAD decisions respectively, and the last column is the resultant output label. For example: 0 0 0 0 1 0 0 2 0 1 0 0 1 1 1 1 2 1

Definition at line 45 of file merge-vads.cc.

References KALDI_ASSERT, KALDI_ERR, SplitStringToVector(), and Input::Stream().

                                                                        {
  Input map_input(map_rxfilename);

  // If a map file isn't specified, provide an obvious mapping.  The
  // following mapping assumes "0" corresponds to nonspeech and "1"
  // corresponds to speech. The combination of two VAD decisions only
  // results in a decision of speech if both input frames are
  // classified as speech.
  if (map_rxfilename.empty()) {
    (*map)[std::pair<int32, int32>(0, 0)] = 0;
    (*map)[std::pair<int32, int32>(0, 1)] = 0;
    (*map)[std::pair<int32, int32>(1, 0)] = 0;
    (*map)[std::pair<int32, int32>(1, 1)] = 1;
  } else {
    std::string line;
    while (std::getline(map_input.Stream(), line)) {
      if (line.size() == 0) continue;
      int32 start = line.find_first_not_of(" \t");
      int32 end = line.find_first_of('#');
      if (start == std::string::npos || start == end) continue;
      end = line.find_last_not_of(" \t", end - 1);
      KALDI_ASSERT(end >= start);
      std::vector<std::string> fields;
      SplitStringToVector(line.substr(start, end - start + 1),
         " \t\n\r", true, &fields);
      if (fields.size() != 3) {
        KALDI_ERR << "Bad line. Expected three fields, got: "
                  << line;
      }
      int32 label1 = std::atoi(fields[0].c_str()),
            label2 = std::atoi(fields[1].c_str()),
            result_label = std::atoi(fields[2].c_str());
      (*map)[std::pair<int32, int32>(label1, label2)] = result_label;
    }
  }
}

PreparePriors()

void kaldi::PreparePriors	(	const std::string &	priors_str,
		int32	num_classes,
		std::vector< BaseFloat > *	priors
	)

PreparePriors creates a table specifying the priors for each class.

If priors_str is empty, uniform priors are assumed. If priors_str is nonempty, the comma-separated floats are parsed out. If present, the input of priors_str is of the form: 0.5,0.25,0.25

Definition at line 80 of file compute-vad-from-frame-likes.cc.

References rnnlm::i, KALDI_ERR, and SplitStringToFloats().

Referenced by main().

                                              {
  if (priors_str.empty()) {
    for (int32 i = 0; i < num_classes; i++)
      priors->push_back(log(1.0/num_classes)); // Uniform priors
  } else {
    SplitStringToFloats(priors_str, ",", false, priors);
    for (int32 i = 0; i < priors->size(); i++)
      (*priors)[i] = log((*priors)[i]);
  }

  if (priors->size() != num_classes)
    KALDI_ERR << priors->size() << " priors specified.  Expected "
              << num_classes;
}

PrintLexicon()

static void kaldi::PrintLexicon ( const std::vector< std::vector< int32 > > &  lexicon )

static

Definition at line 83 of file word-align-lattice-lexicon-test.cc.

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

Referenced by TestWordAlignLatticeLexicon().

                                                                      {
  KALDI_LOG << "Lexicon is: ";
  for (size_t i = 0; i < lexicon.size(); i++) {
    KALDI_ASSERT(lexicon[i].size() >= 2);
    const std::vector<int32> &entry = lexicon[i];
    std::cerr << entry[0] << "\t" << entry[1] << "\t";
    for (size_t j = 2; j < entry.size(); j++)
      std::cerr << entry[j] << " ";
    std::cerr << "\n";
  }
}

PrintPartialResult()

void PrintPartialResult	(	const std::vector< int32 > &	words,
		const fst::SymbolTable *	word_syms,
		bool	line_break
	)

Definition at line 60 of file onlinebin-util.cc.

References rnnlm::i, KALDI_ASSERT, and KALDI_ERR.

Referenced by main().

                                         {
  KALDI_ASSERT(word_syms != NULL);
  for (size_t i = 0; i < words.size(); i++) {
    std::string word = word_syms->Find(words[i]);
    if (word == "")
      KALDI_ERR << "Word-id " << words[i] <<" not in symbol table.";
    std::cout << word << ' ';
  }
  if (line_break)
    std::cout << "\n\n";
  else
    std::cout.flush();
}

PrintWordsAndPhones()

static void kaldi::PrintWordsAndPhones ( const std::vector< int32 > &  words, const std::vector< int32 > &  phones  )

static

Definition at line 95 of file word-align-lattice-lexicon-test.cc.

References rnnlm::i, and KALDI_LOG.

Referenced by TestWordAlignLatticeLexicon().

                                                                {
  std::ostringstream word_str, phone_str;
  for (size_t i = 0; i < words.size(); i++)
    word_str << words[i] << " ";
  for (size_t i = 0; i < phones.size(); i++)
    phone_str << phones[i] << " ";
  KALDI_LOG << "Word-sequence is: " << word_str.str();
  KALDI_LOG << "Phone-sequence is: " << phone_str.str();
}

ProcessPovFeatures()

void kaldi::ProcessPovFeatures

(

Matrix< BaseFloat > *

mat

)

Definition at line 30 of file process-pitch-feats.cc.

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

Referenced by main().

                                                {
  int32 num_frames = mat->NumRows();
  for (int32 i = 0; i < num_frames; i++) {
    BaseFloat p = (*mat)(i, 0);
    KALDI_ASSERT(p >= 0.0 && p <= 1.0);
    (*mat)(i, 0) = Log((p + 0.0001) / (1.0001 - p));
  }
}

ProcessTopo()

int32 kaldi::ProcessTopo	(	const HmmTopology &	topo,
		const std::vector< std::vector< int32 > > &	questions
	)

Definition at line 27 of file compile-questions.cc.

References HmmTopology::GetPhones(), rnnlm::i, rnnlm::j, KALDI_ERR, KALDI_LOG, KALDI_WARN, HmmTopology::NumPdfClasses(), SortAndUniq(), and WriteIntegerVector().

Referenced by main().

                                                                                          {
  std::vector<int32> seen_phones;  // ids of phones seen in questions.
  for (size_t i = 0; i < questions.size(); i++)
    for (size_t j= 0; j < questions[i].size(); j++) seen_phones.push_back(questions[i][j]);
  SortAndUniq(&seen_phones);
  // topo_phones is also sorted and uniq; a list of phones defined in the topology.
  const std::vector<int32> &topo_phones = topo.GetPhones();
  if (seen_phones != topo_phones) {
    std::ostringstream ss_seen, ss_topo;
    WriteIntegerVector(ss_seen, false, seen_phones);
    WriteIntegerVector(ss_topo, false, topo_phones);
    KALDI_WARN << "ProcessTopo: phones seen in questions differ from those in topology: "
               << ss_seen.str() << " vs. " << ss_topo.str();
    if (seen_phones.size() > topo_phones.size()) {
      KALDI_ERR << "ProcessTopo: phones are asked about that are undefined in the topology.";
    } // we accept the reverse (not asking about all phones), even though it's very bad.
  }

  int32 max_num_pdf_classes = 0;
  for (size_t i = 0; i < topo_phones.size(); i++) {
    int32 p = topo_phones[i];
    int32 num_pdf_classes = topo.NumPdfClasses(p);
    max_num_pdf_classes = std::max(num_pdf_classes, max_num_pdf_classes);
  }
  KALDI_LOG << "Max # pdf classes is " << max_num_pdf_classes;
  return max_num_pdf_classes;
}

ProcessUtterance() [1/2]

bool kaldi::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
	)

Definition at line 38 of file sgmm2-latgen-faster.cc.

References AmSgmm2::ComputePerSpkDerivedVars(), DecodeUtteranceLatticeFaster(), RandomAccessTableReader< Holder >::HasKey(), RandomAccessTableReaderMapped< Holder >::HasKey(), RandomAccessTableReaderMapped< Holder >::IsOpen(), KALDI_WARN, MatrixBase< Real >::NumRows(), Sgmm2PerSpkDerivedVars::SetSpeakerVector(), RandomAccessTableReader< Holder >::Value(), and RandomAccessTableReaderMapped< Holder >::Value().

                                        { // puts utterance's like in like_ptr on success.
  using fst::Fst;

  Sgmm2PerSpkDerivedVars spk_vars;
  if (spkvecs_reader.IsOpen()) {
    if (spkvecs_reader.HasKey(utt)) {
      spk_vars.SetSpeakerVector(spkvecs_reader.Value(utt));
      am_sgmm.ComputePerSpkDerivedVars(&spk_vars);
    } else {
      KALDI_WARN << "Cannot find speaker vector for " << utt << ", not decoding this utterance";
      return false; // We could use zero, but probably the user would want to know about this
      // (this would normally be a script error or some kind of failure).
    }
  }
  if (!gselect_reader.HasKey(utt) ||
      gselect_reader.Value(utt).size() != features.NumRows()) {
    KALDI_WARN << "No Gaussian-selection info available for utterance "
               << utt << " (or wrong size)";
  }

  const std::vector<std::vector<int32> > &gselect =
      gselect_reader.Value(utt);
  
  DecodableAmSgmm2Scaled sgmm_decodable(am_sgmm, trans_model, features, gselect,
                                        log_prune, acoustic_scale, &spk_vars);

  return DecodeUtteranceLatticeFaster(
      decoder, sgmm_decodable, trans_model, word_syms, utt, acoustic_scale,
      determinize, allow_partial, alignments_writer, words_writer,
      compact_lattice_writer, lattice_writer, like_ptr);
}

ProcessUtterance() [2/2]

void kaldi::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
	)

Definition at line 39 of file sgmm2-latgen-faster-parallel.cc.

References AmSgmm2::ComputePerSpkDerivedVars(), RandomAccessTableReader< Holder >::HasKey(), RandomAccessTableReaderMapped< Holder >::HasKey(), RandomAccessTableReaderMapped< Holder >::IsOpen(), KALDI_WARN, MatrixBase< Real >::NumRows(), TaskSequencer< C >::Run(), Sgmm2PerSpkDerivedVars::SetSpeakerVector(), RandomAccessTableReader< Holder >::Value(), and RandomAccessTableReaderMapped< Holder >::Value().

Referenced by main().

                                                                                   {
  using fst::Fst;
  using std::vector;

  Sgmm2PerSpkDerivedVars *spk_vars = new Sgmm2PerSpkDerivedVars; // decodable
  // will take ownership.
  if (spkvecs_reader.IsOpen()) {
    if (spkvecs_reader.HasKey(utt)) {
      spk_vars->SetSpeakerVector(spkvecs_reader.Value(utt));
      am_sgmm.ComputePerSpkDerivedVars(spk_vars);
    } else {
      KALDI_WARN << "Cannot find speaker vector for " << utt << ", not decoding this utterance";
      delete spk_vars;
      (*num_err)++;
      return;
    }
  }
  if (!gselect_reader.HasKey(utt) ||
      gselect_reader.Value(utt).size() != features.NumRows()) {
    KALDI_WARN << "No Gaussian-selection info available for utterance "
               << utt << " (or wrong size)";
  }

  // decodable will take ownership.
  vector<vector<int32> > *gselect = new std::vector<vector<int32> >(
      gselect_reader.Value(utt));

  Matrix<BaseFloat> *new_feats = new Matrix<BaseFloat>(features); // decodable
  // will take ownership of this.

  // This takes ownership of new_feats, gselect, and spk_vars
  DecodableAmSgmm2Scaled *sgmm_decodable = new DecodableAmSgmm2Scaled(
      am_sgmm, trans_model, new_feats, gselect,
      spk_vars, log_prune, acoustic_scale);

  // takes ownership of decoder and sgmm_decodable.
  DecodeUtteranceLatticeFasterClass *task =
      new DecodeUtteranceLatticeFasterClass(
          decoder, sgmm_decodable, trans_model, word_syms, utt, acoustic_scale,
          determinize, allow_partial, alignments_writer, words_writer,
          compact_lattice_writer, lattice_writer, like_sum, frame_sum, num_done,
          num_err, NULL);

  sequencer->Run(task); // takes ownership.
}

PruneLattice() [1/4]

bool kaldi::PruneLattice	(	BaseFloat	beam,
		LatticeType *	lat
	)

Prunes a lattice or compact lattice.

Returns true on success, false if there was some kind of failure.

PruneLattice() [2/4]

bool kaldi::PruneLattice	(	BaseFloat	beam,
		LatType *	lat
	)

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

References fst::ConvertToCost(), KALDI_ASSERT, and KALDI_WARN.

Referenced by fst::DeterminizeLatticePruned(), DeterminizeLatticeWrapper(), SingleUtteranceGmmDecoder::GetGaussianPosteriors(), SingleUtteranceGmmDecoder::GetLattice(), main(), and fst::TestDeterminizeLatticePruned().

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

  KALDI_ASSERT(beam > 0.0);
  if (!lat->Properties(fst::kTopSorted, true)) {
    if (fst::TopSort(lat) == false) {
      KALDI_WARN << "Cycles detected in lattice";
      return false;
    }
  }
  // We assume states before "start" are not reachable, since
  // the lattice is topologically sorted.
  int32 start = lat->Start();
  int32 num_states = lat->NumStates();
  if (num_states == 0) return false;
  std::vector<double> forward_cost(num_states,
                                   std::numeric_limits<double>::infinity());  // viterbi forward.
  forward_cost[start] = 0.0; // lattice can't have cycles so couldn't be
  // less than this.
  double best_final_cost = std::numeric_limits<double>::infinity();
  // Update the forward probs.
  // Thanks to Jing Zheng for finding a bug here.
  for (int32 state = 0; state < num_states; state++) {
    double this_forward_cost = forward_cost[state];
    for (fst::ArcIterator<LatType> aiter(*lat, state);
         !aiter.Done();
         aiter.Next()) {
      const Arc &arc(aiter.Value());
      StateId nextstate = arc.nextstate;
      KALDI_ASSERT(nextstate > state && nextstate < num_states);
      double next_forward_cost = this_forward_cost +
          ConvertToCost(arc.weight);
      if (forward_cost[nextstate] > next_forward_cost)
        forward_cost[nextstate] = next_forward_cost;
    }
    Weight final_weight = lat->Final(state);
    double this_final_cost = this_forward_cost +
        ConvertToCost(final_weight);
    if (this_final_cost < best_final_cost)
      best_final_cost = this_final_cost;
  }
  int32 bad_state = lat->AddState(); // this state is not final.
  double cutoff = best_final_cost + beam;

  // Go backwards updating the backward probs (which share memory with the
  // forward probs), and pruning arcs and deleting final-probs.  We prune arcs
  // by making them point to the non-final state "bad_state".  We'll then use
  // Trim() to remove unnecessary arcs and states.  [this is just easier than
  // doing it ourselves.]
  std::vector<double> &backward_cost(forward_cost);
  for (int32 state = num_states - 1; state >= 0; state--) {
    double this_forward_cost = forward_cost[state];
    double this_backward_cost = ConvertToCost(lat->Final(state));
    if (this_backward_cost + this_forward_cost > cutoff
        && this_backward_cost != std::numeric_limits<double>::infinity())
      lat->SetFinal(state, Weight::Zero());
    for (fst::MutableArcIterator<LatType> aiter(lat, state);
         !aiter.Done();
         aiter.Next()) {
      Arc arc(aiter.Value());
      StateId nextstate = arc.nextstate;
      KALDI_ASSERT(nextstate > state && nextstate < num_states);
      double arc_cost = ConvertToCost(arc.weight),
          arc_backward_cost = arc_cost + backward_cost[nextstate],
          this_fb_cost = this_forward_cost + arc_backward_cost;
      if (arc_backward_cost < this_backward_cost)
        this_backward_cost = arc_backward_cost;
      if (this_fb_cost > cutoff) { // Prune the arc.
        arc.nextstate = bad_state;
        aiter.SetValue(arc);
      }
    }
    backward_cost[state] = this_backward_cost;
  }
  fst::Connect(lat);
  return (lat->NumStates() > 0);
}

PruneLattice() [3/4]

template bool kaldi::PruneLattice	(	BaseFloat	beam,
		Lattice *	lat
	)

PruneLattice() [4/4]

template bool kaldi::PruneLattice	(	BaseFloat	beam,
		CompactLattice *	lat
	)

QrInternal()

void kaldi::QrInternal	(	MatrixIndexT	n,
		Real *	diag,
		Real *	off_diag,
		MatrixBase< Real > *	Q
	)

Definition at line 331 of file qr.cc.

References rnnlm::d, rnnlm::i, KALDI_ASSERT, KALDI_WARN, rnnlm::n, MatrixBase< Real >::NumCols(), and QrStep().

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

                                     {
  KALDI_ASSERT(Q == NULL || Q->NumCols() == n); // We may
  // later relax the condition that Q->NumCols() == n.

  MatrixIndexT counter = 0, max_iters = 500 + 4*n, // Should never take this many iters.
      large_iters = 100 + 2*n;
  Real epsilon = (pow(2.0, sizeof(Real) == 4 ? -23.0 : -52.0));
  
  for (; counter < max_iters; counter++) { // this takes the place of "until
                                           // q=n"... we'll break out of the
                                           // loop when we converge.
    if (counter == large_iters ||
        (counter > large_iters && (counter - large_iters) % 50 == 0)) {
      KALDI_WARN << "Took " << counter
                 << " iterations in QR (dim is " << n << "), doubling epsilon.";
      SubVector<Real> d(diag, n), o(off_diag, n-1);
      KALDI_WARN << "Diag, off-diag are " << d << " and " << o;
      epsilon *= 2.0;
    }
    for (MatrixIndexT i = 0; i+1 < n; i++) {
      if (std::abs(off_diag[i]) <= epsilon *
          (std::abs(diag[i]) + std::abs(diag[i+1])))
        off_diag[i] = 0.0;
    }
    // The next code works out p, q, and npq which is n - p - q.
    // For the definitions of q and p, see Golub and Van Loan; we 
    // partition the n dims into pieces of size (p, n-p-q, q) where
    // the part of size q is diagonal and the part of size n-p-p is
    // "unreduced", i.e. has no zero off-diagonal elements.
    MatrixIndexT q = 0;
    // Note: below, "n-q < 2" should more clearly be "n-2-q < 0", but that
    // causes problems if MatrixIndexT is unsigned.
    while (q < n && (n-q < 2 || off_diag[n-2-q] == 0.0))
      q++;
    if (q == n) break; // we're done.  It's diagonal.
    KALDI_ASSERT(n - q >= 2);
    MatrixIndexT npq = 2; // Value of n - p - q, where n - p - q must be
    // unreduced.  This is the size of "middle" band of elements.  If q != n,
    // we must have hit a nonzero off-diag element, so the size of this
    // band must be at least two.
    while (npq + q < n && (n-q-npq-1 < 0 || off_diag[n-q-npq-1] != 0.0))
      npq++;
    MatrixIndexT p = n - q - npq;
    { // Checks.
      for (MatrixIndexT i = 0; i+1 < npq; i++)
        KALDI_ASSERT(off_diag[p + i] != 0.0);
      for (MatrixIndexT i = 0; i+1 < q; i++)
        KALDI_ASSERT(off_diag[p + npq - 1 + i] == 0.0);
      if (p > 1) // Something must have stopped npq from growing further..
        KALDI_ASSERT(off_diag[p-1] == 0.0); // so last off-diag elem in
      // group of size p must be zero.
    }

    if (Q != NULL) {
      // Do one QR step on the middle part of Q only.
      // Qpart will be a subset of the rows of Q.
      SubMatrix<Real> Qpart(*Q, p, npq, 0, Q->NumCols());
      QrStep(npq, diag + p, off_diag + p, &Qpart);
    } else {
      QrStep(npq, diag + p, off_diag + p,
             static_cast<MatrixBase<Real>*>(NULL));
    }      
  }
  if (counter == max_iters) {
    KALDI_WARN << "Failure to converge in QR algorithm. "
               << "Exiting with partial output.";
  }
}

QrStep()

void kaldi::QrStep	(	MatrixIndexT	n,
		Real *	diag,
		Real *	off_diag,
		MatrixBase< Real > *	Q
	)

Definition at line 245 of file qr.cc.

References cblas_Xrot(), rnnlm::d, MatrixBase< Real >::Data(), Givens(), KALDI_ASSERT, KALDI_ISFINITE, MatrixBase< Real >::NumCols(), and MatrixBase< Real >::Stride().

Referenced by QrInternal().

                                 {
  KALDI_ASSERT(n >= 2);
  // below, "scale" could be any number; we introduce it to keep the
  // floating point quantities within a good range.
  Real   d = (diag[n-2] - diag[n-1]) / 2.0,
      t = off_diag[n-2],
      inv_scale = std::max(std::max(std::abs(d), std::abs(t)),
                           std::numeric_limits<Real>::min()),
      scale = 1.0 / inv_scale,
      d_scaled = d * scale,
      off_diag_n2_scaled = off_diag[n-2] * scale,
      t2_n_n1_scaled = off_diag_n2_scaled * off_diag_n2_scaled,
      sgn_d = (d > 0.0 ? 1.0 : -1.0),
      mu = diag[n-1] - inv_scale * t2_n_n1_scaled /
      (d_scaled + sgn_d * std::sqrt(d_scaled * d_scaled + t2_n_n1_scaled)),
      x = diag[0] - mu,
      z = off_diag[0];
  KALDI_ASSERT(KALDI_ISFINITE(x));
  Real *Qdata = (Q == NULL ? NULL : Q->Data());
  MatrixIndexT Qstride = (Q == NULL ? 0 : Q->Stride()),
      Qcols = (Q == NULL ? 0 : Q->NumCols());
  for (MatrixIndexT k = 0; k < n-1; k++) {
    Real c, s;
    Givens(x, z, &c, &s);
    // Rotate dimensions k and k+1 with the Givens matrix G, as
    // T <== G^T T G.
    // In 2d, a Givens matrix is [ c s; -s c ].  Forget about
    // the dimension-indexing issues and assume we have a 2x2
    // symmetric matrix [ p q ; q r ]
    // We ask our friends at Wolfram Alpha about
    // { { c, -s}, {s, c} } * { {p, q}, {q, r} } * { { c, s}, {-s, c} }
    // Interpreting the result as [ p', q' ; q', r ]
    //    p' = c (c p - s q) - s (c q - s r)
    //    q' = s (c p - s q) + c (c q - s r)
    //    r' = s (s p + c q) + c (s q + c r)
    Real p = diag[k], q = off_diag[k], r = diag[k+1];
    // p is element k,k; r is element k+1,k+1; q is element k,k+1 or k+1,k.
    // We'll let the compiler optimize this.
    diag[k] = c * (c*p - s*q) - s * (c*q - s*r);
    off_diag[k] = s * (c*p - s*q) + c * (c*q - s*r);
    diag[k+1] = s * (s*p + c*q) + c * (s*q + c*r);

    // We also have some other elements to think of that
    // got rotated in a simpler way: if k>0,
    // then element (k, k-1) and (k+1, k-1) get rotated.  Here,
    // element k+1, k-1 will be present as z; it's the out-of-band
    // element that we remembered from last time.  This is
    // on the left as it's the row indexes that differ, so think of
    // this as being premultiplied by G^T.  In fact we're multiplying
    // T by in some sense the opposite/transpose of the Givens rotation.
    if (k > 0) { // Note, in rotations, going backward, (x,y) -> ((cx - sy), (sx + cy))
      Real &elem_k_km1 = off_diag[k-1],
          elem_kp1_km1 = z; // , tmp = elem_k_km1;
      elem_k_km1 = c*elem_k_km1 - s*elem_kp1_km1;
      // The next line will set elem_kp1_km1 to zero and we'll never access this
      // value, so we comment it out.
      // elem_kp1_km1 = s*tmp + c*elem_kp1_km1;
    }
    if (Q != NULL)
      cblas_Xrot(Qcols, Qdata + k*Qstride, 1,
                 Qdata + (k+1)*Qstride, 1, c, -s);
    if (k < n-2) {
      // Next is the elements (k+2, k) and (k+2, k-1), to be rotated, again
      // backwards.
      Real &elem_kp2_k = z, 
          &elem_kp2_kp1 = off_diag[k+1];
      // Note: elem_kp2_k == z would start off as zero because it's
       // two off the diagonal, and not been touched yet.  Therefore
      // we eliminate it in expressions below, commenting it out.
      // If we didn't do this we should set it to zero first.
      elem_kp2_k =  - s * elem_kp2_kp1; // + c*elem_kp2_k
      elem_kp2_kp1 =  c * elem_kp2_kp1; // + s*elem_kp2_k (original value).
      // The next part is from the algorithm they describe: x = t_{k+1,k}
      x = off_diag[k];
    }
  }
}

QuoteAndEscape()

static std::string kaldi::QuoteAndEscape ( const std::string &  str, ShellType  st  )

static

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

References KALDI_ASSERT, and kBash.

Referenced by ParseOptions::Escape().

                                                                    {
  // Only Bash is supported (for the moment).
  KALDI_ASSERT(st == kBash && "Invalid shell type.");

  // For now we use the following rules:
  // In the normal case, we quote with single-quote "'", and to escape
  // a single-quote we use the string: '\'' (interpreted as closing the
  // single-quote, putting an escaped single-quote from the shell, and
  // then reopening the single quote).
  char quote_char = '\'';
  const char *escape_str = "'\\''";  // e.g. echo 'a'\''b' returns a'b

  // If the string contains single-quotes that would need escaping this
  // way, and we determine that the string could be safely double-quoted
  // without requiring any escaping, then we double-quote the string.
  // This is the case if the characters "`$\ do not appear in the string.
  // e.g. see http://www.redhat.com/mirrors/LDP/LDP/abs/html/quotingvar.html
  const char *c_str = str.c_str();
  if (strchr(c_str, '\'') && !strpbrk(c_str, "\"`$\\")) {
    quote_char = '"';
    escape_str = "\\\"";  // should never be accessed.
  }

  char buf[2];
  buf[1] = '\0';

  buf[0] = quote_char;
  std::string ans = buf;
  const char *c = str.c_str();
  for (;*c != '\0'; c++) {
    if (*c == quote_char) {
      ans += escape_str;
    } else {
      buf[0] = *c;
      ans += buf;
    }
  }
  buf[0] = quote_char;
  ans += buf;
  return ans;
}

Rand()

int Rand

(

struct RandomState *

state

)

Definition at line 45 of file kaldi-math.cc.

References RandomState::seed.

Referenced by CholeskyUnitTestTr(), ClusterKMeansOnce(), OnlineMatrixInput::Compute(), kaldi::nnet3::ComputeExampleComputationRequestSimple(), CuVectorUnitTestAddColSumMat(), CuVectorUnitTestAddDiagMat2(), CuVectorUnitTestAddDiagMatMat(), CuVectorUnitTestAddMatVec(), CuVectorUnitTestAddRowSumMat(), CuVectorUnitTestAddSpVec(), CuVectorUnitTestAddVec(), CuVectorUnitTestAddVecCross(), CuVectorUnitTestAddVecExtra(), CuVectorUnitTestAddVecVec(), CuVectorUnitTestApplyCeiling(), CuVectorUnitTestApplyCeilingNoCount(), CuVectorUnitTestApplyFloor(), CuVectorUnitTestApplyFloorNoCount(), CuVectorUnitTestApplyPow(), CuVectorUnitTestApplySoftMax(), CuVectorUnitTestApproxEqual(), CuVectorUnitTestCopyCross(), CuVectorUnitTestCopyCross2(), CuVectorUnitTestCopyDiagFromMat(), CuVectorUnitTestCopyDiagFromPacked(), CuVectorUnitTestCopyElements(), CuVectorUnitTestCopyFromMat(), CuVectorUnitTestInvertElements(), CuVectorUnitTestMax(), CuVectorUnitTestMin(), CuVectorUnitTestScale(), CuVectorUnitTestSum(), CuVectorUnitTestVecVec(), fst::GenAcceptorFromSequence(), kaldi::nnet3::GenerateConfigSequenceCnn(), kaldi::nnet3::GenerateConfigSequenceLstm(), kaldi::nnet3::GenerateConfigSequenceLstmType2(), kaldi::nnet3::GenerateConfigSequenceLstmWithTruncation(), kaldi::nnet3::GenerateConfigSequenceRnn(), kaldi::nnet3::GenerateConfigSequenceRnnClockwork(), kaldi::nnet3::GenerateConfigSequenceSimple(), kaldi::nnet3::GenerateConfigSequenceSimpleContext(), kaldi::nnet3::GenerateConfigSequenceSimplest(), kaldi::nnet3::GenerateRandomComponentConfig(), GenRandContextDependency(), GenRandContextDependencyLarge(), kaldi::nnet3::GenRandDescriptor(), kaldi::nnet3::GenRandForwardingDescriptor(), fst::GenRandPhoneSeq(), GenRandStats(), kaldi::nnet3::GenRandSumDescriptor(), GetOutput(), GetRandChar(), GetRandDelim(), InitRandomGmm(), AmSgmm2::LogLikelihood(), main(), MyTaskClass::operator()(), kaldi::nnet2::PreconditionDirections(), fst::RandFst(), RandFstOptions::RandFstOptions(), RandInt(), fst::RandomCompactLatticeWeight(), RandomEventMap(), RandomizeVector(), fst::RandomLatticeWeight(), RandomState::RandomState(), fst::RandPairFst(), RandPosdefSpMatrix(), RandUniform(), kaldi::nnet1::RandUniform(), fst::TestAcceptorMinimize(), fst::TestAddSelfLoops(), TestAddToClustersOptimized(), TestBuildTree(), TestBuildTreeStatsIo(), TestClusterBottomUp(), TestClusterEventMap(), TestClusterEventMapGetMappingAndRenumberEventMap(), TestClusterEventMapGetMappingAndRenumberEventMap2(), TestClusterEventMapRestricted(), TestClusterKMeans(), TestClusterKMeansVector(), TestClusterTopDown(), TestClusterUtils(), TestClusterUtilsVector(), TestContainsNullPointers(), TestContextDep(), fst::TestContextFst(), fst::TestConvert(), fst::TestConvert2(), fst::TestConvertPair(), TestCopyMapKeysToSet(), TestCopyMapKeysToVector(), TestCopyMapToVector(), TestCopyMapValuesToSet(), TestCopyMapValuesToVector(), TestCopySetToVector(), TestCuFindRowMaxId(), TestCuMatrixCompObjfAndDeriv(), TestCuMatrixLookup(), TestCuSparseMatrixTraceMatSmat(), fst::TestDeterminize(), fst::TestDeterminize2(), fst::TestDeterminizeGeneral(), fst::TestDeterminizeLattice(), fst::TestDeterminizeLatticePruned(), TestEditDistance2(), TestEditDistance2String(), fst::TestEnsureEpsilonProperty(), fst::TestEqualAlign(), WordAlignedLatticeTester::TestEquivalent(), TestEventMap(), TestEventMapIo(), TestEventMapMapValues(), TestEventMapPrune(), TestEventTypeIo(), fst::TestFactor(), TestFmpe(), TestGenRandContextDependency(), TestGenRandStats(), TestHashList(), TestHmmTopology(), TestIsSorted(), TestIsSortedAndUniq(), TestIvectorExtractorIO(), TestIvectorExtractorStatsIO(), fst::TestLatticeStringRepository(), TestLatticeTableCross(), TestLevenshteinAlignment(), fst::TestMakeLinearAcceptor(), fst::TestMakeLoopFst(), fst::TestMakeSymbolsSame(), fst::TestMakeSymbolsSameClass(), TestMergePairVectorSumming(), fst::TestMinimize(), TestMinimizeCompactLattice(), TestMonophoneContextDependency(), kaldi::nnet3::TestNnetComponentIo(), TestOnlineCmnInput(), TestOnlineDeltaInput(), TestOnlineFeatureMatrix(), TestOnlineLdaInput(), TestOnlineMatrixInput(), fst::TestPreDeterminize(), fst::TestPruneSpecial(), fst::TestPush(), TestPushCompactLatticeStrings(), TestPushCompactLatticeWeights(), fst::TestPushInLog(), fst::TestPushSpecial(), TestQuestionsInitRand(), TestRefineClusters(), fst::TestRemoveEpsLocal(), fst::TestRemoveEpsLocalSpecial(), TestReverseVector(), fst::TestSafeDeterminizeWrapper(), fst::TestScalePair(), TestSetOfNumbers(), TestShareEventMapLeaves(), kaldi::nnet3::TestSimpleComponentDataDerivative(), kaldi::nnet3::TestSimpleComponentPropagateProperties(), TestSortAndUniq(), TestSplitDecisionTree(), TestSplitStatsByKey(), TestSplitStringToVector(), fst::TestStringRepository(), fst::TestTableMatcher(), fst::TestTableMatcherCacheLeft(), fst::TestTableMatcherCacheRight(), TestTaskSequencer(), TestTreeCluster(), TestUniq(), TestWordAlignedLattice(), UnitTestAddDiagMat2(), UnitTestAddDiagMatMat(), UnitTestAddDiagVecMat(), kaldi::nnet2::UnitTestAdditiveNoiseComponent(), UnitTestAddMat2(), UnitTestAddMat2Sp(), UnitTestAddMatDiagVec(), UnitTestAddMatMatElements(), UnitTestAddMatSelf(), UnitTestAddMatSmat(), UnitTestAddOuterProductPlusMinus(), UnitTestAddRows(), UnitTestAddSp(), UnitTestAddToDiag(), UnitTestAddToDiagMatrix(), UnitTestAddToRows(), UnitTestAddVec2Sp(), UnitTestAddVecToCols(), UnitTestAddVecToRows(), UnitTestAddVecVec(), kaldi::nnet2::UnitTestAffineComponent(), kaldi::nnet2::UnitTestAffineComponentPreconditioned(), kaldi::nnet2::UnitTestAffineComponentPreconditionedOnline(), UnitTestAssertFunc(), UnitTestAxpy(), UnitTestBackpropLstmNonlinearity(), kaldi::nnet2::UnitTestBlockAffineComponent(), kaldi::nnet2::UnitTestBlockAffineComponentPreconditioned(), UnitTestCholesky(), UnitTestComplexFft(), UnitTestComplexFt(), UnitTestCompressedMatrix(), kaldi::nnet3::UnitTestComputationRequestIo(), kaldi::nnet2::UnitTestConvolutional1dComponent(), UnitTestCopyCols(), UnitTestCopyRows(), UnitTestCopyRowsAndCols(), UnitTestCopySp(), UnitTestCopyToRows(), UnitTestCuApproxEqual(), UnitTestCuArray(), UnitTestCuBlockMatrixAddMatBlock(), UnitTestCuBlockMatrixAddMatMat(), UnitTestCuBlockMatrixIO(), UnitTestCuCholesky(), UnitTestCuCopy(), UnitTestCuDiffNormalizePerRow(), UnitTestCuDiffXent(), UnitTestCuFindRowMaxId(), UnitTestCuLogSoftmax(), UnitTestCuMathComputeLstmNonlinearity(), UnitTestCuMathCopy(), UnitTestCuMathNormalizePerRow(), UnitTestCuMathRandomize(), UnitTestCuMathSplice(), UnitTestCuMatrixAdd(), UnitTestCuMatrixAdd2(), UnitTestCuMatrixAddCols(), UnitTestCuMatrixAddDiagVecMat(), UnitTestCuMatrixAddElements(), UnitTestCuMatrixAddMat(), UnitTestCuMatrixAddMatDiagVec(), UnitTestCuMatrixAddMatMatElements(), UnitTestCuMatrixAddMatTp(), UnitTestCuMatrixAddRowRanges(), UnitTestCuMatrixAddRows(), UnitTestCuMatrixAddToDiag(), UnitTestCuMatrixAddToElements(), UnitTestCuMatrixAddToRows(), UnitTestCuMatrixAddTpMat(), UnitTestCuMatrixApplyCeiling(), UnitTestCuMatrixApplyExp(), UnitTestCuMatrixApplyExpLimited(), UnitTestCuMatrixApplyExpSpecial(), UnitTestCuMatrixApplyFloor(), UnitTestCuMatrixApplyHeaviside(), UnitTestCuMatrixApplyLog(), UnitTestCuMatrixApplyPow(), UnitTestCuMatrixApplyPowAbs(), UnitTestCuMatrixCopyCols(), UnitTestCuMatrixCopyColsFromVec(), UnitTestCuMatrixCopyCross(), UnitTestCuMatrixCopyCross2(), UnitTestCuMatrixCopyFromMat(), UnitTestCuMatrixCopyFromTp(), UnitTestCuMatrixCopyLowerToUpper(), UnitTestCuMatrixCopyRows(), UnitTestCuMatrixCopyRowsFromVec(), UnitTestCuMatrixCopyToRows(), UnitTestCuMatrixCopyUpperToLower(), UnitTestCuMatrixDiffGroupPnorm(), UnitTestCuMatrixDivElements(), UnitTestCuMatrixGroupMax(), UnitTestCuMatrixGroupMaxDeriv(), UnitTestCuMatrixGroupPnorm(), UnitTestCuMatrixHeaviside(), UnitTestCuMatrixIO(), UnitTestCuMatrixLookup(), UnitTestCuMatrixMulElements(), UnitTestCuMatrixMulRows(), UnitTestCuMatrixMulRowsGroupMat(), UnitTestCuMatrixMulRowsVec(), UnitTestCuMatrixObjfDeriv(), UnitTestCuMatrixReduceMax(), UnitTestCuMatrixReduceMin(), UnitTestCuMatrixReduceSum(), UnitTestCuMatrixScale(), UnitTestCuMatrixSet(), UnitTestCuMatrixSetMatMatDivMat(), UnitTestCuMatrixSetRandn(), UnitTestCuMatrixSetRandUniform(), UnitTestCuMatrixSetZeroAboveDiag(), UnitTestCuMatrixSigmoid(), UnitTestCuMatrixSoftHinge(), UnitTestCuMatrixSumColumnRanges(), UnitTestCuMatrixSymAddMat2(), UnitTestCuMatrixSymInvertPosDef(), UnitTestCuMatrixTraceMatMat(), UnitTestCuMatrixTranspose(), UnitTestCuPackedMatrixAddToDiag(), UnitTestCuPackedMatrixScale(), UnitTestCuPackedMatrixScaleDiag(), UnitTestCuPackedMatrixSetUnit(), UnitTestCuPackedMatrixTrace(), UnitTestCuSoftmax(), UnitTestCuSparseMatrixConstructFromIndexes(), UnitTestCuSparseMatrixCopyToSmat(), UnitTestCuSparseMatrixFrobeniusNorm(), UnitTestCuSparseMatrixSelectRowsAndTranspose(), UnitTestCuSparseMatrixSum(), UnitTestCuSparseMatrixSwap(), UnitTestCuSparseMatrixTraceMatSmat(), UnitTestCuSpMatrixAddMat2(), UnitTestCuSpMatrixAddSp(), UnitTestCuSpMatrixAddVec2(), UnitTestCuSpMatrixApproxEqual(), UnitTestCuSpMatrixCopyFromMat(), UnitTestCuSpMatrixInvert(), UnitTestCuSpMatrixIO(), UnitTestCuSpMatrixSetUnit(), UnitTestCuSpMatrixTraceSpSp(), UnitTestCuSubMatrix(), UnitTestCuSubVector(), UnitTestCuTpMatrixCholesky(), UnitTestCuTpMatrixCopyFromMat(), UnitTestCuTpMatrixCopyFromTp(), UnitTestCuTpMatrixInvert(), UnitTestCuTpMatrixIO(), UnitTestCuVectorIO(), UnitTestCuVectorReplaceValue(), UnitTestDct(), kaldi::nnet2::UnitTestDctComponent(), kaldi::nnet3::UnitTestDescriptorIo(), UnitTestDeterminant(), UnitTestDeterminantSign(), UnitTestDotprod(), kaldi::nnet2::UnitTestDropoutComponent(), UnitTestEigSp(), UnitTestEigSymmetric(), UnitTestEnsureNonzero(), UnitTestEstimateDiagGmm(), UnitTestEstimateMmieDiagGmm(), UnitTestExtractCompressedMatrix(), UnitTestFactorizeTpl(), UnitTestFFTbasedBlockConvolution(), UnitTestFFTbasedConvolution(), kaldi::nnet2::UnitTestFixedAffineComponent(), kaldi::nnet2::UnitTestFixedBiasComponent(), kaldi::nnet2::UnitTestFixedLinearComponent(), kaldi::nnet2::UnitTestFixedScaleComponent(), UnitTestFloorCeiling(), UnitTestFloorChol(), UnitTestFloorUnit(), UnitTestFmllrRaw(), UnitTestFullGmmEst(), UnitTestGcdLcmTpl(), kaldi::nnet3::UnitTestGeneralDescriptor(), UnitTestGeneralMatrix(), kaldi::nnet2::UnitTestGenericComponent(), kaldi::nnet2::UnitTestGenericComponentInternal(), UnitTestHeaviside(), UnitTestHtkIo(), UnitTestInnerProd(), UnitTestInverse(), UnitTestInvert(), UnitTestIo(), UnitTestIoCross(), UnitTestIoNew(), UnitTestIoPipe(), UnitTestIvectorExtractor(), UnitTestLbfgs(), UnitTestLimitCond(), UnitTestLimitCondInvert(), UnitTestLinearCgd(), UnitTestLogAddSub(), UnitTestMat2Vec(), UnitTestMatrix(), UnitTestMax2(), UnitTestMaxMin(), kaldi::nnet2::UnitTestMaxoutComponent(), kaldi::nnet2::UnitTestMaxpoolingComponent(), UnitTestMmul(), UnitTestMmulSym(), UnitTestMul(), UnitTestMulElements(), UnitTestMulTp(), kaldi::nnet3::UnitTestNnetComputationIo(), kaldi::nnet3::UnitTestNnetIo(), UnitTestNonsymmetricPower(), UnitTestNorm(), UnitTestOnlineCmvn(), UnitTestOrthogonalizeRows(), UnitTestPca(), UnitTestPldaEstimation(), kaldi::nnet2::UnitTestPnormComponent(), UnitTestPosteriors(), UnitTestPower(), UnitTestPowerAbs(), kaldi::nnet2::UnitTestPreconditionDirections(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), UnitTestRand(), UnitTestRandCategorical(), UnitTestRange(), UnitTestRankNUpdate(), UnitTestRealFft(), UnitTestRegressionTree(), UnitTestRegtreeFmllrDiagGmm(), UnitTestRemoveRow(), UnitTestReplaceValue(), UnitTestResize(), UnitTestResizeCopyDataDifferentStrideType(), UnitTestRow(), UnitTestScale(), kaldi::nnet2::UnitTestScaleComponent(), UnitTestScaleDiag(), UnitTestSetDiag(), UnitTestSetRandn(), UnitTestSetRandUniform(), UnitTestSger(), UnitTestSigmoid(), kaldi::nnet2::UnitTestSigmoidComponent(), UnitTestSimple(), UnitTestSimpleForMat(), UnitTestSimpleForVec(), UnitTestSoftHinge(), UnitTestSolve(), kaldi::nnet2::UnitTestSolvePackingProblem(), UnitTestSpAddDiagVec(), UnitTestSpAddVecVec(), UnitTestSparseMatrixAddToMat(), UnitTestSparseMatrixFrobeniusNorm(), UnitTestSparseMatrixSum(), UnitTestSparseMatrixTraceMatSmat(), UnitTestSparseVectorAddToVec(), UnitTestSparseVectorMax(), UnitTestSparseVectorSum(), UnitTestSparseVectorVecSvec(), UnitTestSpInvert(), UnitTestSpliceRows(), kaldi::nnet3::UnitTestSplitLocations(), kaldi::nnet3::UnitTestSplitLocationsBackward(), UnitTestSplitRadixComplexFft(), UnitTestSplitRadixComplexFft2(), UnitTestSplitRadixRealFft(), kaldi::nnet2::UnitTestSumGroupComponent(), UnitTestSvd(), UnitTestSvdJustvec(), UnitTestSvdNodestroy(), UnitTestSvdZero(), UnitTestSymAddMat2(), UnitTestTableRandomBothDouble(), UnitTestTableRandomBothDoubleMatrix(), UnitTestTableSequentialBaseFloatVectorBoth(), UnitTestTableSequentialBool(), UnitTestTableSequentialDouble(), UnitTestTableSequentialDoubleBoth(), UnitTestTableSequentialDoubleMatrixBoth(), UnitTestTableSequentialInt32(), UnitTestTableSequentialInt32PairVectorBoth(), UnitTestTableSequentialInt32Script(), UnitTestTableSequentialInt32VectorBoth(), UnitTestTableSequentialInt32VectorVectorBoth(), UnitTestTanh(), UnitTestTp2(), UnitTestTp2Sp(), UnitTestTpInvert(), UnitTestTrace(), UnitTestTraceProduct(), UnitTestTraceSpSpLower(), UnitTestTrain(), UnitTestTranspose(), UnitTestTransposeScatter(), UnitTestTridiagonalize(), UnitTestTridiagonalizeAndQr(), UnitTestTriVecSolver(), UnitTestVecMatVec(), UnitTestVecmul(), UnitTestVector(), UnitTestVectorMax(), UnitTestVectorMin(), UnitTextCuMatrixAddMatSmat(), UnitTextCuMatrixAddSmat(), UnitTextCuMatrixAddSmatMat(), and WithProb().

                                    {
#if !defined(_POSIX_THREAD_SAFE_FUNCTIONS)
  // On Windows and Cygwin, just call Rand()
  return rand();
#else
  if (state) {
    return rand_r(&(state->seed));
  } else {
    std::lock_guard<std::mutex> lock(_RandMutex);
    return rand();
  }
#endif
}

RandCompactLattice()

CompactLattice * RandCompactLattice

(

)

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

References fst::ConvertLattice().

Referenced by TestCompactLatticeTable(), TestCompactLatticeTableCross(), TestPushCompactLatticeStrings(), and TestPushCompactLatticeWeights().

                                     {
  Lattice *fst = fst::RandPairFst<LatticeArc>();
  CompactLattice *cfst = new CompactLattice;
  ConvertLattice(*fst, cfst);
  delete fst;
  return cfst;
}

RandDeterministicCompactLattice()

CompactLattice* kaldi::RandDeterministicCompactLattice

(

)

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

References RandFstOptions::acyclic, fst::DeterminizeLattice(), and KALDI_WARN.

Referenced by TestMinimizeCompactLattice().

                                                  {
  RandFstOptions opts;
  opts.acyclic = true;
  while (1) {
    Lattice *fst = fst::RandPairFst<LatticeArc>(opts);
    CompactLattice *cfst = new CompactLattice;
    if (!DeterminizeLattice(*fst, cfst)) {
      delete fst;
      delete cfst;
      KALDI_WARN << "Determinization failed, trying again.";
    } else {
      delete fst;
      return cfst;
    }
  }
}

RandFullCova()

static void kaldi::RandFullCova ( Matrix< BaseFloat > *  matrix )

static

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

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::Cond(), MatrixBase< Real >::CopyFromSp(), KALDI_ASSERT, KALDI_ERR, kNoTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and MatrixBase< Real >::SetRandn().

Referenced by generate_features().

                                        {
  size_t dim = matrix->NumCols();
  KALDI_ASSERT(matrix->NumCols() == matrix->NumRows());

  size_t iter = 0;
  size_t max_iter = 10000;
  // generate random (non-singular) matrix
  // until condition
  Matrix<BaseFloat> tmp(dim, dim);
  SpMatrix<BaseFloat> tmp2(dim);
  while (iter < max_iter) {
    tmp.SetRandn();
    if (tmp.Cond() < 100) break;
    iter++;
  }
  if (iter >= max_iter) {
    KALDI_ERR << "Internal error: found no random covariance matrix.";
  }
  // tmp * tmp^T will give positive definite matrix
  tmp2.AddMat2(1.0, tmp, kNoTrans, 0.0);
  matrix->CopyFromSp(tmp2);
}

RandGauss()

float kaldi::RandGauss ( struct RandomState *  state = NULL )

inline

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

References Log(), M_PI, RandGauss2(), RandPoisson(), and RandUniform().

Referenced by _RandGauss(), Dither(), DiagGmm::Generate(), generate_features(), GenRandStats(), OnlineProcessPitch::GetDeltaPitchFeature(), init_rand_diag_gmm(), InitRand(), kaldi::unittest::InitRandDiagGmm(), kaldi::unittest::InitRandFullGmm(), InitRandNonsingular(), InitRandomGmm(), DiagGmm::Perturb(), PlaceNansInGaps(), rand_diag_gmm(), kaldi::unittest::RandDiagGaussFeatures(), kaldi::unittest::RandFullGaussFeatures(), fst::RandomLatticeWeight(), VectorBase< float >::SetRandn(), PackedMatrix< float >::SetRandn(), SparseVector< Real >::SetRandn(), MatrixBase< float >::SetRandn(), DiagGmm::Split(), TestAddToClustersOptimized(), TestAmDiagGmmIO(), TestClusterEventMapRestricted(), TestClustering(), TestClusterUtils(), TestContextDep(), TestFmpe(), TestSgmm2Fmllr(), TestSgmm2IncreaseDim(), TestSgmm2Init(), TestSgmm2IO(), TestSgmm2Substates(), TestShareEventMapLeaves(), TestSplitDecisionTree(), TestSplitStates(), UnitTestComplexPower(), UnitTestCompressedMatrix(), UnitTestCuSpMatrixAddVec2(), UnitTestDelay(), UnitTestDiagGmm(), UnitTestEstimateDiagGmm(), UnitTestEstimateFullGmm(), UnitTestEstimateLda(), UnitTestEstimateMmieDiagGmm(), UnitTestEstimateSgmm2(), UnitTestFullGmm(), UnitTestGeneralMatrix(), UnitTestMleAmDiagGmm(), UnitTestNorm(), UnitTestPieces(), UnitTestRand(), UnitTestSearch(), UnitTestSparseMatrixConstructor(), UnitTestSpInvert(), UnitTestTableSequentialBaseFloatVectorBoth(), UnitTestTableSequentialDoubleMatrixBoth(), UnitTestTopEigs(), UnitTestTpInvert(), and UnitTestTransposeScatter().

                                                         {
  return static_cast<float>(sqrtf (-2 * Log(RandUniform(state)))
                            * cosf(2*M_PI*RandUniform(state)));
}

RandGauss2() [1/2]

void RandGauss2	(	float *	a,
		float *	b,
		RandomState *	state
	)

Definition at line 139 of file kaldi-math.cc.

References KALDI_ASSERT, M_PI, and RandUniform().

Referenced by RandGauss(), RandGauss2(), VectorBase< float >::SetRandn(), MatrixBase< float >::SetRandn(), and UnitTestRand().

                                                        {
  KALDI_ASSERT(a);
  KALDI_ASSERT(b);
  float u1 = RandUniform(state);
  float u2 = RandUniform(state);
  u1 = sqrtf(-2.0f * logf(u1));
  u2 =  2.0f * M_PI * u2;
  *a = u1 * cosf(u2);
  *b = u1 * sinf(u2);
}

RandGauss2() [2/2]

void RandGauss2	(	double *	a,
		double *	b,
		RandomState *	state
	)

Definition at line 150 of file kaldi-math.cc.

References KALDI_ASSERT, and RandGauss2().

                                                          {
  KALDI_ASSERT(a);
  KALDI_ASSERT(b);
  float a_float, b_float;
  // Just because we're using doubles doesn't mean we need super-high-quality
  // random numbers, so we just use the floating-point version internally.
  RandGauss2(&a_float, &b_float, state);
  *a = a_float;
  *b = b_float;
}

RandInt()

int32 RandInt	(	int32	min_val,
		int32	max_val,
		struct RandomState *	state
	)

Definition at line 95 of file kaldi-math.cc.

References KALDI_ASSERT, KALDI_ERR, and Rand().

Referenced by ComputationGraphBuilder::Check(), kaldi::nnet3::time_height_convolution::CheckModelAndIo(), ComputationGraphBuilder::Compute(), kaldi::nnet3::ConstrainOrthonormal(), CuCompressedMatrixTestNonnegative(), CuCompressedMatrixTestSign(), CuCompressedMatrixTestSymmetric(), fst::EqualAlign(), kaldi::nnet3::FindNStride(), GenerateCompactLatticeRandomly(), kaldi::nnet3::GenerateConfigSequence(), kaldi::nnet3::GenerateConfigSequenceCnnNew(), kaldi::nnet3::GenerateConfigSequenceCompositeBlock(), kaldi::nnet3::GenerateConfigSequenceDistribute(), kaldi::nnet3::GenerateConfigSequenceLstmType2(), kaldi::nnet3::GenerateConfigSequenceLstmWithTruncation(), kaldi::nnet3::GenerateConfigSequenceRestrictedAttention(), kaldi::nnet3::GenerateConfigSequenceRnn(), kaldi::nnet3::GenerateConfigSequenceSimple(), kaldi::nnet3::GenerateConfigSequenceSimpleContext(), kaldi::nnet3::GenerateConfigSequenceStatistics(), GenerateLexicon(), GeneratePathThroughHmm(), kaldi::nnet3::GenerateRandomComponentConfig(), kaldi::nnet3::GenerateSimpleNnetTrainingExample(), GenerateWordAndPhoneSequence(), GenRandTopology(), GetBootstrapWERInterval(), GetBootstrapWERTwoSystemComparison(), UtteranceSplitter::GetChunkSizesForUtterance(), GeneralDropoutComponent::GetMemo(), SpecAugmentTimeMaskComponent::GetMemo(), kaldi::nnet3::GetNumNvalues(), NnetComputer::GetPointers(), kaldi::nnet3::time_height_convolution::GetRandomConvolutionIndexes(), kaldi::nnet3::time_height_convolution::GetRandomConvolutionModel(), InitGmmFromRandomFrames(), Questions::InitRand(), kaldi::nnet3::InsertCommands(), main(), PlaceNansInGaps(), TdnnComponent::PrecomputeIndexes(), kaldi::nnet3::ProcessFile(), kaldi::nnet3::SelectFromExample(), kaldi::nnet3::SetDerivTimesOptions(), NonlinearComponent::StoreBackpropStats(), RestrictedAttentionComponent::StoreStats(), SigmoidComponent::StoreStats(), TanhComponent::StoreStats(), RectifiedLinearComponent::StoreStats(), NnetDiscriminativeSupervision::Swap(), NnetChainSupervision::Swap(), TestAccumulateTreeStatsOptions(), TestAmDiagGmmAccsIO(), kaldi::nnet3::attention::TestAttentionForwardBackward(), kaldi::nnet3::time_height_convolution::TestComputationIo(), TestConvertAlignment(), TestCuMatrixResize(), TestCuVectorApplyCeiling(), TestCuVectorApplyCeilingNoCount(), TestCuVectorApplyFloor(), TestCuVectorApplyFloorNoCount(), TestDoTableSplit(), TestFindAllKeys(), TestHmmTopology(), TestMllrAccsIO(), kaldi::nnet3::TestNnetDecodable(), TestOnlineMfcc(), kaldi::nnet3::time_height_convolution::TestParamsBackprop(), TestPossibleValues(), TestPosteriorIo(), TestSgmm2Fmllr(), kaldi::nnet3::TestSimpleComponentDataDerivative(), kaldi::nnet3::TestSimpleComponentModelDerivative(), kaldi::nnet3::TestSimpleComponentPropagateProperties(), TestSplitToPhones(), TestWordAlignLatticeLexicon(), UnitTestAddMatMatNans(), UnitTestAmDiagGmm(), UnitTestApplyExpSpecial(), kaldi::nnet3::attention::UnitTestAttentionDotProductAndAddScales(), UnitTestBackpropLstmNonlinearity(), kaldi::nnet3::UnitTestCindexIo(), UnitTestCompressedMatrix(), UnitTestCompressedMatrix2(), UnitTestCuDiffLogSoftmax(), UnitTestCuDiffSoftmax(), UnitTestCuMathComputeLstmNonlinearity(), UnitTestCuMatrixAddMatBlocks1(), UnitTestCuMatrixAddMatBlocks1Trans(), UnitTestCuMatrixAddMatBlocks2(), UnitTestCuVectorSum(), UnitTestDiagGmm(), UnitTestDivideRoundingDown(), kaldi::nnet3::UnitTestEnsureContiguousProperty(), UnitTestEnsureNonzero(), UnitTestEstimateLda(), UnitTestEstimateMmieDiagGmm(), UnitTestEstimateSgmm2(), UnitTestFullGmm(), UnitTestGeneralMatrix(), kaldi::nnet3::UnitTestHasContiguousProperty(), kaldi::nnet3::UnitTestIndexIo(), UnitTestIo(), UnitTestLstmNonlinearity(), UnitTestMatrixAddMatSmat(), UnitTestMatrixAddSmatMat(), UnitTestMleAmDiagGmm(), kaldi::nnet3::UnitTestNnetAnalyze(), kaldi::nnet3::UnitTestNnetCompileLooped(), kaldi::nnet3::UnitTestNnetCompute(), kaldi::nnet3::UnitTestNnetExample(), kaldi::nnet3::UnitTestNnetInputDerivatives(), kaldi::nnet3::UnitTestNnetMergeExamples(), kaldi::nnet3::UnitTestNnetModelDerivatives(), kaldi::nnet3::UnitTestNnetOptimizeInternal(), kaldi::nnet3::UnitTestNnetOptimizeWithOptions(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), UnitTestRand(), UnitTestRangesMatrix(), UnitTestRegressionTree(), UnitTestRegtreeMllrDiagGmm(), UnitTestSgmm2(), UnitTestSparseMatrixConstructor(), UnitTestSparseVectorMax(), kaldi::nnet2::UnitTestSpliceComponent(), UnitTestTableSequentialBaseFloatVectorBoth(), UnitTestTableSequentialBool(), UnitTestTableSequentialDouble(), UnitTestTableSequentialDoubleBoth(), UnitTestTableSequentialInt32(), UnitTestTableSequentialInt32PairVectorBoth(), UnitTestTableSequentialInt32Script(), UnitTestTableSequentialInt32VectorBoth(), and kaldi::nnet3::time_height_convolution::UnitTestTimeHeightConvolutionIo().

                                                                       {
  // This is not exact.
  KALDI_ASSERT(max_val >= min_val);
  if (max_val == min_val) return min_val;

#ifdef _MSC_VER
  // RAND_MAX is quite small on Windows -> may need to handle larger numbers.
  if (RAND_MAX > (max_val-min_val)*8) {
        // *8 to avoid large inaccuracies in probability, from the modulus...
    return min_val +
      ((unsigned int)Rand(state) % (unsigned int)(max_val+1-min_val));
  } else {
    if ((unsigned int)(RAND_MAX*RAND_MAX) >
        (unsigned int)((max_val+1-min_val)*8)) {
        // *8 to avoid inaccuracies in probability, from the modulus...
      return min_val + ( (unsigned int)( (Rand(state)+RAND_MAX*Rand(state)))
                    % (unsigned int)(max_val+1-min_val));
    } else {
      KALDI_ERR << "rand_int failed because we do not support such large "
          "random numbers. (Extend this function).";
    }
  }
#else
  return min_val +
      (static_cast<int32>(Rand(state)) % static_cast<int32>(max_val+1-min_val));
#endif
}

RandLattice()

Lattice* kaldi::RandLattice

(

)

Definition at line 36 of file kaldi-lattice-test.cc.

Referenced by TestLatticeTable(), and TestLatticeTableCross().

                       {
  Lattice *fst = fst::RandPairFst<LatticeArc>();
  return fst;
}

RandomEventMap()

EventMap* kaldi::RandomEventMap

(

const std::vector< EventKeyType > &

keys

)

Definition at line 145 of file event-map-test.cc.

References CopySetToVector(), rnnlm::i, KALDI_ASSERT, kMaxVal, Rand(), RandPoisson(), and RandUniform().

Referenced by TestEventMapIo(), TestEventMapMapValues(), and TestEventMapPrune().

                                                              {
  // Do not mess with the probabilities inside this routine or there
  // is a danger this function will blow up.
  int32 max_val = kMaxVal;
  KALDI_ASSERT(keys.size() != 0);
  float f = RandUniform();
  if (f < 0.333) {  // w.p. 0.333, return ConstantEventMap.
    return new ConstantEventMap(Rand() % max_val);
  } else if (f < 0.666) {  // w.p. 0.333, return TableEventMap.
    float nonnull_prob = 0.3;  // prob of a non-NULL pointer.
    float expected_table_size = 3.0;
    int32 table_size = RandPoisson(expected_table_size);
    // fertility from this branch is 0.333 * 3.0 * 0.2333 = 0.3.
    EventKeyType key = keys[Rand() % keys.size()];
    std::vector<EventMap*> table(table_size);
    for (size_t t = 0; t < (size_t)table_size; t++) {
      if (RandUniform() < nonnull_prob) table[t] = RandomEventMap(keys);
      else table[t] = NULL;
    }
    return new TableEventMap(key, table);
  } else {  // w.p. 0.333, return SplitEventMap.
    // Fertility of this stage is 0.333 * 2 = 0.666.
    EventKeyType key = keys[Rand() % keys.size()];
    std::set<EventValueType> yes_set;
    for (size_t i = 0; i < 5; i++) yes_set.insert(Rand() % max_val);
    std::vector<EventValueType> yes_vec;
    CopySetToVector(yes_set, &yes_vec);
    EventMap *yes = RandomEventMap(keys), *no = RandomEventMap(keys);
    return new SplitEventMap(key, yes_vec, yes, no);
  }
  // total fertility is 0.3 + 0.666 = 0.9666, hence this will terminate with finite memory (w.p.1)
}

RandomizeVector()

void kaldi::RandomizeVector

(

std::vector< T > *

v

)

Definition at line 754 of file kaldi-table-test.cc.

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

Referenced by UnitTestTableRandomBothDouble(), and UnitTestTableRandomBothDoubleMatrix().

                                                        {
  if (v->size() > 1) {
    for (size_t i = 0; i < 10; i++) {
      size_t j = Rand() % v->size(),
          k = Rand() % v->size();
      if (j != k)
        std::swap((*v)[j], (*v)[k]);
    }
  }
}

RandomSplit()

bool kaldi::RandomSplit	(	int32	wav_dim,
		std::vector< int32 > *	piece_dim,
		int32	num_pieces,
		int32	trials = 5
	)

Definition at line 57 of file online-feature-test.cc.

References rnnlm::i.

Referenced by TestOnlineAppendFeature(), TestOnlineMfcc(), and TestOnlinePlp().

                                   {
  piece_dim->clear();
  piece_dim->resize(num_pieces, 0);

  int32 dim_mean = wav_dim / (num_pieces * 2);
  int32 cnt = 0;
  while (true) {
    int32 dim_total = 0;
    for (int32 i = 0; i < num_pieces - 1; i++) {
      (*piece_dim)[i] = dim_mean + rand() % dim_mean;
      dim_total += (*piece_dim)[i];
    }
    (*piece_dim)[num_pieces - 1] = wav_dim - dim_total;

    if (dim_total > 0 && dim_total < wav_dim)
      break;
    if (++cnt > trials)
      return false;
  }
  return true;
}

RandPoisson()

int32 RandPoisson	(	float	lambda,
		struct RandomState *	state
	)

Definition at line 126 of file kaldi-math.cc.

References KALDI_ASSERT, and RandUniform().

Referenced by RandGauss(), RandomEventMap(), and UnitTestRand().

                                                           {
  // Knuth's algorithm.
  KALDI_ASSERT(lambda >= 0);
  float L = expf(-lambda), p = 1.0;
  int32 k = 0;
  do {
    k++;
    float u = RandUniform(state);
    p *= u;
  } while (p > L);
  return k-1;
}

RandPosdefSpMatrix()

void kaldi::RandPosdefSpMatrix	(	MatrixIndexT	dim,
		SpMatrix< Real > *	matrix
	)

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

References SpMatrix< Real >::AddMat2(), TpMatrix< Real >::Cholesky(), KALDI_LOG, kNoTrans, and Rand().

Referenced by UnitTestFullGmm(), UnitTestLbfgs(), UnitTestLinearCgd(), and UnitTestSolve().

                                                                  {
  MatrixIndexT dim2 = dim + (Rand() % 3);  // slightly higher-dim.
  // generate random (non-singular) matrix
  Matrix<Real> tmp(dim, dim2);
  while (1) {
    tmp.SetRandn();
    if (tmp.Cond() < 100) break;
    KALDI_LOG << "Condition number of random matrix large "
              << static_cast<float>(tmp.Cond())
              << ", trying again (this is normal)";
  }
  // tmp * tmp^T will give positive definite matrix
  matrix->AddMat2(1.0, tmp, kNoTrans, 0.0);

  // Checks that the matrix is indeed pos-def
  TpMatrix<Real> sqrt(dim);
  sqrt.Cholesky(*matrix);
}

RandPrune()

Float kaldi::RandPrune ( Float  post, BaseFloat  prune_thresh, struct RandomState *  state = NULL  )

inline

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

References KALDI_ASSERT, and RandUniform().

Referenced by NnetLdaStatsAccumulator::AccStatsFromOutput(), MlltAccs::AccumulateFromPosteriors(), MleAmSgmm2Accs::AccumulateFromPosteriors(), MleSgmm2SpeakerAccs::AccumulateFromPosteriors(), main(), and UnitTestRand().

                                                         {
  KALDI_ASSERT(prune_thresh >= 0.0);
  if (post == 0.0 || std::abs(post) >= prune_thresh)
    return post;
  return (post >= 0 ? 1.0 : -1.0) *
      (RandUniform(state) <= fabs(post)/prune_thresh ? prune_thresh : 0.0);
}

RandUniform()

float kaldi::RandUniform ( struct RandomState *  state = NULL )

inline

Returns a random number strictly between 0 and 1.

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

References Rand().

Referenced by CuRand< float >::BinarizeProbs(), LstmNonlinearityComponent::ConsolidateMemory(), DiagGmm::Generate(), kaldi::nnet3::GenerateRandomComponentConfig(), kaldi::nnet3::GenerateSimpleNnetTrainingExample(), GenRandContextDependency(), GenRandContextDependencyLarge(), fst::GenRandPhoneSeq(), GenRandStats(), GeneralDropoutComponent::GetMemo(), init_rand_diag_gmm(), kaldi::unittest::InitRandFullGmm(), InitRandomGmm(), PitchInterpolator::InitValues(), main(), kaldi::nnet3::PerturbImage(), DropoutMaskComponent::Propagate(), DropoutComponent::Propagate(), AdditiveNoiseComponent::Propagate(), rand_diag_gmm(), VectorBase< float >::RandCategorical(), RandGauss(), RandGauss2(), RandomEventMap(), RandPoisson(), RandPrune(), RandZeroToOneMatrix(), SigmoidComponent::RepairGradients(), TanhComponent::RepairGradients(), RectifiedLinearComponent::RepairGradients(), ClipGradientComponent::RepairGradients(), VectorBase< float >::SetRandUniform(), MatrixBase< float >::SetRandUniform(), TestBuildTree(), TestClusterBottomUp(), TestClusterEventMap(), TestClusterEventMapGetMappingAndRenumberEventMap(), TestClusterEventMapGetMappingAndRenumberEventMap2(), TestClusterEventMapRestricted(), TestClustering(), TestClusterKMeans(), TestClusterTopDown(), TestClusterUtilsVector(), fst::TestContextFst(), TestCuMatrixCompObjfAndDeriv(), fst::TestFactor(), TestGenRandStats(), TestPosteriorIo(), TestRefineClusters(), fst::TestRemoveEpsLocal(), TestSgmm2AccsIO(), TestSgmm2Substates(), TestShareEventMapLeaves(), TestSplitStates(), TestTreeCluster(), TestVectorToPosteriorEntry(), UnitTestArbitraryResample(), UnitTestCuMatrixObjfDeriv(), UnitTestDiagGmm(), UnitTestFullGmm(), UnitTestIo(), UnitTestIoNew(), UnitTestIoPipe(), UnitTestLinearResample(), UnitTestRand(), UnitTestRegtreeFmllrDiagGmm(), UnitTestSimpleForVec(), and UnitTestVtln().

                                                           {
  return static_cast<float>((Rand(state) + 1.0) / (RAND_MAX+2.0));
}

RandZeroToOneMatrix()

static void kaldi::RandZeroToOneMatrix ( MatrixBase< Real > *  mat )

static

Definition at line 64 of file cu-matrix-test.cc.

References MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), and RandUniform().

Referenced by UnitTestCuDiffLogSoftmax(), UnitTestCuDiffSigmoid(), UnitTestCuDiffSoftmax(), UnitTestCuDiffTanh(), and UnitTestCuDiffXent().

                                                       {
  for(int32 r=0; r<mat->NumRows(); r++)
    for(int32 c=0; c<mat->NumCols(); c++)
      (*mat)(r,c) = RandUniform();
}

ReadCommaSeparatedCommand()

void kaldi::ReadCommaSeparatedCommand	(	const std::string &	s,
		std::vector< BaseFloat > *	v
	)

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

References ConvertStringToReal(), rnnlm::i, and SplitStringToVector().

Referenced by main().

                                                         {
  std::vector<std::string> split_string;
  SplitStringToVector(s, ",", true, &split_string);
  for (size_t i = 0; i < split_string.size(); i++) {
    float ret;
    ConvertStringToReal(split_string[i], &ret);
    v->push_back(ret);
  }
}

ReadCompactLattice()

bool ReadCompactLattice	(	std::istream &	is,
		bool	binary,
		CompactLattice **	clat
	)

Definition at line 304 of file kaldi-lattice.cc.

References ConvertToCompactLattice(), KALDI_ASSERT, KALDI_WARN, and ReadCompactLatticeText().

Referenced by CompactLatticeHolder::Read(), and DiscriminativeNnetExample::Read().

                                               {
  KALDI_ASSERT(*clat == NULL);
  if (binary) {
    fst::FstHeader hdr;
    if (!hdr.Read(is, "<unknown>")) {
      KALDI_WARN << "Reading compact lattice: error reading FST header.";
      return false;
    }
    if (hdr.FstType() != "vector") {
      KALDI_WARN << "Reading compact lattice: unsupported FST type: "
                 << hdr.FstType();
      return false;
    }
    fst::FstReadOptions ropts("<unspecified>",
                              &hdr);

    typedef fst::CompactLatticeWeightTpl<fst::LatticeWeightTpl<float>, int32> T1;
    typedef fst::CompactLatticeWeightTpl<fst::LatticeWeightTpl<double>, int32> T2;
    typedef fst::LatticeWeightTpl<float> T3;
    typedef fst::LatticeWeightTpl<double> T4;
    typedef fst::VectorFst<fst::ArcTpl<T1> > F1;
    typedef fst::VectorFst<fst::ArcTpl<T2> > F2;
    typedef fst::VectorFst<fst::ArcTpl<T3> > F3;
    typedef fst::VectorFst<fst::ArcTpl<T4> > F4;

    CompactLattice *ans = NULL;
    if (hdr.ArcType() == T1::Type()) {
      ans = ConvertToCompactLattice(F1::Read(is, ropts));
    } else if (hdr.ArcType() == T2::Type()) {
      ans = ConvertToCompactLattice(F2::Read(is, ropts));
    } else if (hdr.ArcType() == T3::Type()) {
      ans = ConvertToCompactLattice(F3::Read(is, ropts));
    } else if (hdr.ArcType() == T4::Type()) {
      ans = ConvertToCompactLattice(F4::Read(is, ropts));
    } else {
      KALDI_WARN << "FST with arc type " << hdr.ArcType()
                 << " cannot be converted to CompactLattice.\n";
      return false;
    }
    if (ans == NULL) {
      KALDI_WARN << "Error reading compact lattice (after reading header).";
      return false;
    }
    *clat = ans;
    return true;
  } else {
    // The next line would normally consume the \r on Windows, plus any
    // extra spaces that might have got in there somehow.
    while (std::isspace(is.peek()) && is.peek() != '\n') is.get();
    if (is.peek() == '\n') is.get(); // consume the newline.
    else { // saw spaces but no newline.. this is not expected.
      KALDI_WARN << "Reading compact lattice: unexpected sequence of spaces "
                 << " at file position " << is.tellg();
      return false;
    }
    *clat = ReadCompactLatticeText(is); // that routine will warn on error.
    return (*clat != NULL);
  }
}

ReadCompactLatticeText()

CompactLattice* kaldi::ReadCompactLatticeText

(

std::istream &

is

)

Definition at line 277 of file kaldi-lattice.cc.

References ConvertToCompactLattice(), and LatticeReader::ReadText().

Referenced by ReadCompactLattice().

                                                       {
  std::pair<Lattice*, CompactLattice*> lat_pair = LatticeReader::ReadText(is);
  if (lat_pair.second != NULL) {
    delete lat_pair.first;
    return lat_pair.second;
  } else if (lat_pair.first != NULL) {
    // note: ConvertToCompactLattice frees its input.
    return ConvertToCompactLattice(lat_pair.first);
  } else {
    return NULL;
  }
}

ReadConfigFromFile()

void kaldi::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.

This function assumes the config has a function "void Register(OptionsItf *opts)" which it can call to register the ParseOptions object.

Definition at line 237 of file parse-options.h.

References ParseOptions::Register().

Referenced by OnlineIvectorExtractionInfo::Init(), OnlineFeaturePipelineConfig::OnlineFeaturePipelineConfig(), and OnlineNnet2FeaturePipelineInfo::OnlineNnet2FeaturePipelineInfo().

                                                {
  std::ostringstream usage_str;
  usage_str << "Parsing config from "
            << "from '" << config_filename << "'";
  ParseOptions po(usage_str.str().c_str());
  c->Register(&po);
  po.ReadConfigFile(config_filename);
}

ReadConfigLines()

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.

Definition at line 564 of file text-utils.cc.

References KALDI_ASSERT.

Referenced by Nnet::ReadConfig(), kaldi::nnet3::ReadEditConfig(), and UnitTestReadConfig().

                                                 {
  KALDI_ASSERT(lines != NULL);
  std::string line;
  while (std::getline(is, line)) {
    if (line.size() == 0) continue;
    size_t start = line.find_first_not_of(" \t");
    size_t end = line.find_first_of('#');
    if (start == std::string::npos || start == end) continue;
    end = line.find_last_not_of(" \t", end - 1);
    KALDI_ASSERT(end >= start);
    lines->push_back(line.substr(start, end - start + 1));
  }
}

ReadConfigsFromFile()

void kaldi::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.

Definition at line 249 of file parse-options.h.

References ParseOptions::Register().

Referenced by OnlineNnet2FeaturePipelineInfo::OnlineNnet2FeaturePipelineInfo().

                                                                      {
  std::ostringstream usage_str;
  usage_str << "Parsing config from "
            << "from '" << conf << "'";
  ParseOptions po(usage_str.str().c_str());
  c1->Register(&po);
  c2->Register(&po);
  po.ReadConfigFile(conf);
}

ReadData()

bool kaldi::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
	)

Definition at line 35 of file nnet-train-multistream.cc.

References VectorBase< Real >::Dim(), SequentialTableReader< Holder >::Done(), RandomAccessTableReader< Holder >::HasKey(), RandomAccessTableReader< Holder >::IsOpen(), KALDI_VLOG, KALDI_WARN, kCopyData, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Vector< Real >::Resize(), Matrix< Real >::Resize(), VectorBase< Real >::Set(), RandomAccessTableReader< Holder >::Value(), and SequentialTableReader< Holder >::Value().

Referenced by main().

                                      {

  // We're looking for the 1st valid utterance...
  for ( ; !feature_reader.Done(); feature_reader.Next()) {
    // Do we have targets?
    const std::string& utt = feature_reader.Key();
    KALDI_VLOG(3) << "Reading: " << utt;
    if (!target_reader.HasKey(utt)) {
      KALDI_WARN << utt << ", missing targets";
      (*num_no_tgt_mat)++;
      continue;
    }
    // Do we have frame-weights?
    if (weights_reader.IsOpen() && !weights_reader.HasKey(utt)) {
      KALDI_WARN << utt << ", missing frame-weights";
      (*num_other_error)++;
      continue;
    }

    // get the (feature,target) pair,
    (*feats) = feature_reader.Value();
    (*targets) = target_reader.Value(utt);

    // getting per-frame weights,
    if (weights_reader.IsOpen()) {
      (*weights) = weights_reader.Value(utt);
    } else {  // all per-frame weights are 1.0
      weights->Resize(feats->NumRows());
      weights->Set(1.0);
    }

    // correct small length mismatch ... or drop sentence
    {
      // add lengths to vector
      std::vector<int32> length;
      length.push_back(feats->NumRows());
      length.push_back(targets->size());
      length.push_back(weights->Dim());
      // find min, max
      int32 min = *std::min_element(length.begin(), length.end());
      int32 max = *std::max_element(length.begin(), length.end());
      // fix or drop ?
      if (max - min < length_tolerance) {
        if (feats->NumRows() != min) feats->Resize(min, feats->NumCols(), kCopyData);
        if (targets->size() != min) targets->resize(min);
        if (weights->Dim() != min) weights->Resize(min, kCopyData);
      } else {
        KALDI_WARN << "Length mismatch! Targets " << targets->size()
                   << ", features " << feats->NumRows() << ", " << utt;
        num_other_error++;
        continue;
      }
    }

    // By getting here we got a valid utterance,
    feature_reader.Next();
    return true;
  }

  // No more data,
  return false;
}

ReadDecodeGraph()

fst::Fst< fst::StdArc > * ReadDecodeGraph

(

const std::string &

filename

)

Definition at line 27 of file onlinebin-util.cc.

References KALDI_ERR, and Input::Stream().

Referenced by main().

                                                              {
  // read decoding network FST
  Input ki(filename); // use ki.Stream() instead of is.
  if (!ki.Stream().good()) KALDI_ERR << "Could not open decoding-graph FST "
                                      << filename;

  fst::FstHeader hdr;
  if (!hdr.Read(ki.Stream(), "<unknown>")) {
    KALDI_ERR << "Reading FST: error reading FST header.";
  }
  if (hdr.ArcType() != fst::StdArc::Type()) {
    KALDI_ERR << "FST with arc type " << hdr.ArcType() << " not supported.";
  }
  fst::FstReadOptions ropts("<unspecified>", &hdr);

  fst::Fst<fst::StdArc> *decode_fst = NULL;

  if (hdr.FstType() == "vector") {
    decode_fst = fst::VectorFst<fst::StdArc>::Read(ki.Stream(), ropts);
  } else if (hdr.FstType() == "const") {
    decode_fst = fst::ConstFst<fst::StdArc>::Read(ki.Stream(), ropts);
  } else {
    KALDI_ERR << "Reading FST: unsupported FST type: " << hdr.FstType();
  }
  if (decode_fst == NULL) { // fst code will warn.
    KALDI_ERR << "Error reading FST (after reading header).";
    return NULL;
  } else {
    return decode_fst;
  }
}

ReadEventType()

void ReadEventType	(	std::istream &	is,
		bool	binary,
		EventType *	evec
	)

Definition at line 239 of file event-map.cc.

References ExpectToken(), rnnlm::i, KALDI_ASSERT, and ReadBasicType().

Referenced by MakeEventPair(), ReadBuildTreeStats(), and TestEventTypeIo().

                                                                 {
  KALDI_ASSERT(evec != NULL);
  ExpectToken(is, binary, "EV");
  uint32 size;
  ReadBasicType(is, binary, &size);
  evec->resize(size);
  for (size_t i = 0; i < size; i++) {
    ReadBasicType(is, binary, &( (*evec)[i].first ));
    ReadBasicType(is, binary, &( (*evec)[i].second ));
  }
}

ReadHtk() [1/2]

template bool kaldi::ReadHtk	(	std::istream &	is,
		Matrix< float > *	M,
		HtkHeader *	header_ptr
	)

ReadHtk() [2/2]

template bool kaldi::ReadHtk	(	std::istream &	is,
		Matrix< double > *	M,
		HtkHeader *	header_ptr
	)

Referenced by ReadHtk().

ReadIntegerVectorSimple()

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.

returns true if succeeded.

Definition at line 33 of file simple-io-funcs.cc.

References rnnlm::i, Input::OpenTextMode(), and Input::Stream().

Referenced by main().

                                                     {
  kaldi::Input ki;
  if (!ki.OpenTextMode(rxfilename)) return false;
  std::istream &is = ki.Stream();
  int32 i;
  list->clear();
  while ( !(is >> i).fail() )
    list->push_back(i);
  is >> std::ws;
  return is.eof();  // should be eof, or junk at end of file.
}

ReadIntegerVectorVectorSimple()

bool ReadIntegerVectorVectorSimple	(	const std::string &	rxfilename,
		std::vector< std::vector< int32 > > *	list
	)

Definition at line 62 of file simple-io-funcs.cc.

References Input::OpenTextMode(), SplitStringToIntegers(), and Input::Stream().

Referenced by main(), and ReadPhoneMap().

                                                                       {
  kaldi::Input ki;
  if (!ki.OpenTextMode(rxfilename)) return false;
  std::istream &is = ki.Stream();
  list->clear();
  std::string line;
  while (std::getline(is, line)) {
    std::vector<int32> v;
    if (!SplitStringToIntegers(line, " \t\r", true, &v)) {
      list->clear();
      return false;
    }
    list->push_back(v);
  }
  return is.eof();  // if we're not at EOF, something weird happened.
}

ReadLattice()

bool ReadLattice	(	std::istream &	is,
		bool	binary,
		Lattice **	lat
	)

Definition at line 417 of file kaldi-lattice.cc.

References ConvertToLattice(), KALDI_ASSERT, KALDI_WARN, and ReadLatticeText().

Referenced by LatticeHolder::Read(), and DiscriminativeSupervision::Read().

                                {
  KALDI_ASSERT(*lat == NULL);
  if (binary) {
    fst::FstHeader hdr;
    if (!hdr.Read(is, "<unknown>")) {
      KALDI_WARN << "Reading lattice: error reading FST header.";
      return false;
    }
    if (hdr.FstType() != "vector") {
      KALDI_WARN << "Reading lattice: unsupported FST type: "
                 << hdr.FstType();
      return false;
    }
    fst::FstReadOptions ropts("<unspecified>",
                              &hdr);

    typedef fst::CompactLatticeWeightTpl<fst::LatticeWeightTpl<float>, int32> T1;
    typedef fst::CompactLatticeWeightTpl<fst::LatticeWeightTpl<double>, int32> T2;
    typedef fst::LatticeWeightTpl<float> T3;
    typedef fst::LatticeWeightTpl<double> T4;
    typedef fst::VectorFst<fst::ArcTpl<T1> > F1;
    typedef fst::VectorFst<fst::ArcTpl<T2> > F2;
    typedef fst::VectorFst<fst::ArcTpl<T3> > F3;
    typedef fst::VectorFst<fst::ArcTpl<T4> > F4;

    Lattice *ans = NULL;
    if (hdr.ArcType() == T1::Type()) {
      ans = ConvertToLattice(F1::Read(is, ropts));
    } else if (hdr.ArcType() == T2::Type()) {
      ans = ConvertToLattice(F2::Read(is, ropts));
    } else if (hdr.ArcType() == T3::Type()) {
      ans = ConvertToLattice(F3::Read(is, ropts));
    } else if (hdr.ArcType() == T4::Type()) {
      ans = ConvertToLattice(F4::Read(is, ropts));
    } else {
      KALDI_WARN << "FST with arc type " << hdr.ArcType()
                 << " cannot be converted to Lattice.\n";
      return false;
    }
    if (ans == NULL) {
      KALDI_WARN << "Error reading lattice (after reading header).";
      return false;
    }
    *lat = ans;
    return true;
  } else {
    // The next line would normally consume the \r on Windows, plus any
    // extra spaces that might have got in there somehow.
    while (std::isspace(is.peek()) && is.peek() != '\n') is.get();
    if (is.peek() == '\n') is.get(); // consume the newline.
    else { // saw spaces but no newline.. this is not expected.
      KALDI_WARN << "Reading compact lattice: unexpected sequence of spaces "
                 << " at file position " << is.tellg();
      return false;
    }
    *lat = ReadLatticeText(is); // that routine will warn on error.
    return (*lat != NULL);
  }
}

ReadLatticeText()

Lattice* kaldi::ReadLatticeText

(

std::istream &

is

)

Definition at line 291 of file kaldi-lattice.cc.

References ConvertToLattice(), and LatticeReader::ReadText().

Referenced by ReadLattice().

                                         {
  std::pair<Lattice*, CompactLattice*> lat_pair = LatticeReader::ReadText(is);
  if (lat_pair.first != NULL) {
    delete lat_pair.second;
    return lat_pair.first;
  } else if (lat_pair.second != NULL) {
    // note: ConvertToLattice frees its input.
    return ConvertToLattice(lat_pair.second);
  } else {
    return NULL;
  }
}

ReadLexiconForWordAlign()

bool ReadLexiconForWordAlign	(	std::istream &	is,
		std::vector< std::vector< int32 > > *	lexicon
	)

Read the lexicon in the special format required for word alignment.

Each line has a series of integers on it (at least two on each line), representing:

<old-word-id> <new-word-id> [<phone-id-1> [<phone-id-2> ... ] ]

Here, <old-word-id> is the word-id that appears in the lattice before alignment, and <new-word-id> is the word-is that should appear in the lattice after alignment. This is mainly useful when the lattice may have no symbol for the optional-silence arcs (so <old-word-id> would equal zero), but we want it to be output with a symbol on those arcs (so <new-word-id> would be nonzero). If the silence should not be added to the lattice, both <old-word-id> and <new-word-id> may be zero.

This function is very simple: it just reads in a series of lines from a text file, each with at least two integers on them.

Definition at line 1051 of file word-align-lattice-lexicon.cc.

References KALDI_WARN, and SplitStringToIntegers().

Referenced by main().

                                                                     {
  lexicon->clear();
  std::string line;
  while (std::getline(is, line)) {
    std::vector<int32> this_entry;
    if (!SplitStringToIntegers(line, " \t\r", false, &this_entry) ||
        this_entry.size() < 2) {
      KALDI_WARN << "Lexicon line '" << line  << "' is invalid";
      return false;
    }
    lexicon->push_back(this_entry);
  }
  return (!lexicon->empty());
}

ReadLine()

bool ReadLine	(	int32	desc,
		std::string *	str
	)

Definition at line 359 of file online-audio-client.cc.

References buffer_fill, buffer_offset, and rnnlm::i.

Referenced by main().

                                          {
  *str = "";

  while (true) {
    if (buffer_offset >= buffer_fill) {
      buffer_fill = read(desc, read_buffer, 1024);

      if (buffer_fill <= 0)
        break;

      buffer_offset = 0;
    }

    for (int32 i = buffer_offset; i < buffer_fill; i++) {
      if (read_buffer[i] == '\r' || read_buffer[i] == '\n') {
        read_buffer[i] = 0;
        *str += (read_buffer + buffer_offset);

        buffer_offset = i + 1;

        if (i < buffer_fill) {
          if (read_buffer[i] == '\n' && read_buffer[i + 1] == '\r') {
            read_buffer[i + 1] = 0;
            buffer_offset = i + 2;
          }
          if (read_buffer[i] == '\r' && read_buffer[i + 1] == '\n') {
            read_buffer[i + 1] = 0;
            buffer_offset = i + 2;
          }
        }

        return true;
      }
    }

    read_buffer[buffer_fill] = 0;
    *str += (read_buffer + buffer_offset);
    buffer_offset = buffer_fill;
  }

  return false;
}

ReadModels()

void kaldi::ReadModels	(	std::vector< std::pair< std::string, BaseFloat > >	models_and_weights,
		nnet3::Nnet *	output_nnet,
		int32 *	success
	)

Definition at line 57 of file nnet3-average.cc.

References kaldi::nnet3::AddNnet(), rnnlm::i, rnnlm::n, ReadKaldiObject(), and kaldi::nnet3::ScaleNnet().

Referenced by main().

                                {
  using namespace nnet3;
  try {
    int32 n = models_and_weights.size();
    ReadKaldiObject(models_and_weights[0].first, output_nnet);
    ScaleNnet(models_and_weights[0].second, output_nnet);
    for (int32 i = 1; i < n; i++) {
      Nnet nnet;
      ReadKaldiObject(models_and_weights[i].first, &nnet);
      AddNnet(nnet, models_and_weights[i].second, output_nnet);
    }
    *success = 1;
  } catch (...) {
    *success = 0;
  }
}

ReadNetwork()

fst::Fst< fst::StdArc > * ReadNetwork

(

std::string

filename

)

Definition at line 32 of file gmm-decode-biglm-faster.cc.

References KALDI_ERR, and Input::Stream().

Referenced by main().

                                                   {
  // read decoding network FST
  Input ki(filename); // use ki.Stream() instead of is.
  if (!ki.Stream().good()) KALDI_ERR << "Could not open decoding-graph FST "
                                      << filename;

  fst::FstHeader hdr;
  if (!hdr.Read(ki.Stream(), "<unknown>")) {
    KALDI_ERR << "Reading FST: error reading FST header.";
  }
  if (hdr.ArcType() != fst::StdArc::Type()) {
    KALDI_ERR << "FST with arc type " << hdr.ArcType() << " not supported.";
  }
  fst::FstReadOptions ropts("<unspecified>", &hdr);

  fst::Fst<fst::StdArc> *decode_fst = NULL;

  if (hdr.FstType() == "vector") {
    decode_fst = fst::VectorFst<fst::StdArc>::Read(ki.Stream(), ropts);
  } else if (hdr.FstType() == "const") {
    decode_fst = fst::ConstFst<fst::StdArc>::Read(ki.Stream(), ropts);
  } else {
    KALDI_ERR << "Reading FST: unsupported FST type: " << hdr.FstType();
  }
  if (decode_fst == NULL) { // fst code will warn.
    KALDI_ERR << "Error reading FST (after reading header).";
    return NULL;
  } else {
    return decode_fst;
  }
}

ReadPhoneMap()

void ReadPhoneMap	(	std::string	phone_map_rxfilename,
		std::vector< int32 > *	phone_map
	)

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

References rnnlm::i, KALDI_ASSERT, KALDI_ERR, PrintableRxfilename(), and ReadIntegerVectorVectorSimple().

Referenced by AccumulateTreeStatsInfo::AccumulateTreeStatsInfo(), and main().

                                               {
  phone_map->clear();
  // phone map file has format e.g.:
  // 1 1
  // 2 1
  // 3 2
  // 4 2
  std::vector<std::vector<int32> > vec;  // vector of vectors, each with two elements
  // (if file has right format). first is old phone, second is new phone
  if (!ReadIntegerVectorVectorSimple(phone_map_rxfilename, &vec))
    KALDI_ERR << "Error reading phone map from " <<
        PrintableRxfilename(phone_map_rxfilename);
  for (size_t i = 0; i < vec.size(); i++) {
    if (vec[i].size() != 2 || vec[i][0]<=0 || vec[i][1]<=0 ||
       (vec[i][0]<static_cast<int32>(phone_map->size()) &&
        (*phone_map)[vec[i][0]] != -1))
      KALDI_ERR << "Error reading phone map from "
                <<   PrintableRxfilename(phone_map_rxfilename)
                << " (bad line " << i << ")";
    if (vec[i][0]>=static_cast<int32>(phone_map->size()))
      phone_map->resize(vec[i][0]+1, -1);
    KALDI_ASSERT((*phone_map)[vec[i][0]] == -1);
    (*phone_map)[vec[i][0]] = vec[i][1];
  }
  if (phone_map->empty()) {
    KALDI_ERR << "Read empty phone map from "
              << PrintableRxfilename(phone_map_rxfilename);
  }
}

ReadSharedPhonesList()

void ReadSharedPhonesList	(	std::string	rxfilename,
		std::vector< std::vector< int32 > > *	list_out
	)

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

References IsSortedAndUniq(), KALDI_ERR, PrintableRxfilename(), SplitStringToIntegers(), and Input::Stream().

Referenced by main().

                                                                                        {
  list_out->clear();
  Input input(rxfilename);
  std::istream &is = input.Stream();
  std::string line;
  while (std::getline(is, line)) {
    list_out->push_back(std::vector<int32>());
    if (!SplitStringToIntegers(line, " \t\r", true, &(list_out->back())))
      KALDI_ERR << "Bad line in shared phones list: " << line << " (reading "
                << PrintableRxfilename(rxfilename) << ")";
    std::sort(list_out->rbegin()->begin(), list_out->rbegin()->end());
    if (!IsSortedAndUniq(*(list_out->rbegin())))
      KALDI_ERR << "Bad line in shared phones list (repeated phone): " << line
                << " (reading " << PrintableRxfilename(rxfilename) << ")";
  }
}

ReadSymbolList()

void kaldi::ReadSymbolList	(	const std::string &	rxfilename,
		fst::SymbolTable *	word_syms,
		LabelPairVector *	lpairs
	)

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

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

Referenced by main().

                                             {
  Input ki(rxfilename);
  std::string line;
  KALDI_ASSERT(lpairs != NULL);
  lpairs->clear();
  while (getline(ki.Stream(), line)) {
    std::string sym;
    std::istringstream ss(line);
    ss >> sym >> std::ws;
    if (ss.fail() || !ss.eof()) {
      KALDI_ERR << "Bad line in symbol list: "<< line
                << ", file is: " << PrintableRxfilename(rxfilename);
    }
    fst::StdArc::Label lab = word_syms->Find(sym.c_str());
    if (lab == -1) { // fst::kNoSymbol
      KALDI_ERR << "Can't find symbol in symbol table: "
                << line << ", file is: "
                << PrintableRxfilename(rxfilename);
    }
    lpairs->emplace_back(lab, 0);
  }
}

RealFft() [1/2]

template void kaldi::RealFft	(	VectorBase< float > *	v,
		bool	forward
	)

RealFft() [2/2]

template void kaldi::RealFft	(	VectorBase< double > *	v,
		bool	forward
	)

RealFftInefficient() [1/2]

template void kaldi::RealFftInefficient	(	VectorBase< float > *	v,
		bool	forward
	)

RealFftInefficient() [2/2]

template void kaldi::RealFftInefficient	(	VectorBase< double > *	v,
		bool	forward
	)

RegisterCuAllocatorOptions()

void kaldi::RegisterCuAllocatorOptions ( OptionsItf *  po )

inline

Definition at line 87 of file cu-allocator.h.

References CuAllocatorOptions::Register().

Referenced by main().

                                                       {
  g_allocator_options.Register(po);
}

RemoveDuplicates()

static void kaldi::RemoveDuplicates ( std::vector< std::vector< int32 > > *  vecs )

static

Definition at line 533 of file build-tree.cc.

References KALDI_VLOG.

Referenced by ObtainSetsOfPhones().

                                                                  {
  unordered_set<std::vector<int32>, VectorHasher<int32> > vec_set;
  std::vector<std::vector<int32 > > new_vecs;
  new_vecs.reserve(vecs->size());
  int32 num_not_inserted = 0;
  for (std::vector<std::vector<int32 > >::const_iterator iter = vecs->begin(),
           end = vecs->end(); iter != end; iter++) {
    if (vec_set.insert(*iter).second) {  // if this vector was not already in
                                         // the set...
      new_vecs.push_back(*iter);
    } else {
      num_not_inserted++;
    }
  }
  KALDI_VLOG(2) << "Removed " << num_not_inserted
                << " duplicates from the phone sets.";
  vecs->swap(new_vecs);
}

RemoveLongSilences()

void RemoveLongSilences	(	int32	max_silence_frames,
		const std::vector< int32 > &	state_times,
		KwsProductFst *	factor_transducer
	)

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

Referenced by main().

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

  StateId ns = factor_transducer->NumStates();
  StateId ss = factor_transducer->Start();
  StateId bad_state = factor_transducer->AddState();
  for (StateId s = 0; s < ns; s++) {
    // Skip arcs start from the initial state
    if (s == ss)
      continue;
    for (MutableArcIterator<KwsProductFst>
         aiter(factor_transducer, s); !aiter.Done(); aiter.Next()) {
      KwsProductArc arc = aiter.Value();
      // Skip arcs end with the final state
      if (factor_transducer->Final(arc.nextstate) != KwsProductWeight::Zero())
        continue;
      // Non-silence arcs
      if (arc.ilabel != 0)
        continue;
      // Short silence arcs
      if (state_times[arc.nextstate]-state_times[s] <= max_silence_frames)
        continue;
      // The rest are the long silence arcs, we point their nextstate to
      // bad_state
      arc.nextstate = bad_state;
      aiter.SetValue(arc);
    }
  }

  // Trim the unsuccessful paths
  Connect(factor_transducer);
}

ReplaceAcousticScoresFromMap()

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.

Parameters

[in]	acoustic_scores	A map from the pair (frame-index, transition-id) to a pair (sum-of-acoustic-scores, num-of-occurences) of the occurences of the transition-id in that frame. See the comments for ComputeAcousticScoresMap for details.
[out]	lat	Pointer to the output lattice.

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

References KALDI_ASSERT, KALDI_ERR, LatticeStateTimes(), LatticeWeightTpl< FloatType >::SetValue2(), TopSortLatticeIfNeeded(), and LatticeWeightTpl< BaseFloat >::Zero().

Referenced by main().

                  {
  // typedef the arc, weight types
  typedef Lattice::Arc Arc;
  typedef Arc::Weight LatticeWeight;
  typedef Arc::StateId StateId;

  TopSortLatticeIfNeeded(lat);

  std::vector<int32> state_times;
  LatticeStateTimes(*lat, &state_times);

  KALDI_ASSERT(lat->Start() == 0);

  for (StateId s = 0; s < lat->NumStates(); s++) {
    int32 t = state_times[s];
    for (fst::MutableArcIterator<Lattice> aiter(lat, s);
          !aiter.Done(); aiter.Next()) {
      Arc arc(aiter.Value());

      int32 tid = arc.ilabel;
      if (tid != 0) {
        unordered_map<std::pair<int32, int32>, std::pair<BaseFloat, int32>,
          PairHasher<int32> >::const_iterator it = acoustic_scores.find(std::make_pair(t, tid));
        if (it == acoustic_scores.end()) {
          KALDI_ERR << "Could not find tid " << tid << " at time " << t
                    << " in the acoustic scores map.";
        } else {
          arc.weight.SetValue2(it->second.first / it->second.second);
        }
      } else {
        // For epsilon arcs, set acoustic cost to 0.0
        arc.weight.SetValue2(0.0);
      }
      aiter.SetValue(arc);
    }

    LatticeWeight f = lat->Final(s);
    if (f != LatticeWeight::Zero()) {
      // Set final acoustic cost to 0.0
      f.SetValue2(0.0);
      lat->SetFinal(s, f);
    }
  }
}

ReplaceSymbolWithEpsilon()

static void kaldi::ReplaceSymbolWithEpsilon ( typename Arc::Label  symbol, fst::VectorFst< Arc > *  fst  )

static

Definition at line 36 of file kws-functions2.cc.

References KALDI_ASSERT.

Referenced by DoFactorMerging().

                                                             {
  typedef typename Arc::StateId StateId;
  for (StateId s = 0; s < fst->NumStates(); s++) {
    for (fst::MutableArcIterator<fst::VectorFst<Arc> > aiter(fst, s);
         !aiter.Done(); aiter.Next()) {
      Arc arc = aiter.Value();
      KALDI_ASSERT(arc.ilabel == arc.olabel);
      if (arc.ilabel == symbol) {
        arc.ilabel = 0;
        arc.olabel = 0;
        aiter.SetValue(arc);
      }
    }
  }
}

RescoreCompactLattice()

bool RescoreCompactLattice	(	DecodableInterface *	decodable,
		CompactLattice *	clat
	)

This function *adds* the negated scores obtained from the Decodable object, to the acoustic scores on the arcs.

If you want to replace them, you should use ScaleCompactLattice to first set the acoustic scores to zero. Returns true on success, false on error (typically some kind of mismatched inputs).

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

References RescoreCompactLatticeInternal().

Referenced by main().

                                                 {
  return RescoreCompactLatticeInternal(NULL, 1.0, decodable, clat);
}

RescoreCompactLatticeInternal()

bool kaldi::RescoreCompactLatticeInternal	(	const TransitionModel *	tmodel,
		BaseFloat	speedup_factor,
		DecodableInterface *	decodable,
		CompactLattice *	clat
	)

RescoreCompactLatticeInternal is the internal code for both RescoreCompactLattice and RescoreCompatLatticeSpeedup.

For RescoreCompactLattice, "tmodel" will be NULL and speedup_factor will be 1.0.

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

References CompactLatticeStateTimes(), rnnlm::i, DecodableInterface::IsLastFrame(), KALDI_ASSERT, KALDI_WARN, DecodableInterface::LogLikelihood(), LatticeWeightTpl< FloatType >::SetValue2(), CompactLatticeWeightTpl< WeightType, IntType >::SetWeight(), TransitionModel::TransitionIdToPdf(), CompactLatticeWeightTpl< WeightType, IntType >::Weight(), WithProb(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by RescoreCompactLattice(), and RescoreCompactLatticeSpeedup().

                          {
  KALDI_ASSERT(speedup_factor >= 1.0);
  if (clat->NumStates() == 0) {
    KALDI_WARN << "Rescoring empty lattice";
    return false;
  }
  if (!clat->Properties(fst::kTopSorted, true)) {
    if (fst::TopSort(clat) == false) {
      KALDI_WARN << "Cycles detected in lattice.";
      return false;
    }
  }
  std::vector<int32> state_times;
  int32 utt_len = kaldi::CompactLatticeStateTimes(*clat, &state_times);

  std::vector<std::vector<ClatRescoreTuple> > time_to_state(utt_len);

  int32 num_states = clat->NumStates();
  KALDI_ASSERT(num_states == state_times.size());
  for (size_t state = 0; state < num_states; state++) {
    KALDI_ASSERT(state_times[state] >= 0);
    int32 t = state_times[state];
    int32 arc_id = 0;
    for (fst::MutableArcIterator<CompactLattice> aiter(clat, state);
         !aiter.Done(); aiter.Next(), arc_id++) {
      CompactLatticeArc arc = aiter.Value();
      std::vector<int32> arc_string = arc.weight.String();

      for (size_t offset = 0; offset < arc_string.size(); offset++) {
        if (t < utt_len) { // end state may be past this..
          int32 tid = arc_string[offset];
          time_to_state[t+offset].push_back(ClatRescoreTuple(state, arc_id, tid));
        } else {
          if (t != utt_len) {
            KALDI_WARN << "There appears to be lattice/feature mismatch, "
                       << "aborting.";
            return false;
          }
        }
      }
    }
    if (clat->Final(state) != CompactLatticeWeight::Zero()) {
      arc_id = -1;
      std::vector<int32> arc_string = clat->Final(state).String();
      for (size_t offset = 0; offset < arc_string.size(); offset++) {
        KALDI_ASSERT(t + offset < utt_len); // already checked in
        // CompactLatticeStateTimes, so would be code error.
        time_to_state[t+offset].push_back(
            ClatRescoreTuple(state, arc_id, arc_string[offset]));
      }
    }
  }

  for (int32 t = 0; t < utt_len; t++) {
    if ((t < utt_len - 1) && decodable->IsLastFrame(t)) {
      KALDI_WARN << "Features are too short for lattice: utt-len is "
                 << utt_len << ", " << t << " is last frame";
      return false;
    }
    // frame_scale is the scale we put on the computed acoustic probs for this
    // frame.  It will always be 1.0 if tmodel == NULL (i.e. if we are not doing
    // the "speedup" code).  For frames with multiple pdf-ids it will be one.
    // For frames with only one pdf-id, it will equal speedup_factor (>=1.0)
    // with probability 1.0 / speedup_factor, and zero otherwise.  If it is zero,
    // we can avoid computing the probabilities.
    BaseFloat frame_scale = 1.0;
    KALDI_ASSERT(!time_to_state[t].empty());
    if (tmodel != NULL) {
      int32 pdf_id = tmodel->TransitionIdToPdf(time_to_state[t][0].tid);
      bool frame_has_multiple_pdfs = false;
      for (size_t i = 1; i < time_to_state[t].size(); i++) {
        if (tmodel->TransitionIdToPdf(time_to_state[t][i].tid) != pdf_id) {
          frame_has_multiple_pdfs = true;
          break;
        }
      }
      if (frame_has_multiple_pdfs) {
        frame_scale = 1.0;
      } else {
        if (WithProb(1.0 / speedup_factor)) {
          frame_scale = speedup_factor;
        } else {
          frame_scale = 0.0;
        }
      }
      if (frame_scale == 0.0)
        continue; // the code below would be pointless.
    }

    for (size_t i = 0; i < time_to_state[t].size(); i++) {
      int32 state = time_to_state[t][i].state_id;
      int32 arc_id = time_to_state[t][i].arc_id;
      int32 tid = time_to_state[t][i].tid;

      if (arc_id == -1) { // Final state
        // Access the trans_id
        CompactLatticeWeight curr_clat_weight = clat->Final(state);

        // Calculate likelihood
        BaseFloat log_like = decodable->LogLikelihood(t, tid) * frame_scale;
        // update weight
        CompactLatticeWeight new_clat_weight = curr_clat_weight;
        LatticeWeight new_lat_weight = new_clat_weight.Weight();
        new_lat_weight.SetValue2(-log_like + curr_clat_weight.Weight().Value2());
        new_clat_weight.SetWeight(new_lat_weight);
        clat->SetFinal(state, new_clat_weight);
      } else {
        fst::MutableArcIterator<CompactLattice> aiter(clat, state);

        aiter.Seek(arc_id);
        CompactLatticeArc arc = aiter.Value();

        // Calculate likelihood
        BaseFloat log_like = decodable->LogLikelihood(t, tid) * frame_scale;
        // update weight
        LatticeWeight new_weight = arc.weight.Weight();
        new_weight.SetValue2(-log_like + arc.weight.Weight().Value2());
        arc.weight.SetWeight(new_weight);
        aiter.SetValue(arc);
      }
    }
  }
  return true;
}

RescoreCompactLatticeSpeedup()

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.

(it needs the transition-model to work out whether two transition-ids map to the same pdf-id, and it assumes that the lattice has transition-ids on it). The naive thing would be to just set all probabilities to zero on frames where all the pdf-ids are the same (because this value won't affect the lattice posterior). But this would become confusing when we compute corpus-level diagnostics such as the MMI objective function. Instead, imagine speedup_factor = 100 (it must be >= 1.0)... with probability (1.0 / speedup_factor) we compute those likelihoods and multiply them by speedup_factor; otherwise we set them to zero. This gives the right expected probability so our corpus-level diagnostics will be about right.

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

References RescoreCompactLatticeInternal().

Referenced by main().

                          {
  return RescoreCompactLatticeInternal(&tmodel, speedup_factor, decodable, clat);
}

RescoreLattice()

bool RescoreLattice	(	DecodableInterface *	decodable,
		Lattice *	lat
	)

This function *adds* the negated scores obtained from the Decodable object, to the acoustic scores on the arcs.

If you want to replace them, you should use ScaleCompactLattice to first set the acoustic scores to zero. Returns true on success, false on error (e.g. some kind of mismatched inputs). The input labels, if nonzero, are interpreted as transition-ids or whatever other index the Decodable object expects.

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

References rnnlm::i, DecodableInterface::IsLastFrame(), KALDI_ASSERT, KALDI_WARN, LatticeStateTimes(), and DecodableInterface::LogLikelihood().

Referenced by SingleUtteranceGmmDecoder::GetLattice().

                                  {
  if (lat->NumStates() == 0) {
    KALDI_WARN << "Rescoring empty lattice";
    return false;
  }
  if (!lat->Properties(fst::kTopSorted, true)) {
    if (fst::TopSort(lat) == false) {
      KALDI_WARN << "Cycles detected in lattice.";
      return false;
    }
  }
  std::vector<int32> state_times;
  int32 utt_len = kaldi::LatticeStateTimes(*lat, &state_times);

  std::vector<std::vector<int32> > time_to_state(utt_len );

  int32 num_states = lat->NumStates();
  KALDI_ASSERT(num_states == state_times.size());
  for (size_t state = 0; state < num_states; state++) {
    int32 t = state_times[state];
    // Don't check t >= 0 because non-accessible states could have t = -1.
    KALDI_ASSERT(t <= utt_len);
    if (t >= 0 && t < utt_len)
      time_to_state[t].push_back(state);
  }

  for (int32 t = 0; t < utt_len; t++) {
    if ((t < utt_len - 1) && decodable->IsLastFrame(t)) {
      KALDI_WARN << "Features are too short for lattice: utt-len is "
                 << utt_len << ", " << t << " is last frame";
      return false;
    }
    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();
        if (arc.ilabel != 0) {
          int32 trans_id = arc.ilabel; // Note: it doesn't necessarily
          // have to be a transition-id, just whatever the Decodable
          // object is expecting, but it's normally a transition-id.

          BaseFloat log_like = decodable->LogLikelihood(t, trans_id);
          arc.weight.SetValue2(-log_like + arc.weight.Value2());
          aiter.SetValue(arc);
        }
      }
    }
  }
  return true;
}

ResizeModel()

void kaldi::ResizeModel	(	int32	dim,
		AmDiagGmm *	am_gmm
	)

Definition at line 176 of file mle-am-diag-gmm.cc.

References DiagGmm::ComputeGconsts(), AmDiagGmm::GetPdf(), DiagGmm::NumGauss(), AmDiagGmm::NumPdfs(), DiagGmm::Resize(), MatrixBase< Real >::Set(), and DiagGmm::SetInvVars().

Referenced by MleAmDiagGmmUpdate().

                                                {
  for (int32 pdf_id = 0; pdf_id < am_gmm->NumPdfs(); pdf_id++) {
    DiagGmm &pdf = am_gmm->GetPdf(pdf_id);
    pdf.Resize(pdf.NumGauss(), dim);
    Matrix<BaseFloat> inv_vars(pdf.NumGauss(), dim);
    inv_vars.Set(1.0); // make all vars 1.
    pdf.SetInvVars(inv_vars);
    pdf.ComputeGconsts();
  }
}

ReverseVector()

void kaldi::ReverseVector ( std::vector< T > *  vec )

inline

Reverses the contents of a vector.

Definition at line 264 of file stl-utils.h.

References rnnlm::i, KALDI_ASSERT, and swap().

Referenced by LevenshteinAlignment(), and TestReverseVector().

                                             {
  KALDI_ASSERT(vec != NULL);
  size_t sz = vec->size();
  for (size_t i = 0; i < sz/2; i++)
    std::swap( (*vec)[i], (*vec)[sz-1-i]);
}

RoundUpToNearestPowerOfTwo()

int32 RoundUpToNearestPowerOfTwo

(

int32

n

)

Definition at line 32 of file kaldi-math.cc.

References KALDI_ASSERT.

Referenced by ComputationGraphBuilder::AddDependencies(), AssertEqual(), FFTbasedBlockConvolveSignals(), FFTbasedConvolveSignals(), FrameExtractionOptions::PaddedWindowSize(), and UnitTestRoundUpToNearestPowerOfTwo().

                                          {
  KALDI_ASSERT(n > 0);
  n--;
  n |= n >> 1;
  n |= n >> 2;
  n |= n >> 4;
  n |= n >> 8;
  n |= n >> 16;
  return n+1;
}

RuleActivated()

static bool kaldi::RuleActivated ( const OnlineEndpointRule &  rule, const std::string &  rule_name, BaseFloat  trailing_silence, BaseFloat  relative_cost, BaseFloat  utterance_length  )

static

Definition at line 26 of file online-endpoint.cc.

References KALDI_VLOG, OnlineEndpointRule::max_relative_cost, OnlineEndpointRule::min_trailing_silence, OnlineEndpointRule::min_utterance_length, and OnlineEndpointRule::must_contain_nonsilence.

Referenced by EndpointDetected().

                                                      {
  bool contains_nonsilence = (utterance_length > trailing_silence);

  bool ans = (contains_nonsilence || !rule.must_contain_nonsilence) &&
      trailing_silence >= rule.min_trailing_silence &&
      relative_cost <= rule.max_relative_cost &&
      utterance_length >= rule.min_utterance_length;
  if (ans) {
    KALDI_VLOG(2) << "Endpointing rule " << rule_name << " activated: "
                  << (contains_nonsilence ? "true" : "false" ) << ','
                  << trailing_silence << ',' << relative_cost << ','
                  << utterance_length;
  }
  return ans;
}

RunMultiThreaded()

void kaldi::RunMultiThreaded

(

const C &

c_in

)

Here, class C should inherit from MultiThreadable.

Note: if you want to control the number of threads yourself, or need to do something in the main thread of the program while the objects exist, just initialize the MultiThreader<C> object yourself.

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

Referenced by AmSgmm2::ComputeNormalizers(), TestThreads(), EbwAmSgmm2Updater::UpdatePhoneVectors(), MleAmSgmm2Updater::UpdatePhoneVectors(), EbwAmSgmm2Updater::UpdateW(), and MleAmSgmm2Updater::UpdateW().

                                                       {
  MultiThreader<C> m(g_num_threads, c_in);
}

RunPerSpeaker()

int32 kaldi::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
	)

Definition at line 92 of file ivector-extract.cc.

References IvectorEstimationOptions::acoustic_weight, SequentialTableReader< Holder >::Done(), IvectorExtractor::FeatDim(), IvectorExtractor::GetAuxf(), IvectorExtractor::GetIvectorDistribution(), RandomAccessTableReader< Holder >::HasKey(), rnnlm::i, IvectorExtractor::IvectorDim(), KALDI_LOG, KALDI_WARN, SequentialTableReader< Holder >::Key(), IvectorEstimationOptions::max_count, SequentialTableReader< Holder >::Next(), IvectorExtractor::NumGauss(), MatrixBase< Real >::NumRows(), IvectorExtractor::PriorOffset(), ReadKaldiObject(), ScalePosterior(), RandomAccessTableReader< Holder >::Value(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                        {
  IvectorExtractor extractor;
  ReadKaldiObject(ivector_extractor_rxfilename, &extractor);
  SequentialTokenVectorReader spk2utt_reader(spk2utt_rspecifier);
  RandomAccessBaseFloatMatrixReader feature_reader(feature_rspecifier);
  RandomAccessPosteriorReader posterior_reader(posterior_rspecifier);
  BaseFloatVectorWriter ivector_writer(ivector_wspecifier);

  double tot_auxf_change = 0.0, tot_post = 0.0, tot_norm = 0.0;
  int32 num_utt_done = 0, num_utt_err = 0,
      num_spk_done = 0, num_spk_err = 0;

  for (; !spk2utt_reader.Done(); spk2utt_reader.Next()) {
    std::string spk = spk2utt_reader.Key();
    const std::vector<std::string> &utts = spk2utt_reader.Value();

    bool need_2nd_order_stats = false;

    IvectorExtractorUtteranceStats utt_stats(extractor.NumGauss(),
                                             extractor.FeatDim(),
                                             need_2nd_order_stats);

    for (size_t i = 0; i < utts.size(); i++) {
      const std::string &utt = utts[i];
      if (!feature_reader.HasKey(utt)) {
        KALDI_WARN << "No features present for utterance " << utt;
        num_utt_err++;
        continue;
      }
      const Matrix<BaseFloat> &feats = feature_reader.Value(utt);
      if (!posterior_reader.HasKey(utt)) {
        KALDI_WARN << "No posteriors present for utterance " << utt;
        num_utt_err++;
        continue;
      }
      Posterior posterior = posterior_reader.Value(utt);
      if (feats.NumRows() != posterior.size()) {
        KALDI_WARN << "Posterior has wrong size " << posterior.size()
                   << " vs. feats " << feats.NumRows() << " for "
                   << utt;
        num_utt_err++;
        continue;
      }
      ScalePosterior(opts.acoustic_weight, &posterior);
      num_utt_done++;
      utt_stats.AccStats(feats, posterior);
    }

    if (utt_stats.NumFrames() == 0.0) {
      KALDI_WARN << "No stats accumulated for speaker " << spk;
      num_spk_err++;
      continue;
    } else {
      if (opts.max_count > 0 && utt_stats.NumFrames() > opts.max_count) {
        double scale = opts.max_count / utt_stats.NumFrames();
        utt_stats.Scale(scale);
        KALDI_LOG << "Scaling stats for speaker " << spk << " by scale "
                  << scale << " due to --max-count=" << opts.max_count;
      }

      Vector<double> ivector(extractor.IvectorDim());
      ivector(0) = extractor.PriorOffset();

      if (compute_objf_change) {
        double old_auxf = extractor.GetAuxf(utt_stats, ivector);
        extractor.GetIvectorDistribution(utt_stats, &ivector, NULL);
        double new_auxf = extractor.GetAuxf(utt_stats, ivector);
        double auxf_change = new_auxf - old_auxf;

        KALDI_LOG << "Auxf change for speaker " << spk << " was "
                  << (auxf_change / utt_stats.NumFrames()) << " per frame, over "
                  << utt_stats.NumFrames() << " frames (weighted).";
        tot_auxf_change += auxf_change;
      } else {
        extractor.GetIvectorDistribution(utt_stats, &ivector, NULL);
      }
      // We actually write out the offset of the iVectors from the mean of the
      // prior distribution; this is the form we'll need it in for scoring and
      // as a feature for neural nets.  (most formulations of iVectors have
      // zero-mean priors so this is not normally an issue).
      ivector(0) -= extractor.PriorOffset();
      KALDI_LOG << "Ivector norm for speaker " << spk
                << " was " << ivector.Norm(2.0);

      tot_norm += ivector.Norm(2.0) * utt_stats.NumFrames();
      tot_post += utt_stats.NumFrames();
      num_spk_done++;
      Vector<BaseFloat> ivector_flt(ivector);
      ivector_writer.Write(spk, ivector_flt);
    }
  }

  KALDI_LOG << "Done " << num_spk_done << " speakers; " << num_spk_err
            << " with errors.  " << num_utt_done << " utterances "
            << "were processed, " << num_utt_err << " with errors.";
  if (tot_post != 0.0) {
    if (compute_objf_change) {
      KALDI_LOG << "Overall weighted-average objective function improvement was "
                << (tot_auxf_change / tot_post) << " over " << tot_post
                << " frames (weighted)";
    }
    KALDI_LOG << "Average iVector norm (weighted by frames) was "
              << (tot_norm / tot_post) << " over " << tot_post
              << " frames (weighted)";
  }
  return (num_spk_done != 0 ? 0 : 1);
}

SameDim()

bool kaldi::SameDim	(	const CuMatrixBase< Real > &	M,
		const CuMatrixBase< Real > &	N
	)

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

                                                                       {
  return (M.NumRows() == N.NumRows() && M.NumCols() == N.NumCols());
}

SameDimAndStride()

bool kaldi::SameDimAndStride	(	const CuMatrixBase< Real > &	M,
		const CuMatrixBase< Real > &	N
	)

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

Referenced by ScaleAndOffsetComponent::Backprop(), and ScaleAndOffsetComponent::Propagate().

                                                                                {
  return (M.NumRows() == N.NumRows() && M.NumCols() == N.NumCols()
          && M.Stride() == N.Stride());
}

ScoringTest()

bool kaldi::ScoringTest	(	bool	seps,
		const std::string &	infile,
		const std::string &	sentence,
		float	expected
	)

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

References AddSelfLoops(), AddToChainFsa(), ApproxEqual(), Compile(), ArpaLmCompiler::Fst(), KALDI_ASSERT, KALDI_WARN, kBos, and kEos.

Referenced by RunAllTests().

                                 {
  ArpaLmCompiler* lm_compiler = Compile(seps, infile);
  const fst::SymbolTable* symbols = lm_compiler->Fst().InputSymbols();

  // Create a sentence FST for scoring.
  fst::StdVectorFst sentFst;
  fst::StdArc::StateId state = sentFst.AddState();
  sentFst.SetStart(state);
  if (!seps) {
    state = AddToChainFsa(&sentFst, state, kBos);
  }
  std::stringstream ss(sentence);
  std::string word;
  while (ss >> word) {
    int64 word_sym = symbols->Find(word);
    KALDI_ASSERT(word_sym != -1);
    state = AddToChainFsa(&sentFst, state, word_sym);
  }
  if (!seps) {
    state = AddToChainFsa(&sentFst, state, kEos);
  }
  if (seps) {
    AddSelfLoops(&sentFst);
  }
  sentFst.SetFinal(state, 0);
  sentFst.SetOutputSymbols(symbols);

  // Do the composition and extract final weight.
  fst::StdVectorFst composed;
  fst::Compose(sentFst, lm_compiler->Fst(), &composed);
  delete lm_compiler;

  if (composed.Start() == fst::kNoStateId) {
    KALDI_WARN << "Test sentence " << sentence << " did not compose "
               << "with the language model FST\n";
    return false;
  }

  std::vector<fst::StdArc::Weight> shortest;
  fst::ShortestDistance(composed, &shortest, true);
  float actual = shortest[composed.Start()].Value();

  bool ok = ApproxEqual(expected, actual);
  if (!ok) {
    KALDI_WARN << "Scored " << sentence << " in " << infile
               << ": Expected=" << expected << " actual=" << actual;
  }
  return ok;
}

SelectLags()

void kaldi::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.

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

References VectorBase< Real >::Data(), PitchExtractionOptions::delta_pitch, PitchExtractionOptions::max_f0, PitchExtractionOptions::min_f0, and Vector< Real >::Resize().

Referenced by OnlinePitchFeatureImpl::OnlinePitchFeatureImpl().

                                         {
  // choose lags relative to acceptable pitch tolerance
  BaseFloat min_lag = 1.0 / opts.max_f0, max_lag = 1.0 / opts.min_f0;

  std::vector<BaseFloat> tmp_lags;
  for (BaseFloat lag = min_lag; lag <= max_lag; lag *= 1.0 + opts.delta_pitch)
    tmp_lags.push_back(lag);
  lags->Resize(tmp_lags.size());
  std::copy(tmp_lags.begin(), tmp_lags.end(), lags->Data());
}

SendPartialResult()

void kaldi::SendPartialResult	(	const std::vector< int32 > &	words,
		const fst::SymbolTable *	word_syms,
		const bool	line_break,
		const int32	serv_sock,
		const sockaddr_in &	client_addr
	)

Definition at line 30 of file online-server-gmm-decode-faster.cc.

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

Referenced by main().

                                                       {
  KALDI_ASSERT(word_syms != NULL);
  std::stringstream sstream;
  for (size_t i = 0; i < words.size(); i++) {
    std::string word = word_syms->Find(words[i]);
    if (word == "")
      KALDI_ERR << "Word-id " << words[i] <<" not in symbol table.";
    sstream << word << ' ';
  }
  if (line_break)
    sstream << "\n\n";

  ssize_t sent = sendto(serv_sock, sstream.str().c_str(), sstream.str().size(),
                        0, reinterpret_cast<const sockaddr*>(&client_addr),
                        sizeof(client_addr));
  if (sent == -1)
    KALDI_WARN << "sendto() call failed when tried to send recognition results";
}

SentenceLevelConfidence() [1/2]

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.

This only gives you sentence-level (utterance-level) confidence. You can get word-by-word confidence within a sentence, along with Minimum Bayes Risk decoding, by looking at sausages.h. Caution: confidences estimated using this type of method are not very accurate. This function will return the difference between the best path in clat and the second-best path in clat (a positive number), or zero if clat was equivalent to the empty FST (no successful paths), or infinity if there was only one path in "clat". It will output to "num_paths" (if non-NULL) a number n = 0, 1 or 2 saying how many n-best paths (up to two) were found. If n >= 1 it outputs to "best_sentence" (if non-NULL) the best word-sequence; if n == 2 it outputs to "second_best_sentence" (if non-NULL) the second best word-sequence (this may be useful for testing whether the two best word sequences are somehow equivalent for the task at hand). If you need more information than this or want to look deeper inside the n-best list, then look at the implementation of this function. This function requires that distinct paths in "lat" have distinct word sequences; this will automatically be the case if you generated "clat" in any normal way, such as from a decoder, because a deterministic FST has this property. This function assumes that any acoustic scaling you want to apply, has already been applied.

Definition at line 26 of file confidence.cc.

References fst::ConvertLattice(), fst::ConvertToCost(), KALDI_ASSERT, KALDI_WARN, rnnlm::n, and fst::NbestAsFsts().

Referenced by main(), and SentenceLevelConfidence().

                                                                          {
  /* It may seem strange that the first thing we do is to convert the
     CompactLattice to a Lattice, given that we may have just created the
     CompactLattice by determinizing a Lattice.  However, this is not just
     a circular conversion; "lat" will have the property that distinct
     paths have distinct word sequences.
     Below, we could run NbestAsFsts on a CompactLattice, but the time
     taken would be quadratic in the length in words of the CompactLattice,
     because of the alignment information getting appended as vectors.
     That's why we convert back to Lattice.
  */
  Lattice lat;
  ConvertLattice(clat, &lat);
  
  std::vector<Lattice> lats;
  NbestAsFsts(lat, 2, &lats);
  int32 n = lats.size();
  KALDI_ASSERT(n >= 0 && n <= 2);
  if (num_paths != NULL) *num_paths = n;
  if (best_sentence != NULL) best_sentence->clear();
  if (second_best_sentence != NULL) second_best_sentence->clear();

  LatticeWeight weight1, weight2;
  if (n >= 1)
    fst::GetLinearSymbolSequence<LatticeArc,int32>(lats[0], NULL,
                                                   best_sentence,
                                                   &weight1);
  if (n >= 2)
    fst::GetLinearSymbolSequence<LatticeArc,int32>(lats[1], NULL,
                                                   second_best_sentence,
                                                   &weight2);

  if (n == 0) {
    return 0; // this seems most appropriate because it will be interpreted as
              // zero confidence, and something definitely went wrong for this
              // to happen.
  } else if (n == 1) {
    // If there is only one sentence in the lattice, we interpret this as there
    // being perfect confidence
    return std::numeric_limits<BaseFloat>::infinity();
  } else {
    BaseFloat best_cost = ConvertToCost(weight1),
        second_best_cost = ConvertToCost(weight2);
    BaseFloat ans = second_best_cost - best_cost;
    if (!(ans >= -0.001 * (fabs(best_cost) + fabs(second_best_cost)))) {
      // Answer should be positive.  Make sure it's at at least not
      // substantially negative.  This would be very strange.
      KALDI_WARN << "Very negative difference." << ans;
    }
    if (ans < 0) ans = 0;
    return ans;
  }  
}

SentenceLevelConfidence() [2/2]

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.

It needs to determinize it first, but it does so in a "smart" way that only generates about as many output paths as it needs.

Definition at line 85 of file confidence.cc.

References fst::DeterminizeLatticePruned(), LongestSentenceLength(), DeterminizeLatticePrunedOptions::max_arcs, and SentenceLevelConfidence().

                                                                          {
  int32 max_sentence_length = LongestSentenceLength(lat);
  fst::DeterminizeLatticePrunedOptions determinize_opts;
  // The basic idea of expanding only up to "max_sentence_length * 2" arcs,
  // is that that should be sufficient to get the best and second-best paths
  // through the lattice, which is all we need for this particular application.
  // "safety_term" is just in case there is some reason why we might need a few
  // extra arcs, e.g. in case of a tie on the weights of the second-best path.
  int32 safety_term = 4 + max_sentence_length;
  determinize_opts.max_arcs = max_sentence_length * 2 + safety_term;
  // set prune_beam to a large value... we don't really rely on the beam; we
  // rely on the max_arcs variable to limit the size of the lattice.
  double prune_beam = std::numeric_limits<double>::infinity();

  CompactLattice clat;
  // We ignore the return status of DeterminizeLatticePruned.  It will likely
  // return false, but this is expected because the expansion is limited
  // by "max_arcs" not "prune_beam".
  Lattice inverse_lat(lat);
  fst::Invert(&inverse_lat); // Swap input and output symbols.
  DeterminizeLatticePruned(inverse_lat, prune_beam, &clat, determinize_opts);
  
  // Call the version of this function that takes a CompactLattice.
  return SentenceLevelConfidence(clat, num_paths,
                                 best_sentence, second_best_sentence);
}

SetLinearAcceptorWeight()

void kaldi::SetLinearAcceptorWeight	(	double	cost,
		fst::VectorFst< fst::StdArc > *	fst
	)

Definition at line 27 of file transcripts-to-fsts.cc.

Referenced by main().

                                                                        {
  typedef typename fst::StdArc::Label Label;
  typedef typename fst::StdArc::Weight Weight;
  typedef typename fst::StdArc::StateId StateId;

  StateId start = fst->Start();
  fst::MutableArcIterator<fst::VectorFst<fst::StdArc> > aiter(fst, start);
  fst::StdArc arc = aiter.Value();
  arc.weight = cost;
  aiter.SetValue(arc);
}

SetOptionImpl()

static bool kaldi::SetOptionImpl ( const std::string &  key, const T &  value, std::map< std::string, T *> &  some_map  )

static

Definition at line 69 of file simple-options.cc.

Referenced by SimpleOptions::SetOption().

                                                           {
  if (some_map.end() != some_map.find(key)) {
    *(some_map[key]) = value;
    return true;
  }
  return false;
}

SetToMovingAverage()

void kaldi::SetToMovingAverage	(	int32	average_window_size,
		Matrix< BaseFloat > *	mat
	)

Definition at line 84 of file process-pitch-feats.cc.

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

Referenced by main().

                                                {
  int32 num_frames = mat->NumRows();
  Matrix<BaseFloat> &features = *mat;
  Vector<BaseFloat> temp_pitch(num_frames);
  int32 width = (average_window_size - 1) / 2, i;
  // e.g. if average_window_size is 5, width will equal 2.
        
  for (i = width; i < num_frames - width ; i++) {
    temp_pitch(i) = features(i, 1);
    for(int j = 1; j <= width; ++j) {
      temp_pitch(i) += (features(i - j, 1) + features(i + j, 1));
    }
    temp_pitch(i) /= (2 * width + 1);
  }
  for (i = width; i < num_frames - width; i++)
    features(i, 1) = temp_pitch(i);
}

ShiftFeatureMatrix()

void kaldi::ShiftFeatureMatrix	(	const Matrix< BaseFloat > &	src,
		int32	shift,
		Matrix< BaseFloat > *	rearranged
	)

Definition at line 26 of file shift-feats.cc.

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

Referenced by main().

                                                         {
    for (int32 r = 0; r < src.NumRows(); r++) {
      int32 src_r = r - shift;
      if (src_r < 0) src_r = 0;
      if (src_r >= src.NumRows()) src_r = src.NumRows() - 1;
      rearranged->Row(r).CopyFromVec(src.Row(src_r));
    }
  }

Sleep()

void Sleep

(

float

seconds

)

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

Referenced by MachineIsLittleEndian(), main(), OnlineTimer::SleepUntil(), TimerTest(), kaldi::nnet2::UnitTestAffineComponent(), kaldi::nnet2::UnitTestAffineComponentPreconditioned(), kaldi::nnet2::UnitTestAffineComponentPreconditionedOnline(), kaldi::nnet2::UnitTestConvolutional1dComponent(), UnitTestIoPipe(), and UnitTestReadScriptFile().

                          {
#if defined(_MSC_VER) || defined(MINGW)
  ::Sleep(static_cast<int>(seconds * 1000.0));
#elif defined(__CYGWIN__)
  sleep(static_cast<int>(seconds));
#else
  usleep(static_cast<int>(seconds * 1000000.0));
#endif
}

SlidingWindowCmnInternal()

void kaldi::SlidingWindowCmnInternal	(	const SlidingWindowCmnOptions &	opts,
		const MatrixBase< double > &	input,
		MatrixBase< double > *	output
	)

Definition at line 250 of file feature-functions.cc.

References VectorBase< Real >::AddDiagMat2(), VectorBase< Real >::AddVec(), VectorBase< Real >::AddVec2(), VectorBase< Real >::ApplyFloor(), VectorBase< Real >::ApplyPow(), SlidingWindowCmnOptions::center, SlidingWindowCmnOptions::Check(), SlidingWindowCmnOptions::cmn_window, VectorBase< Real >::CopyFromVec(), KALDI_ASSERT, KALDI_WARN, kTrans, SlidingWindowCmnOptions::max_warnings, SlidingWindowCmnOptions::min_window, VectorBase< Real >::MulElements(), SlidingWindowCmnOptions::normalize_variance, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), VectorBase< Real >::Scale(), and VectorBase< Real >::Set().

Referenced by SlidingWindowCmn().

                                                          {
  opts.Check();
  int32 num_frames = input.NumRows(), dim = input.NumCols(),
        last_window_start = -1, last_window_end = -1,
        warning_count = 0;
  Vector<double> cur_sum(dim), cur_sumsq(dim);

  for (int32 t = 0; t < num_frames; t++) {
    int32 window_start, window_end; // note: window_end will be one
    // past the end of the window we use for normalization.
    if (opts.center) {
      window_start = t - (opts.cmn_window / 2);
      window_end = window_start + opts.cmn_window;
    } else {
      window_start = t - opts.cmn_window;
      window_end = t + 1;
    }
    if (window_start < 0) { // shift window right if starts <0.
      window_end -= window_start;
      window_start = 0; // or: window_start -= window_start
    }
    if (!opts.center) {
      if (window_end > t)
        window_end = std::max(t + 1, opts.min_window);
    }
    if (window_end > num_frames) {
      window_start -= (window_end - num_frames);
      window_end = num_frames;
      if (window_start < 0) window_start = 0;
    }
    if (last_window_start == -1) {
      SubMatrix<double> input_part(input,
                                      window_start, window_end - window_start,
                                      0, dim);
      cur_sum.AddRowSumMat(1.0, input_part , 0.0);
      if (opts.normalize_variance)
        cur_sumsq.AddDiagMat2(1.0, input_part, kTrans, 0.0);
    } else {
      if (window_start > last_window_start) {
        KALDI_ASSERT(window_start == last_window_start + 1);
        SubVector<double> frame_to_remove(input, last_window_start);
        cur_sum.AddVec(-1.0, frame_to_remove);
        if (opts.normalize_variance)
          cur_sumsq.AddVec2(-1.0, frame_to_remove);
      }
      if (window_end > last_window_end) {
        KALDI_ASSERT(window_end == last_window_end + 1);
        SubVector<double> frame_to_add(input, last_window_end);
        cur_sum.AddVec(1.0, frame_to_add);
        if (opts.normalize_variance)
          cur_sumsq.AddVec2(1.0, frame_to_add);
      }
    }
    int32 window_frames = window_end - window_start;
    last_window_start = window_start;
    last_window_end = window_end;

    KALDI_ASSERT(window_frames > 0);
    SubVector<double> input_frame(input, t),
        output_frame(*output, t);
    output_frame.CopyFromVec(input_frame);
    output_frame.AddVec(-1.0 / window_frames, cur_sum);

    if (opts.normalize_variance) {
      if (window_frames == 1) {
        output_frame.Set(0.0);
      } else {
        Vector<double> variance(cur_sumsq);
        variance.Scale(1.0 / window_frames);
        variance.AddVec2(-1.0 / (window_frames * window_frames), cur_sum);
        // now "variance" is the variance of the features in the window,
        // around their own mean.
        int32 num_floored;
        variance.ApplyFloor(1.0e-10, &num_floored);
        if (num_floored > 0 && num_frames > 1) {
          if (opts.max_warnings == warning_count) {
            KALDI_WARN << "Suppressing the remaining variance flooring "
                       << "warnings. Run program with --max-warnings=-1 to "
                       << "see all warnings.";
          }
          // If opts.max_warnings is a negative number, we won't restrict the
          // number of times that the warning is printed out.
          else if (opts.max_warnings < 0
                   || opts.max_warnings > warning_count) {
            KALDI_WARN << "Flooring when normalizing variance, floored "
                       << num_floored << " elements; num-frames was "
                       << window_frames;
          }
          warning_count++;
        }
        variance.ApplyPow(-0.5); // get inverse standard deviation.
        output_frame.MulElements(variance);
      }
    }
  }
}

SlowMatMul()

static void kaldi::SlowMatMul ( )

static

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

References MatrixBase< Real >::AddMatMat(), rnnlm::i, and kNoTrans.

                                                 {
  MatrixIndexT N = 1000;
  Matrix<Real> M(N, N), P(N, N), Q(N, N);
  for (MatrixIndexT i = 0; i < 10000; i++) {
    Q.AddMatMat(1.0, M, kNoTrans, P, kNoTrans, 0.0);
  }
}

SolveDoubleQuadraticMatrixProblem() [1/2]

template float kaldi::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
	)

SolveDoubleQuadraticMatrixProblem() [2/2]

template double kaldi::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
	)

SolveQuadraticMatrixProblem() [1/2]

template float kaldi::SolveQuadraticMatrixProblem	(	const SpMatrix< float > &	Q,
		const MatrixBase< float > &	Y,
		const SpMatrix< float > &	SigmaInv,
		const SolverOptions &	opts,
		MatrixBase< float > *	M
	)

SolveQuadraticMatrixProblem() [2/2]

template double kaldi::SolveQuadraticMatrixProblem	(	const SpMatrix< double > &	Q,
		const MatrixBase< double > &	Y,
		const SpMatrix< double > &	SigmaInv,
		const SolverOptions &	opts,
		MatrixBase< double > *	M
	)

SolveQuadraticProblem() [1/2]

double SolveQuadraticProblem	(	const SpMatrix< double > &	H,
		const VectorBase< double > &	g,
		const SolverOptions &	opts,
		VectorBase< double > *	x
	)

Definition at line 635 of file sp-matrix.cc.

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::AddSpVec(), VectorBase< Real >::AddVec(), SpMatrix< Real >::AddVec2Sp(), VectorBase< Real >::ApplyFloor(), VectorBase< Real >::ApplyPow(), SolverOptions::Check(), VectorBase< Real >::CopyDiagFromSp(), VectorBase< Real >::CopyFromVec(), SolverOptions::diagonal_precondition, VectorBase< Real >::Dim(), VectorBase< Real >::DivElements(), SolverOptions::eps, rnnlm::i, VectorBase< Real >::InvertElements(), SpMatrix< Real >::IsZero(), SolverOptions::K, KALDI_ASSERT, KALDI_LOG, KALDI_WARN, kNoTrans, kTrans, VectorBase< Real >::Max(), VectorBase< Real >::MulElements(), SolverOptions::name, PackedMatrix< Real >::NumRows(), SolverOptions::optimize_delta, SolverOptions::print_debug_output, SpMatrix< Real >::SymPosSemiDefEig(), VecSpVec(), and VecVec().

Referenced by LinearCgd(), SolveDoubleQuadraticMatrixProblem(), SolveQuadraticProblem(), SolverOptions::SolverOptions(), UnitTestSolve(), MleSgmm2SpeakerAccs::UpdateNoU(), EbwAmSgmm2Updater::UpdatePhoneVectorsInternal(), MleAmSgmm2Updater::UpdatePhoneVectorsInternal(), EbwAmSgmm2Updater::UpdateU(), MleAmSgmm2Updater::UpdateU(), EbwAmSgmm2Updater::UpdateW(), MleAmSgmm2Updater::UpdateW(), IvectorExtractorStats::UpdateWeight(), and MleSgmm2SpeakerAccs::UpdateWithU().

                                                               {
  KALDI_ASSERT(H.NumRows() == g.Dim() && g.Dim() == x->Dim() && x->Dim() != 0);
  opts.Check();
  MatrixIndexT dim = x->Dim();
  if (H.IsZero(0.0)) {
    KALDI_WARN << "Zero quadratic term in quadratic vector problem for "
               << opts.name << ": leaving it unchanged.";
    return 0.0;
  }
  if (opts.diagonal_precondition) {
    // We can re-cast the problem with a diagonal preconditioner to
    // make H better-conditioned.
    Vector<double> H_diag(dim);
    H_diag.CopyDiagFromSp(H);
    H_diag.ApplyFloor(std::numeric_limits<double>::min() * 1.0E+3);
    Vector<double> H_diag_sqrt(H_diag);
    H_diag_sqrt.ApplyPow(0.5);
    Vector<double> H_diag_inv_sqrt(H_diag_sqrt);
    H_diag_inv_sqrt.InvertElements();
    Vector<double> x_scaled(*x);
    x_scaled.MulElements(H_diag_sqrt);
    Vector<double> g_scaled(g);
    g_scaled.MulElements(H_diag_inv_sqrt);
    SpMatrix<double> H_scaled(dim);
    H_scaled.AddVec2Sp(1.0, H_diag_inv_sqrt, H, 0.0);
    double ans;
    SolverOptions new_opts(opts);
    new_opts.diagonal_precondition = false;
    ans = SolveQuadraticProblem(H_scaled, g_scaled, new_opts, &x_scaled);
    x->CopyFromVec(x_scaled);
    x->MulElements(H_diag_inv_sqrt);
    return ans;
  }
  Vector<double> gbar(g);
  if (opts.optimize_delta) gbar.AddSpVec(-1.0, H, *x, 1.0);  // gbar = g - H x
  Matrix<double> U(dim, dim);
  Vector<double> l(dim);
  H.SymPosSemiDefEig(&l, &U);  // does svd H = U L V^T and checks that H == U L U^T to within a tolerance.
  // floor l.
  double f = std::max(static_cast<double>(opts.eps), l.Max() / opts.K);
  MatrixIndexT nfloored = 0;
  for (MatrixIndexT i = 0; i < dim; i++) {  // floor l.
    if (l(i) < f) {
      nfloored++;
      l(i) = f;
    }
  }
  if (nfloored != 0 && opts.print_debug_output) {
    KALDI_LOG << "Solving quadratic problem for " << opts.name
              << ": floored " << nfloored<< " eigenvalues. ";
  }
  Vector<double> tmp(dim);
  tmp.AddMatVec(1.0, U, kTrans, gbar, 0.0);  // tmp = U^T \bar{g}
  tmp.DivElements(l);  // divide each element of tmp by l: tmp = \tilde{L}^{-1} U^T \bar{g}
  Vector<double> delta(dim);
  delta.AddMatVec(1.0, U, kNoTrans, tmp, 0.0);  // delta = U tmp = U \tilde{L}^{-1} U^T \bar{g}
  Vector<double> &xhat(tmp);
  xhat.CopyFromVec(delta);
  if (opts.optimize_delta) xhat.AddVec(1.0, *x);  // xhat = x + delta.
  double auxf_before = VecVec(g, *x) - 0.5 * VecSpVec(*x, H, *x),
         auxf_after = VecVec(g, xhat) - 0.5 * VecSpVec(xhat, H, xhat);
  if (auxf_after < auxf_before) {  // Reject change.
    if (auxf_after < auxf_before - 1.0e-10 && opts.print_debug_output)
      KALDI_WARN << "Optimizing vector auxiliary function for "
                 << opts.name<< ": auxf decreased " << auxf_before
                 << " to "  << auxf_after <<  ", change is "
                 << (auxf_after-auxf_before);
    return 0.0;
  } else {
    x->CopyFromVec(xhat);
    return auxf_after - auxf_before;
  }
}

SolveQuadraticProblem() [2/2]

float SolveQuadraticProblem	(	const SpMatrix< float > &	H,
		const VectorBase< float > &	g,
		const SolverOptions &	opts,
		VectorBase< float > *	x
	)

Definition at line 712 of file sp-matrix.cc.

References VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Dim(), KALDI_ASSERT, PackedMatrix< Real >::NumRows(), and SolveQuadraticProblem().

                                                             {
  KALDI_ASSERT(H.NumRows() == g.Dim() && g.Dim() == x->Dim() && x->Dim() != 0);
  SpMatrix<double> Hd(H);
  Vector<double> gd(g);
  Vector<double> xd(*x);
  float ans = static_cast<float>(SolveQuadraticProblem(Hd, gd, opts, &xd));
  x->CopyFromVec(xd);
  return ans;
}

SortAndUniq()

void kaldi::SortAndUniq ( std::vector< T > *  vec )

inline

Sorts and uniq's (removes duplicates) from a vector.

Definition at line 39 of file stl-utils.h.

Referenced by ComputationGraphBuilder::AddDependencies(), AutomaticallyObtainQuestions(), HmmTopology::Check(), Nnet::Check(), kaldi::nnet3::ComputeCommandAttributes(), kaldi::nnet3::ComputeComputationGraph(), kaldi::nnet3::ComputeComputationPhasesForEpoch(), kaldi::nnet3::ComputeMatrixAccesses(), ComputationVariables::ComputeSplitPoints(), kaldi::nnet3::ComputeVariableAccesses(), ConstIntegerSet< EventValueType >::ConstIntegerSet(), ContextDependency::EnumeratePairs(), WordAlignLatticeLexiconInfo::FinalizeViabilityMap(), kaldi::nnet3::FindNStride(), GenerateLexicon(), GenRandStats(), GetHTransducer(), ContextDependency::GetPdfInfo(), GetPdfsForPhones(), GetPhonesForPdfs(), kaldi::nnet3::time_height_convolution::GetRandomConvolutionIndexes(), kaldi::nnet3::time_height_convolution::GetRandomConvolutionModel(), kaldi::nnet3::IndexesMultiToSubmatrixIndexes(), ConstIntegerSet< EventValueType >::Init(), TimeHeightConvolutionComponent::InitFromConfig(), Questions::InitRand(), InverseLeftBiphoneContextFst::InverseLeftBiphoneContextFst(), KMeansClusterPhones(), main(), kaldi::nnet3::MakeSccGraph(), SplitEventMap::MapValues(), kaldi::nnet3::NnetToDirectedGraph(), ProcessTopo(), ComputationGraphBuilder::PruneDependencies(), ReadSymbolTableAsIntegers(), RenumberEventMap(), ShareEventMapLeaves(), SingleUtteranceGmmDecoder::SingleUtteranceGmmDecoder(), Compiler::SplitByScale(), TestClusterEventMapGetMappingAndRenumberEventMap(), TestClusterEventMapGetMappingAndRenumberEventMap2(), TestEventMapPrune(), fst::TestMakeLinearAcceptor(), TestShareEventMapLeaves(), TestSortAndUniq(), TrainingGraphCompiler::TrainingGraphCompiler(), kaldi::nnet2::UnitTestSolvePackingProblem(), and WordAlignLatticeLexiconInfo::UpdateEquivalenceMap().

                                           {
  std::sort(vec->begin(), vec->end());
  vec->erase(std::unique(vec->begin(), vec->end()), vec->end());
}

SortSvd() [1/2]

template void kaldi::SortSvd	(	VectorBase< float > *	s,
		MatrixBase< float > *	U,
		MatrixBase< float > *	Vt,
		bool
	)

SortSvd() [2/2]

template void kaldi::SortSvd	(	VectorBase< double > *	s,
		MatrixBase< double > *	U,
		MatrixBase< double > *	Vt,
		bool
	)

Referenced by SortSvd().

SparseMatrixUnitTest()

void kaldi::SparseMatrixUnitTest

(

)

Definition at line 314 of file sparse-matrix-test.cc.

References rnnlm::i.

                            {
  // SparseVector
  UnitTestSparseVectorSum<Real>();
  UnitTestSparseVectorAddToVec<Real>();
  UnitTestSparseVectorMax<Real>();
  UnitTestSparseVectorVecSvec<Real>();

  // SparseMatrix
  UnitTestSparseMatrixSum<Real>();
  UnitTestSparseMatrixFrobeniusNorm<Real>();
  UnitTestSparseMatrixAddToMat<Real>();
  UnitTestSparseMatrixTraceMatSmat<Real>();
  for (int32 i = 0; i < 30; i++)
    UnitTestSparseMatrixConstructor<Real>();


  // Matrix functions involving sparse matrices.
  UnitTestMatrixAddMatSmat<Real>();
  UnitTestMatrixAddSmatMat<Real>();
}

SplitArgOnEquals()

void kaldi::SplitArgOnEquals	(	const std::string &	arg,
		std::string *	name,
		std::string *	rspecifier
	)

Definition at line 33 of file nnet3-get-egs-simple.cc.

References ClassifyRspecifier(), IsToken(), KALDI_ERR, and kNoRspecifier.

Referenced by main().

                                             {
  size_t pos = arg.find_first_of('=');
  if (pos == std::string::npos) {
    KALDI_ERR << "Bad command line argument (expecting '='): "
              << arg;
  }
  *name = std::string(arg, 0, pos);
  *rspecifier = std::string(arg, pos + 1);
  if (!IsToken(*name)) {
    KALDI_ERR << "Bad command line argument (expecting a valid name before '='): "
              << arg;
  }
  if (ClassifyRspecifier(*rspecifier, NULL, NULL) == kNoRspecifier) {
    KALDI_ERR << "Bad command line argument (expecting an rspecifier after '='): "
              << arg;
  }
}

SplitEgsKey()

bool kaldi::SplitEgsKey	(	const std::string &	key,
		std::string *	utt_id,
		int32 *	frame_id
	)

Definition at line 34 of file nnet-relabel-egs.cc.

Referenced by main().

                                                        {
    size_t start = 0, found = 0, end = key.size();
    utt_id->clear();
 
    found = key.find_last_of("-", end);
    // start != end condition is for when the delimiter is at the end
    
    if (found != start && start != end && found < end) {
      *utt_id = key.substr(start, found - start);
      std::istringstream tmp(key.substr(found + 1, end));
      tmp >> *frame_id;
      return true;
    }

    return false;
  }

SplitStringOnFirstSpace()

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".

If there is no such space, everything that remains after removing leading and trailing whitespace goes in "first".

Definition at line 120 of file text-utils.cc.

References KALDI_ASSERT.

Referenced by ConvertStringToInteger(), SequentialTableReaderScriptImpl< Holder >::NextScpLine(), ReadScriptFile(), and TestSplitStringOnFirstSpace().

                                              {
  const char *white_chars = " \t\n\r\f\v";
  typedef std::string::size_type I;
  const I npos = std::string::npos;
  I first_nonwhite = str.find_first_not_of(white_chars);
  if (first_nonwhite == npos) {
    first->clear();
    rest->clear();
    return;
  }
  // next_white is first whitespace after first nonwhitespace.
  I next_white = str.find_first_of(white_chars, first_nonwhite);

  if (next_white == npos) {  // no more whitespace...
    *first = std::string(str, first_nonwhite);
    rest->clear();
    return;
  }
  I next_nonwhite = str.find_first_not_of(white_chars, next_white);
  if (next_nonwhite == npos) {
    *first = std::string(str, first_nonwhite, next_white-first_nonwhite);
    rest->clear();
    return;
  }

  I last_nonwhite = str.find_last_not_of(white_chars);
  KALDI_ASSERT(last_nonwhite != npos);  // or coding error.

  *first = std::string(str, first_nonwhite, next_white-first_nonwhite);
  *rest = std::string(str, next_nonwhite, last_nonwhite+1-next_nonwhite);
}

SplitStringToFloats() [1/3]

bool SplitStringToFloats	(	const std::string &	full,
		const char *	delim,
		bool	omit_empty_strings,
		std::vector< F > *	out
	)

Definition at line 30 of file text-utils.cc.

References ConvertStringToReal(), full, rnnlm::i, KALDI_ASSERT, and SplitStringToVector().

Referenced by GetWeights(), main(), PreparePriors(), SplitStringToIntegers(), SplitStringToWeights(), and TestSplitStringToFloats().

                                            {
  KALDI_ASSERT(out != NULL);
  if (*(full.c_str()) == '\0') {
    out->clear();
    return true;
  }
  std::vector<std::string> split;
  SplitStringToVector(full, delim, omit_empty_strings, &split);
  out->resize(split.size());
  for (size_t i = 0; i < split.size(); i++) {
    F f = 0;
    if (!ConvertStringToReal(split[i], &f))
      return false;
    (*out)[i] = f;
  }
  return true;
}

SplitStringToFloats() [2/3]

template bool kaldi::SplitStringToFloats	(	const std::string &	full,
		const char *	delim,
		bool	omit_empty_strings,
		std::vector< float > *	out
	)

SplitStringToFloats() [3/3]

template bool kaldi::SplitStringToFloats	(	const std::string &	full,
		const char *	delim,
		bool	omit_empty_strings,
		std::vector< double > *	out
	)

SplitStringToIntegers()

bool kaldi::SplitStringToIntegers	(	const std::string &	full,
		const char *	delim,
		bool	omit_empty_strings,
		std::vector< I > *	out
	)

Split a string (e.g.

1:2:3) into a vector of integers.

Parameters

[in]	delim	String containing a list of characters, any of which is allowed as a delimiter.
[in]	omit_empty_strings	If true, empty strings between delimiters are allowed and will not produce an output integer; if false, instances of characters in 'delim' that are consecutive or at the start or end of the string would be an error. You'll normally want this to be true if 'delim' consists of spaces, and false otherwise.
[out]	out	The output list of integers.

Definition at line 68 of file text-utils.h.

References full, rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_ASSERT_IS_INTEGER_TYPE, KALDI_STRTOLL, SplitStringToFloats(), and SplitStringToVector().

Referenced by AccumulateTreeStatsInfo::AccumulateTreeStatsInfo(), ExampleGenerationConfig::ComputeDerived(), DiscriminativeComputation::DiscriminativeComputation(), ExtractObjectRange(), GetSkipLayers(), ConfigLine::GetValue(), Splice::InitData(), BlockSoftmax::InitData(), CopyComponent::InitData(), TimeHeightConvolutionComponent::InitFromConfig(), TdnnComponent::InitFromConfig(), PermuteComponent::InitFromConfig(), main(), NnetDiscriminativeUpdater::NnetDiscriminativeUpdater(), OnlineCmvn::OnlineCmvn(), OnlineSilenceWeighting::OnlineSilenceWeighting(), kaldi::nnet2::ParseFromString(), ExampleMergingConfig::ParseIntSet(), ParseMatrixRangeSpecifier(), fst::ReadFstKaldi(), ReadIntegerVectorVectorSimple(), ReadLexiconForWordAlign(), ReadSharedPhonesList(), WordBoundaryInfo::SetOptions(), SingleUtteranceGmmDecoder::SingleUtteranceGmmDecoder(), kaldi::nnet3::SummarizeVector(), TestSplitStringToIntegers(), and TrailingSilenceLength().

                                              {
  KALDI_ASSERT(out != NULL);
  KALDI_ASSERT_IS_INTEGER_TYPE(I);
  if (*(full.c_str()) == '\0') {
    out->clear();
    return true;
  }
  std::vector<std::string> split;
  SplitStringToVector(full, delim, omit_empty_strings, &split);
  out->resize(split.size());
  for (size_t i = 0; i < split.size(); i++) {
    const char *this_str = split[i].c_str();
    char *end = NULL;
    int64 j = 0;
    j = KALDI_STRTOLL(this_str, &end);
    if (end == this_str || *end != '\0') {
      out->clear();
      return false;
    } else {
      I jI = static_cast<I>(j);
      if (static_cast<int64>(jI) != j) {
        // output type cannot fit this integer.
        out->clear();
        return false;
      }
      (*out)[i] = jI;
    }
  }
  return true;
}

SplitStringToVector()

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.

If omit_empty_strings == true, the output will contain any nonempty strings after splitting on any of the characters in the delimiter. If omit_empty_strings == false, the output will contain n+1 strings if there are n characters in the set "delim" within the input string. In this case the empty string is split to a single empty string.

Definition at line 63 of file text-utils.cc.

Referenced by ClassifyRspecifier(), ClassifyWspecifier(), ExampleMergingConfig::ComputeDerived(), CopyExcludedFeats(), CopyIncludedFeats(), CopySubsetLattices(), ExtractObjectRange(), ExtractRangeSpecifier(), GetUtterancePairs(), WordBoundaryInfo::Init(), TimeHeightConvolutionComponent::InitFromConfig(), MultiTaskLoss::InitFromString(), main(), kaldi::nnet2::ParseFromString(), ExampleMergingConfig::ParseIntSet(), ParseMatrixRangeSpecifier(), PrepareMap(), kaldi::nnet3::ProcessRangeFile(), ArpaFileParser::Read(), TokenVectorHolder::Read(), ReadCommaSeparatedCommand(), fst::ReadFstKaldi(), LatticeReader::ReadText(), Fmpe::SetContexts(), SplitStringToFloats(), SplitStringToIntegers(), and TestSplitStringToVector().

                                                    {
  size_t start = 0, found = 0, end = full.size();
  out->clear();
  while (found != std::string::npos) {
    found = full.find_first_of(delim, start);
    // start != end condition is for when the delimiter is at the end
    if (!omit_empty_strings || (found != start && start != end))
      out->push_back(full.substr(start, found - start));
    start = found + 1;
  }
}

SplitStringToWeights()

void kaldi::SplitStringToWeights	(	const string &	full,
		const char *	delim,
		vector< BaseFloat > *	out
	)

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

References KALDI_WARN, and SplitStringToFloats().

Referenced by main().

                                                  {
  vector<BaseFloat> tmp;
  SplitStringToFloats(full, delim, true /*omit empty strings*/, &tmp);
  if (tmp.size() != out->size()) {
    KALDI_WARN << "Expecting " << out->size() << " weights, found " << tmp.size()
               << ": using uniform weights.";
    return;
  }
  BaseFloat sum = 0;
  for (vector<BaseFloat>::const_iterator itr = tmp.begin();
       itr != tmp.end(); ++itr) {
    if (*itr < 0.0) {
      KALDI_WARN << "Cannot use negative weight: " << *itr << "; input string: "
                 << full << "\n\tUsing uniform weights.";
      return;
    }
    sum += (*itr);
  }
  if (sum != 1.0) {
    KALDI_WARN << "Weights sum to " << sum << " instead of 1: renormalizing";
    for (vector<BaseFloat>::iterator itr = tmp.begin();
         itr != tmp.end(); ++itr)
      (*itr) /= sum;
  }
  out->swap(tmp);
}

SplitToPhonesInternal()

static bool kaldi::SplitToPhonesInternal ( const TransitionModel &  trans_model, const std::vector< int32 > &  alignment, bool  reordered, std::vector< std::vector< int32 > > *  split_output  )

static

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

References TransitionModel::GetTopo(), rnnlm::i, TransitionModel::IsFinal(), TransitionModel::IsSelfLoop(), rnnlm::j, KALDI_ASSERT, kNoPdf, HmmTopology::TopologyForPhone(), TransitionModel::TransitionIdToTransitionState(), TransitionModel::TransitionStateToHmmState(), and TransitionModel::TransitionStateToPhone().

Referenced by SplitToPhones().

                                                                              {
  if (alignment.empty()) return true;  // nothing to split.
  std::vector<size_t> end_points;  // points at which phones end [in an
  // stl iterator sense, i.e. actually one past the last transition-id within
  // each phone]..

  bool was_ok = true;
  for (size_t i = 0; i < alignment.size(); i++) {
    int32 trans_id = alignment[i];
    if (trans_model.IsFinal(trans_id)) {  // is final-prob
      if (!reordered) end_points.push_back(i+1);
      else {  // reordered.
        while (i+1 < alignment.size() &&
              trans_model.IsSelfLoop(alignment[i+1])) {
          KALDI_ASSERT(trans_model.TransitionIdToTransitionState(alignment[i]) ==
                 trans_model.TransitionIdToTransitionState(alignment[i+1]));
          i++;
        }
        end_points.push_back(i+1);
      }
    } else if (i+1 == alignment.size()) {
      // need to have an end-point at the actual end.
      // but this is an error- should have been detected already.
      was_ok = false;
      end_points.push_back(i+1);
    } else {
      int32 this_state = trans_model.TransitionIdToTransitionState(alignment[i]),
          next_state = trans_model.TransitionIdToTransitionState(alignment[i+1]);
      if (this_state == next_state) continue;  // optimization.
      int32 this_phone = trans_model.TransitionStateToPhone(this_state),
          next_phone = trans_model.TransitionStateToPhone(next_state);
      if (this_phone != next_phone) {
        // The phone changed, but this is an error-- we should have detected this via the
        // IsFinal check.
        was_ok = false;
        end_points.push_back(i+1);
      }
    }
  }

  size_t cur_point = 0;
  for (size_t i = 0; i < end_points.size(); i++) {
    split_output->push_back(std::vector<int32>());
    // The next if-statement checks if the initial trans-id at the current end
    // point is the initial-state of the current phone if that initial-state
    // is emitting (a cursory check that the alignment is plausible).
    int32 trans_state =
      trans_model.TransitionIdToTransitionState(alignment[cur_point]);
    int32 phone = trans_model.TransitionStateToPhone(trans_state);
    int32 forward_pdf_class = trans_model.GetTopo().TopologyForPhone(phone)[0].forward_pdf_class;
    if (forward_pdf_class != kNoPdf)  // initial-state of the current phone is emitting
      if (trans_model.TransitionStateToHmmState(trans_state) != 0)
        was_ok = false;
    for (size_t j = cur_point; j < end_points[i]; j++)
      split_output->back().push_back(alignment[j]);
    cur_point = end_points[i];
  }
  return was_ok;
}

StringsApproxEqual()

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.

The definition of 'equal' is normal string equality, except that two substrings like "0.31134" and "0.311341" would be considered equal. 'decimal_places_tolerance' controls how many digits after the '.' have to match up. E.g. StringsApproxEqual("hello 0.23 there", "hello 0.24 there", 2) would return false because there is a difference in the 2nd decimal, but with an argument of 1 it would return true.

Definition at line 335 of file text-utils.cc.

References StringsApproxEqualInternal().

Referenced by kaldi::nnet3::CheckStringsApproxEqual(), ConvertStringToInteger(), kaldi::nnet3::TestNnetComponentCopy(), kaldi::nnet3::TestNnetComponentUpdatable(), and TestStringsApproxEqual().

                                                        {
  return StringsApproxEqualInternal(a.c_str(), b.c_str(),
                                    decimal_places_tolerance, -1);
}

StringsApproxEqualInternal()

bool kaldi::StringsApproxEqualInternal	(	const char *	a,
		const char *	b,
		int32	decimal_places_tolerance,
		int32	places_into_number
	)

Definition at line 286 of file text-utils.cc.

Referenced by StringsApproxEqual().

                                                          {
start:
  char ca = *a, cb = *b;
  if (ca == cb) {
    if (ca == '\0') {
      return true;
    } else {
      if (places_into_number >= 0) {
        if (isdigit(ca)) {
          places_into_number++;
        } else {
          places_into_number = -1;
        }
      } else {
        if (ca == '.') {
          places_into_number = 0;
        }
      }
      a++;
      b++;
      goto start;
    }
  } else {
    if (places_into_number  >= decimal_places_tolerance &&
        (isdigit(ca) || isdigit(cb))) {
      // we're potentially willing to accept this difference between the
      // strings.
      if (isdigit(ca)) a++;
      if (isdigit(cb)) b++;
      // we'll have advanced at least one of the two strings.
      goto start;
    } else if (places_into_number >= 0 &&
               ((ca == '0' && !isdigit(cb)) || (cb == '0' && !isdigit(ca)))) {
      // this clause is designed to ensure that, for example,
      // "0.1" would count the same as "0.100001".
      if (ca == '0') a++;
      else b++;
      places_into_number++;
      goto start;
    } else {
      return false;
    }
  }

}

StringToGmmFlags()

GmmFlagsType StringToGmmFlags

(

std::string

str

)

Convert string which is some subset of "mSwa" to flags.

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

References CharToString(), KALDI_ERR, kGmmAll, kGmmMeans, kGmmTransitions, kGmmVariances, and kGmmWeights.

Referenced by main().

                                             {
  GmmFlagsType flags = 0;
  for (const char *c = str.c_str(); *c != '\0'; c++) {
    switch (*c) {
      case 'm': flags |= kGmmMeans; break;
      case 'v': flags |= kGmmVariances; break;
      case 'w': flags |= kGmmWeights; break;
      case 't': flags |= kGmmTransitions; break;
      case 'a': flags |= kGmmAll; break;
      default: KALDI_ERR << "Invalid element " << CharToString(*c)
                         << " of GmmFlagsType option string "
                         << str;
    }
  }
  return flags;
}

StringToSgmmUpdateFlags()

SgmmUpdateFlagsType StringToSgmmUpdateFlags

(

std::string

str

)

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

References CharToString(), KALDI_ERR, kSgmmAll, kSgmmCovarianceMatrix, kSgmmPhoneProjections, kSgmmPhoneVectors, kSgmmPhoneWeightProjections, kSgmmSpeakerProjections, kSgmmSpeakerWeightProjections, kSgmmSubstateWeights, and kSgmmTransitions.

Referenced by main().

                                                           {
  SgmmUpdateFlagsType flags = 0;
  for (const char *c = str.c_str(); *c != '\0'; c++) {
    switch (*c) {
      case 'v': flags |= kSgmmPhoneVectors; break;
      case 'M': flags |= kSgmmPhoneProjections; break;
      case 'w': flags |= kSgmmPhoneWeightProjections; break;
      case 'S': flags |= kSgmmCovarianceMatrix; break;
      case 'c': flags |= kSgmmSubstateWeights; break;
      case 'N': flags |= kSgmmSpeakerProjections; break;
      case 't': flags |= kSgmmTransitions; break;
      case 'u': flags |= kSgmmSpeakerWeightProjections; break;
      case 'a': flags |= kSgmmAll; break;
      default: KALDI_ERR << "Invalid element " << CharToString(*c)
                         << " of SgmmUpdateFlagsType option string "
                         << str;
    }
  }
  return flags;
}

StringToSgmmWriteFlags()

SgmmWriteFlagsType StringToSgmmWriteFlags

(

std::string

str

)

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

References CharToString(), KALDI_ERR, kSgmmAll, kSgmmBackgroundGmms, kSgmmGlobalParams, kSgmmNormalizers, and kSgmmStateParams.

Referenced by main().

                                                          {
  SgmmWriteFlagsType flags = 0;
  for (const char *c = str.c_str(); *c != '\0'; c++) {
    switch (*c) {
      case 'g': flags |= kSgmmGlobalParams; break;
      case 's': flags |= kSgmmStateParams; break;
      case 'n': flags |= kSgmmNormalizers; break;
      case 'u': flags |= kSgmmBackgroundGmms; break;
      case 'a': flags |= kSgmmAll; break;
      default: KALDI_ERR << "Invalid element " << CharToString(*c)
                         << " of SgmmWriteFlagsType option string "
                         << str;
    }
  }
  return flags;
}

SubtractMovingAverage()

void kaldi::SubtractMovingAverage	(	int32	normalization_window_size,
		Matrix< BaseFloat > *	mat
	)

Definition at line 49 of file process-pitch-feats.cc.

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

Referenced by main().

                                                   {
  int32 num_frames = mat->NumRows();
  Vector<BaseFloat> temp_pitch(num_frames);
  Matrix<BaseFloat> &features = *mat;
  int32 i;
  for (i = 0; i < num_frames; i++)
    temp_pitch(i) = features(i, 1);

  // Moving Window Normalization
  BaseFloat mean = 0.0;
  int32 mid_win = (normalization_window_size - 1) / 2;
  for (i = 0; (i < num_frames) && (i < normalization_window_size); i++) { 
    mean += features(i, 1);
  }
  mean /= i;

  if (num_frames <= normalization_window_size) {
    for (i = 0; i < num_frames; i++) { 
      features(i, 1) -= mean;
    }
  } else {
    for (i = 0; i <= mid_win; i++) { 
      features(i, 1) -= mean;
    } 
    for (i = (mid_win + 1); i < num_frames; i++) {
      if (i + (mid_win + 1) < num_frames)
        mean -= (temp_pitch(i - (mid_win + 1)) - 
                 temp_pitch(i + (mid_win + 1))) / normalization_window_size; 
      features(i,1) -= mean;
    }    
  }
}

swap()

void kaldi::swap ( basic_filebuf< CharT, Traits > &  x, basic_filebuf< CharT, Traits > &  y  )

inline

Definition at line 275 of file basic-filebuf.h.

References basic_filebuf< CharT, Traits >::swap().

Referenced by VectorBase< float >::AddDiagMatMat(), CuMatrixBase< float >::AddDiagVecMat(), MatrixBase< float >::AddDiagVecMat(), CuMatrixBase< float >::AddMatBlock(), CuMatrixBase< float >::AddMatDiagVec(), MatrixBase< float >::AddMatDiagVec(), CuBlockMatrix< Real >::AddMatMat(), MatrixBase< float >::AddMatMatMat(), ChangeReorderingOfAlignment(), kaldi::nnet3::CheckComputationOnline(), PosteriorHolder::Clear(), GaussPostHolder::Clear(), fst::ComposeDeterministicOnDemandInverse(), fst::ConvertLattice(), DiscriminativeSupervisionSplitter::CreateRangeLattice(), DeterminizerStar< F >::Debug(), GeneralDropoutComponent::GetMemo(), GeneralDescriptor::Normalize(), CuSpMatrix< Real >::operator()(), SpMatrix< float >::operator()(), CuPackedMatrix< Real >::operator()(), LatticeDeterminizer< Weight, IntType >::Output(), LatticeLexiconWordAligner::ProcessFinalForceOut(), RandomizeVector(), BottomUpClusterer::ReconstructQueue(), CompartmentalizedBottomUpClusterer::ReconstructQueue(), CompartmentalizedBottomUpClusterer::Renumber(), DctComponent::Reorder(), ReverseVector(), CRnnLM::sortVocab(), RowOpsSplitter::SplitCommand(), basic_filebuf< CharT, Traits >::swap(), SparseVector< Real >::Swap(), SpMatrix< float >::Swap(), TpMatrix< float >::Swap(), IoSpecification::Swap(), CompactLatticeHolder::Swap(), KaldiObjectHolder< KaldiType >::Swap(), CuBlockMatrix< Real >::Swap(), CuSparseMatrix< Real >::Swap(), CuPackedMatrix< Real >::Swap(), DiscriminativeSupervision::Swap(), LatticeHolder::Swap(), VectorFstTplHolder< Arc >::Swap(), GenericHolder< SomeType >::Swap(), WaveData::Swap(), PackedMatrix< float >::Swap(), CuArray< Int32Pair >::Swap(), CompressedMatrix::Swap(), BasicHolder< BasicType >::Swap(), WaveInfoHolder::Swap(), CuVector< float >::Swap(), NnetComputation::MatrixDebugInfo::Swap(), Vector< float >::Swap(), OnlineNaturalGradient::Swap(), HtkMatrixHolder::Swap(), Matrix< BaseFloat >::Swap(), CuMatrix< float >::Swap(), TestClusterBottomUp(), TestEditDistance2(), TestEditDistance2String(), TestHashList(), TestSetOfNumbers(), TraceMatMatMat(), TraceMatMatMatMat(), MatrixBase< float >::Transpose(), UnitTestCuBlockMatrixAddMatBlock(), UnitTestCuBlockMatrixAddMatMat(), UnitTestCuBlockMatrixIO(), UnitTestCuMatrixIO(), UnitTextCuMatrixAddMatSmat(), UnitTextCuMatrixAddSmat(), UnitTextCuMatrixAddSmatMat(), and WordAlignLatticeLexiconInfo::UpdateEquivalenceMap().

                                                                       {
    x.swap(y);
}

SynchronizeGpu()

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.

It just launches a no-op kernel into the legacy default stream. This will have the effect that it will run after any kernels previously launched from any stream(*), and before kernels that will later be launched from any stream(*). (*) does not apply to non-blocking streams.

Note: at the time of writing we never call SynchronizeGpu() from binary-level code because it hasn't become necessary yet; the only program that might have multiple threads actually using the GPU is rnnlm-train (if the user were to invoke it with the ,bg option for loading training examples); but the only CUDA invocation the RnnlmExample::Read() function uses (via CuMatrix::Read()), is cudaMemcpy, which is synchronous already.

Definition at line 638 of file cu-device.cc.

Referenced by NnetBatchComputer::Compute(), and NnetBatchComputer::FormatOutputs().

{ }

TakeLogOfPitch()

void kaldi::TakeLogOfPitch

(

Matrix< BaseFloat > *

mat

)

Definition at line 39 of file process-pitch-feats.cc.

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

Referenced by main().

                                            {
  int32 num_frames = mat->NumRows();
  for (int32 i = 0; i < num_frames; i++) {
    KALDI_ASSERT((*mat)(i, 1) > 0.0);
    (*mat)(i, 1) = Log((*mat)(i, 1));
  }
}

TestAccumulateTreeStatsOptions()

void kaldi::TestAccumulateTreeStatsOptions

(

)

Definition at line 188 of file hmm-utils-test.cc.

References AccumulateTreeStatsOptions::central_position, AccumulateTreeStatsInfo::central_position, AccumulateTreeStatsInfo::ci_phones, AccumulateTreeStatsOptions::ci_phones_str, AccumulateTreeStatsOptions::context_width, AccumulateTreeStatsInfo::context_width, KALDI_ASSERT, AccumulateTreeStatsInfo::phone_map, AccumulateTreeStatsOptions::phone_map_rxfilename, RandInt(), AccumulateTreeStatsOptions::var_floor, and AccumulateTreeStatsInfo::var_floor.

Referenced by main().

                                      {
  AccumulateTreeStatsOptions opts;
  opts.var_floor = RandInt(0, 10);
  opts.ci_phones_str = "3:2:1";
  opts.phone_map_rxfilename = "echo 1 2; echo 2 5 |";
  opts.context_width = RandInt(3, 4);
  opts.central_position = RandInt(0, 2);
  AccumulateTreeStatsInfo info(opts);
  KALDI_ASSERT(info.var_floor == opts.var_floor);
  KALDI_ASSERT(info.ci_phones.size() == 3 && info.ci_phones[2] == 3);
  KALDI_ASSERT(info.phone_map.size() == 3 && info.phone_map[2] == 5);
  KALDI_ASSERT(info.context_width == opts.context_width);
  KALDI_ASSERT(info.central_position == opts.central_position);
}

TestAddToClusters()

static void kaldi::TestAddToClusters ( )

static

Definition at line 156 of file cluster-utils-test.cc.

References AddToClusters(), AssertEqual(), ScalarClusterable::Copy(), DeletePointers(), rnnlm::i, KALDI_ASSERT, and ScalarClusterable::Mean().

Referenced by main().

                                {
  ScalarClusterable a(1.0), b(2.5), c(3.0);
  std::vector<Clusterable*> stats(3);
  stats[0] = a.Copy(); stats[1] = b.Copy(); stats[2] = c.Copy();
  std::vector<int32> assignments(3);
  assignments[0] = 1; assignments[1] = 1; assignments[2] = 4;
  std::vector<Clusterable*> clusters;
  std::vector<Clusterable*> clusters2;
  AddToClusters(stats, assignments, &clusters);

  AddToClusters(stats, assignments, &clusters2);  // do this twice.
  AddToClusters(stats, assignments, &clusters2);

  KALDI_ASSERT(clusters.size() == 5);
  KALDI_ASSERT(clusters[0] == NULL && clusters[1] != NULL && clusters[4] != NULL);
  for (size_t i = 0;i < 5;i++) {
    if (clusters[i] != NULL) {
      AssertEqual(clusters2[i]->Objf(), clusters[i]->Objf()*2);
    }
  }
  AssertEqual(c.Mean(), ((ScalarClusterable*)clusters[4])->Mean());
  AssertEqual( ((ScalarClusterable*)clusters[1])->Mean(), 0.5*(1.0+2.5));
  DeletePointers(&stats);
  DeletePointers(&clusters);
  DeletePointers(&clusters2);
}

TestAddToClustersOptimized()

static void kaldi::TestAddToClustersOptimized ( )

static

Definition at line 183 of file cluster-utils-test.cc.

References ScalarClusterable::Add(), AddToClusters(), AddToClustersOptimized(), AssertEqual(), DeletePointers(), rnnlm::i, KALDI_ASSERT, Rand(), RandGauss(), SumClusterable(), and SumClusterableNormalizer().

Referenced by main().

                                         {
  for (size_t p = 0;p < 100;p++) {
    size_t n_stats = Rand() % 5;
    n_stats = n_stats * n_stats;  // more interestingly distributed.
    std::vector<Clusterable*> stats(n_stats);
    for (size_t i = 0;i < n_stats;i++) {
      if (Rand() % 5 < 4) {
        ScalarClusterable *ptr = new ScalarClusterable(RandGauss());
        if (Rand() % 2 == 0) ptr->Add(*ptr);  // make count equal 2.  for more randomness.
        stats[i] = ptr;
      }  else stats[i] = NULL;  // make some zero. supposed to be robust to this.
    }
    size_t n_clust = 1 + Rand() % 4;
    std::vector<int32> assignments(n_stats);
    for (size_t i = 0;i < assignments.size();i++)
      assignments[i] = Rand() % n_clust;
    std::vector<Clusterable*> clusts1;
    std::vector<Clusterable*> clusts2;
    Clusterable *total = SumClusterable(stats);
    if (total == NULL) {  // no stats were non-NULL.
      KALDI_ASSERT(stats.size() == 0 || stats[0] == NULL);
      DeletePointers(&stats);
      continue;
    }
    AddToClusters(stats, assignments, &clusts1);
    AddToClustersOptimized(stats, assignments, *total, &clusts2);

    BaseFloat tot1 = SumClusterableNormalizer(stats),
        tot2 = SumClusterableNormalizer(clusts1),
        tot3 = SumClusterableNormalizer(clusts2);
    AssertEqual(tot1, tot2);
    AssertEqual(tot1, tot3);
    KALDI_ASSERT(clusts1.size() == clusts2.size());
    for (size_t i = 0;i < clusts1.size();i++) {
      if (clusts1[i] != NULL || clusts2[i] != NULL) {
        KALDI_ASSERT(clusts1[i] != NULL && clusts2[i] != NULL);
        AssertEqual(clusts1[i]->Normalizer(), clusts2[i]->Normalizer());
        AssertEqual( ((ScalarClusterable*)clusts1[i])->Mean(),
                     ((ScalarClusterable*)clusts2[i])->Mean() );
      }
    }
    delete total;
    DeletePointers(&clusts1);
    DeletePointers(&clusts2);
    DeletePointers(&stats);
  }
}

TestBuildTree()

void kaldi::TestBuildTree

(

)

Definition at line 90 of file build-tree-test.cc.

References BuildTree(), DeleteBuildTreeStats(), GenRandStats(), Questions::GetKeysWithQuestions(), Questions::GetQuestionsOf(), Questions::HasQuestionsForKey(), rnnlm::i, QuestionsForKey::initial_questions, Questions::InitRand(), rnnlm::j, KALDI_ASSERT, KALDI_VLOG, kAllKeysUnion, EventMap::Map(), Rand(), RandUniform(), EventMap::Write(), WriteBasicType(), WriteBuildTreeStats(), and WriteIntegerVector().

Referenced by main().

                     {
  for (int32 p = 0; p < 3; p++) {
    // First decide phone-ids, hmm lengths, is-ctx-dep...

    int32 dim = 1 + Rand() % 40;
    int32 num_phones = 1 + Rand() % 8;
    int32 num_stats = 1 + (Rand() % 15) * (Rand() % 15);  // up to 14^2 + 1 separate stats.
    int32 N = 2 + Rand() % 2;  // 2 or 3.
    int32 P = Rand() % N;
    float ctx_dep_prob = 0.5 + 0.5*RandUniform();

    std::vector<int32> phone_ids(num_phones);
    for (size_t i = 0;i < (size_t)num_phones;i++)
      phone_ids[i] = (i == 0 ? (Rand() % 2) : phone_ids[i-1] + 1 + (Rand()%2));
    int32 max_phone = *std::max_element(phone_ids.begin(), phone_ids.end());
    std::vector<int32> hmm_lengths(max_phone+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.  These were tested in TestGenRandStats() above.
    BuildTreeStatsType stats;
    bool ensure_all_covered = false;
    GenRandStats(dim, num_stats, N, P, phone_ids, hmm_lengths, is_ctx_dep, ensure_all_covered, &stats);

    {  // print out the stats.
      std::cout << "Writing random stats.";
      std::cout << "dim = " << dim << '\n';
      std::cout << "num_phones = " << num_phones << '\n';
      std::cout << "num_stats = " << num_stats << '\n';
      std::cout << "N = "<< N << '\n';
      std::cout << "P = "<< P << '\n';
      std::cout << "is-ctx-dep = ";
      for (size_t i = 0;i < is_ctx_dep.size();i++)
        WriteBasicType(std::cout, false, static_cast<bool>(is_ctx_dep[i]));
      std::cout << "hmm_lengths = "; WriteIntegerVector(std::cout, false, hmm_lengths);
      std::cout << "phone_ids = "; WriteIntegerVector(std::cout, false, phone_ids);
      std::cout << "Stats are: \n";
      WriteBuildTreeStats(std::cout, false, 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

    {
      std::cout << "Printing questions:\n";
      std::vector<EventKeyType> keys;
      qopts.GetKeysWithQuestions(&keys);
      for (size_t i = 0;i < keys.size();i++) {
        KALDI_ASSERT(qopts.HasQuestionsForKey(keys[i]));
        const QuestionsForKey &opts = qopts.GetQuestionsOf(keys[i]);
        std::cout << "num-quest: "<< opts.initial_questions.size() << '\n';
        for (size_t j = 0;j < opts.initial_questions.size();j++) {
          for (size_t k = 0;k < opts.initial_questions[j].size();k++)
            std::cout << opts.initial_questions[j][k] <<" ";
          std::cout << '\n';
        }
      }
    }

    float thresh = 100.0 * RandUniform();
    int max_leaves = 100;
    std::cout <<"Thresh = "<<thresh<<" for building tree.\n";

    {
      std::cout << "Building tree\n";
      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);

      if (p % 3 != 0) {
        bool round_num_leaves = true;

        EventMap *tree_not_rounded =
               BuildTree(qopts, phone_sets, hmm_lengths, share_roots,
                         do_split, stats, thresh, max_leaves, 0.0, P,
                         false);

        tree = BuildTree(qopts, phone_sets, hmm_lengths, share_roots,
                         do_split, stats, thresh, max_leaves, 0.0, P,
                         round_num_leaves);

        BuildTreeStatsType::const_iterator iter, end = stats.end();

        std::map<EventAnswerType, std::set<EventAnswerType> > mapping;
        int32 num_removed = 0;
        for (iter = stats.begin(); iter != end; ++iter) {
          const EventType &evec =  iter->first;
          EventAnswerType ans_not_rounded;
          KALDI_ASSERT(tree_not_rounded->Map(evec, &ans_not_rounded));

          EventAnswerType ans;
          KALDI_ASSERT(tree->Map(evec, &ans));

          auto it = mapping.find(ans);
          if (it == mapping.end()) {
            std::set<EventAnswerType> leaf_set;
            leaf_set.insert(ans_not_rounded);
            mapping.insert(it, std::make_pair(ans, leaf_set));
          } else if (it->second.count(ans_not_rounded) == 0) {
            num_removed++;
            it->second.insert(ans_not_rounded);
          }
        }

        std::cout << "Leaf rounding map:\n";
        for (auto it = mapping.begin(); it != mapping.end(); ++it) {
          WriteBasicType(std::cout, false, it->first);
          for (auto it2 = it->second.begin(); it2 != it->second.end(); ++it2) {
            WriteBasicType(std::cout, false, *it2);
          }
          std::cout << std::endl;
        }

        KALDI_ASSERT(num_removed < 8);
      } else {
        tree = BuildTree(qopts, phone_sets, hmm_lengths, share_roots,
                         do_split, stats, thresh, max_leaves, 0.0, P,
                         false);
      }

      // Would have print-out & testing code here.
      std::cout << "Tree [default build] is:\n";
      tree->Write(std::cout, false);
      delete tree;
    }
    DeleteBuildTreeStats(&stats);
  }
}

TestBuildTreeStatsIo()

void kaldi::TestBuildTreeStatsIo

(

bool

binary

)

Definition at line 838 of file build-tree-utils-test.cc.

References rnnlm::i, KALDI_ASSERT, Rand(), ReadBuildTreeStats(), Input::Stream(), and WriteBuildTreeStats().

Referenced by main().

                                       {
  for (int32 p = 0; p < 10; p++) {
    size_t num_stats = Rand() % 20;
    BuildTreeStatsType stats;
    for (size_t i = 0; i < num_stats; i++) {
      EventType ev;
      int32 ev_sz = Rand() % 5;
      for (int32 i = 0; i < ev_sz; i++) {
        EventKeyType key = (i == 0 ? 0 : ev[i-1].first) + Rand() % 2, value = Rand() % 10;
        ev.push_back(std::make_pair(key, value));
      }
      stats.push_back(std::make_pair(ev, (Clusterable*) NULL));
    }
    const char *filename = "tmpf";
    WriteBuildTreeStats(Output(filename, binary).Stream(), binary, stats);

    {
      bool binary_in;
      BuildTreeStatsType stats2;
      GaussClusterable gc;  // just need some random Clusterable object
      Input ki(filename, &binary_in);
      ReadBuildTreeStats(ki.Stream(),
                         binary_in, gc, &stats2);
      KALDI_ASSERT(stats == stats2);
    }
  }

  unlink("tmpf");
}

TestClusterBottomUp()

static void kaldi::TestClusterBottomUp ( )

static

Definition at line 232 of file cluster-utils-test.cc.

References ClusterBottomUp(), DeletePointers(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, Rand(), RandUniform(), and swap().

Referenced by main().

                                  {
  for (size_t i = 0;i < 10;i++) {
    size_t n_clust = Rand() % 10;
    std::vector<Clusterable*> points;
    for (size_t j = 0;j < n_clust;j++) {
      size_t n_points = 1 + Rand() % 5;
      BaseFloat clust_center  = (BaseFloat)j;
      for (size_t k = 0;k < n_points;k++) points.push_back(new ScalarClusterable(clust_center + RandUniform()*0.01));
    }

    BaseFloat max_merge_thresh = 0.1;
    size_t min_clust = Rand() % 10;  // use max_merge_thresh to control #clust.
    std::vector<Clusterable*> clusters;
    std::vector<int32> assignments;

    for (size_t i = 0;i < points.size();i++) {
      size_t j = Rand() % points.size();
      if (i != j) std::swap(points[i], points[j]);  // randomize order.
    }


    float ans = ClusterBottomUp(points, max_merge_thresh, min_clust, &clusters, &assignments);

    KALDI_ASSERT(ans < 0.000001);  //  objf change should be negative.
    KALDI_LOG << "Objf change from bottom-up clustering is "<<ans<<'\n';

    ClusterBottomUp(points, max_merge_thresh, min_clust, NULL, NULL);  // make sure no crash.

    if (0) {  // for debug if it breaks.
      for (size_t i = 0;i < points.size();i++) {
        KALDI_LOG << "point " << i << ": " << ((ScalarClusterable*)points[i])->Info() << " -> " << assignments[i];
      }
      for (size_t i = 0;i < clusters.size();i++) {
        KALDI_LOG << "clust " << i << ": " << ((ScalarClusterable*)clusters[i])->Info();
      }
    }

    KALDI_ASSERT(clusters.size() == std::max(n_clust, std::min(points.size(), min_clust)));

    for (size_t i = 0;i < points.size();i++) {
      size_t j = Rand() % points.size();
      BaseFloat xi = ((ScalarClusterable*)points[i])->Mean(),
          xj = ((ScalarClusterable*)points[j])->Mean();
      if (fabs(xi-xj) < 0.011) {
        if (clusters.size() == n_clust) KALDI_ASSERT(assignments[i] == assignments[j]);
      } else KALDI_ASSERT(assignments[i] != assignments[j]);
    }
    DeletePointers(&clusters);
    DeletePointers(&points);
  }

}

TestClusterEventMap()

void kaldi::TestClusterEventMap

(

)

Definition at line 376 of file build-tree-utils-test.cc.

References ClusterEventMap(), DeleteBuildTreeStats(), DoTableSplit(), rnnlm::i, rnnlm::j, KALDI_ASSERT, EventMap::Map(), rnnlm::n, Rand(), RandUniform(), and TrivialTree().

Referenced by main().

                           {
  // This second testing routine checks that ClusterEventMap does not renumber leaves whose stats
  // we exclude.
  // ClusterEventMapGetMapping (the internal version) were tested in another
  // testing routine.

  EventKeyType key = 0;  // just one key.
  for (size_t iter = 0;iter < 1;iter++) {  // in loop anyway.
    BuildTreeStatsType stats;
    EventValueType cur_value = 0;
    int32 num_clust = 10;
    for (int32 i = 0;i < num_clust;i++) {  // this will correspond to the "cluster".
      size_t n = 1 + Rand() % 3;
      for (size_t j = 0;j < n;j++) {
        BaseFloat scalar = static_cast<BaseFloat>(i) + RandUniform()*0.001;
        EventType evec;
        evec.push_back(std::make_pair(key, cur_value++));
        stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(new ScalarClusterable(scalar))));
      }
    }

    int32 nleaves = 0;
    EventMap *trivial_map = TrivialTree(&nleaves);

    EventMap *table_map = DoTableSplit(*trivial_map, key, stats, &nleaves);
    KALDI_ASSERT(nleaves == cur_value);

    std::set<EventValueType> exclude_leaves;
    for (size_t i = 0;i < 4;i++) exclude_leaves.insert(Rand() % num_clust);
    BuildTreeStatsType stats_excluded;
    BuildTreeStatsType stats_included;
    for (size_t i = 0;i < stats.size();i++) {
      if (exclude_leaves.count(stats[i].first[0].second) != 0) {  // this code relies on the fact that there is just one event in the EventVector.
        stats_excluded.push_back(stats[i]);
      } else {
        stats_included.push_back(stats[i]);
      }
    }
    KALDI_ASSERT(!stats_excluded.empty()&&!stats_included.empty() && stats_excluded.size()+stats_included.size() == stats.size());

    int32 num_reduced;
    EventMap *clustered_map = ClusterEventMap(*table_map, stats_included, 0.1, &num_reduced);

    std::cout << "TestCluster*(): num_reduced = "<<num_reduced<<", expected [without exclusion]: "<<cur_value<<" - "<<num_clust<<" = "<<(cur_value-num_clust)<<'\n';

    // Make sure stats we excluded are not renumbered.
    for (size_t i = 0;i < stats_excluded.size();i++) {
      const EventType &evec = stats_excluded[i].first;
      EventAnswerType ans;  table_map->Map(evec, &ans);
      EventAnswerType  ans2; clustered_map->Map(evec, &ans2);
      KALDI_ASSERT(ans == ans2);
    }

    delete clustered_map;
    delete table_map;
    delete trivial_map;
    DeleteBuildTreeStats(&stats);
  }
}

TestClusterEventMapGetMappingAndRenumberEventMap()

void kaldi::TestClusterEventMapGetMappingAndRenumberEventMap

(

)

Definition at line 256 of file build-tree-utils-test.cc.

References ClusterEventMapGetMapping(), EventMap::Copy(), DeleteBuildTreeStats(), DeletePointers(), DoTableSplit(), rnnlm::i, rnnlm::j, KALDI_ASSERT, EventMap::MaxResult(), EventMap::MultiMap(), rnnlm::n, Rand(), RandUniform(), RenumberEventMap(), SortAndUniq(), and TrivialTree().

Referenced by main().

                                                        {
  EventKeyType key = 0;  // just one key.
  for (size_t iter = 0;iter < 1;iter++) {  // in loop anyway.
    BuildTreeStatsType stats;
    EventValueType cur_value = 0;
    int32 num_clust = 10;
    for (int32 i = 0;i < num_clust;i++) {  // this will correspond to the "cluster".
      size_t n = 1 + Rand() % 3;
      for (size_t j = 0;j < n;j++) {
        BaseFloat scalar = static_cast<BaseFloat>(i) + RandUniform()*0.001;
        EventType evec;
        evec.push_back(std::make_pair(key, cur_value++));
        stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(new ScalarClusterable(scalar))));
      }
    }

    int32 nleaves = 0;
    EventMap *trivial_map = TrivialTree(&nleaves);

    EventMap *table_map = DoTableSplit(*trivial_map, key, stats, &nleaves);
    KALDI_ASSERT(nleaves == cur_value);

    std::vector<EventMap*> mapping;
    int32 num_reduced = ClusterEventMapGetMapping(*table_map, stats, 0.1, &mapping);

    std::cout << "TestCluster(): num_reduced = "<<num_reduced<<", expected: "<<cur_value<<" - "<<num_clust<<" = "<<(cur_value-num_clust)<<'\n';
    KALDI_ASSERT(num_reduced == cur_value - num_clust);

    EventMap *clustered_map = table_map->Copy(mapping);

    EventAnswerType new_nleaves;
    EventMap *renumbered_map = RenumberEventMap(*clustered_map, &new_nleaves);
    KALDI_ASSERT(new_nleaves == num_clust);

    std::vector<EventAnswerType> orig_answers, clustered_answers, renumbered_answers;

    EventType empty_vec;
    table_map->MultiMap(empty_vec, &orig_answers);
    clustered_map->MultiMap(empty_vec, &clustered_answers);
    renumbered_map->MultiMap(empty_vec, &renumbered_answers);

    SortAndUniq(&orig_answers);
    SortAndUniq(&clustered_answers);
    SortAndUniq(&renumbered_answers);
    KALDI_ASSERT(orig_answers.size() == (size_t) cur_value);
    KALDI_ASSERT(clustered_answers.size() == (size_t) num_clust);
    KALDI_ASSERT(renumbered_answers.size() == (size_t) num_clust);
    KALDI_ASSERT(renumbered_map->MaxResult()+1 == num_clust);

    DeletePointers(&mapping);
    delete renumbered_map;
    delete clustered_map;
    delete table_map;
    delete trivial_map;
    DeleteBuildTreeStats(&stats);
  }
}

TestClusterEventMapGetMappingAndRenumberEventMap2()

void kaldi::TestClusterEventMapGetMappingAndRenumberEventMap2

(

)

Definition at line 315 of file build-tree-utils-test.cc.

References ClusterEventMapGetMapping(), EventMap::Copy(), DeleteBuildTreeStats(), DeletePointers(), DoTableSplit(), rnnlm::i, rnnlm::j, KALDI_ASSERT, EventMap::MultiMap(), rnnlm::n, Rand(), RandUniform(), RenumberEventMap(), SortAndUniq(), and TrivialTree().

Referenced by main().

                                                         {
  EventKeyType key = 0;  // just one key.
  for (size_t iter = 0;iter < 1;iter++) {  // in loop anyway.
    BuildTreeStatsType stats;
    BuildTreeStatsType stats_reduced;
    EventValueType cur_value = 0;
    int32 num_clust = 10;
    for (int32 i = 0;i < num_clust;i++) {  // this will correspond to the "cluster".
      size_t n = 1 + Rand() % 3;
      for (size_t j = 0;j < n;j++) {
        BaseFloat scalar = static_cast<BaseFloat>(i) + RandUniform()*0.001;
        EventType evec;
        evec.push_back(std::make_pair(key, cur_value++));
        stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(new ScalarClusterable(scalar))));
        if (Rand() % 10 < 5) stats_reduced.push_back(stats.back());
      }
    }

    int32 nleaves = 0;
    EventMap *trivial_map = TrivialTree(&nleaves);

    EventMap *table_map = DoTableSplit(*trivial_map, key, stats, &nleaves);
    KALDI_ASSERT(nleaves == cur_value);

    std::vector<EventMap*> mapping;
    int32 num_reduced = ClusterEventMapGetMapping(*table_map, stats_reduced, 0.1, &mapping);

    std::cout << "TestCluster(): num_reduced = "<<num_reduced<<", expected [ignoring gaps]: "<<cur_value<<" - "<<num_clust<<" = "<<(cur_value-num_clust)<<'\n';
    // KALDI_ASSERT(num_reduced == cur_value - num_clust);

    EventMap *clustered_map = table_map->Copy(mapping);

    EventAnswerType new_nleaves;
    EventMap *renumbered_map = RenumberEventMap(*clustered_map, &new_nleaves);
    // KALDI_ASSERT(new_nleaves == num_clust);

    std::vector<EventAnswerType> orig_answers, clustered_answers, renumbered_answers;

    EventType empty_vec;
    table_map->MultiMap(empty_vec, &orig_answers);
    clustered_map->MultiMap(empty_vec, &clustered_answers);
    renumbered_map->MultiMap(empty_vec, &renumbered_answers);

    SortAndUniq(&orig_answers);
    SortAndUniq(&clustered_answers);
    SortAndUniq(&renumbered_answers);
    // KALDI_ASSERT(orig_answers.size() == (size_t) cur_value);
    // KALDI_ASSERT(clustered_answers.size() == (size_t) num_clust);
    // KALDI_ASSERT(renumbered_answers.size() == (size_t) num_clust);
    // KALDI_ASSERT(renumbered_map->MaxResult()+1 == num_clust);

    DeletePointers(&mapping);
    delete renumbered_map;
    delete clustered_map;
    delete table_map;
    delete trivial_map;
    DeleteBuildTreeStats(&stats);
  }
}

TestClusterEventMapRestricted()

void kaldi::TestClusterEventMapRestricted

(

)

Definition at line 437 of file build-tree-utils-test.cc.

References ClusterEventMap(), ClusterEventMapRestrictedByKeys(), ClusterEventMapRestrictedByMap(), CopySetToVector(), DeleteBuildTreeStats(), DoTableSplitMultiple(), rnnlm::i, Questions::InitRand(), rnnlm::j, KALDI_ASSERT, kAllKeysInsistIdentical, Rand(), RandGauss(), RandUniform(), SplitDecisionTree(), and TrivialTree().

Referenced by main().

                                     {

  // TestClusterEventMapRestricted() tests that ClusterEventMapRestricted()
  // does not combine leaves that we were trying to keep separate.

  bool test_by_key = (Rand()%2 == 0);

  int32 num_keys = 1 + Rand() % 4;
  std::vector<EventKeyType> keys;

  {  // randomly choose keys.  Will always define all of them.
    std::set<EventKeyType> keys_set;
    while (keys_set.size() < (size_t)num_keys)
      keys_set.insert(  (Rand() % (num_keys + 10)) - 3 );
    CopySetToVector(keys_set, &keys);
  }


  BuildTreeStatsType stats;

  int32 n_stats = 1 + (Rand() % 10);
  n_stats *= n_stats;  // up to 81 stats.

  for (size_t i = 0; i < (size_t)n_stats; i++) {
    EventType evec;

    for (size_t j = 0; j < keys.size(); j++) {
      EventValueType val = Rand() % 100;
      evec.push_back(std::make_pair(keys[j], val));
    }
    stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(new ScalarClusterable(RandGauss()))));
  }

  std::vector<EventKeyType> special_keys;
  for (size_t i = 0; i < keys.size(); i++)
    if (RandUniform() < 0.5) special_keys.push_back(keys[i]);


  int32 nleaves = 0;
  EventMap *trivial_map = TrivialTree(&nleaves);


  // We do a complete split on these keys.
  EventMap *table_split_map = DoTableSplitMultiple(*trivial_map, special_keys,
                                                   stats, &nleaves);
  int32 nleaves_after_table_split = nleaves;
  std::cout << "TestClusterEventMapRestricted: after splitting on "<<special_keys.size()<<" keys, nleaves = " <<nleaves<<'\n';
  // We now do decision tree split.

  Questions qo;  // all default.
  int32 num_quest = Rand() % 10, num_iters = rand () % 5;
  qo.InitRand(stats, num_quest, num_iters, kAllKeysInsistIdentical);
  float thresh = 0.001;
  int32 max_leaves = 50;
  BaseFloat smallest_split = 0.0;
  BaseFloat impr;
  EventMap *split_tree = SplitDecisionTree(*table_split_map, stats, qo, thresh, max_leaves,
                                           &nleaves, &impr, &smallest_split);
  KALDI_ASSERT((nleaves <= max_leaves || nleaves == nleaves_after_table_split) && smallest_split >= thresh);

  std::cout << "TestClusterEventMapRestricted: after building decision tree, " <<nleaves<<'\n';

  thresh = 1000;  // will ensure everything is combined.
  {
    int32 num_removed;
    EventMap *map_clustered = ClusterEventMap(*split_tree, stats,
                                              thresh, &num_removed);
    std::cout << "ClusterEventMap: num_removed = "<<num_removed;
    KALDI_ASSERT(num_removed == nleaves - 1);
    delete map_clustered;
  }

  {
    int32 num_removed;

    EventMap *map_clustered = NULL;
    if (test_by_key)
      map_clustered = ClusterEventMapRestrictedByKeys(*split_tree, stats,
                                                      thresh, special_keys,
                                                      &num_removed);
    else
      map_clustered = ClusterEventMapRestrictedByMap(*split_tree, stats,
                                                     thresh, *table_split_map,
                                                     &num_removed);

    std::cout << "ClusterEventMapRestricted: num_removed = "<<num_removed;
    // should take it back to status after table split.
    KALDI_ASSERT(num_removed == nleaves - nleaves_after_table_split);
    delete map_clustered;
  }

  delete split_tree;
  delete trivial_map;
  delete table_split_map;
  DeleteBuildTreeStats(&stats);
}

TestClusterKMeans()

static void kaldi::TestClusterKMeans ( )

static

Definition at line 329 of file cluster-utils-test.cc.

References ClusterKMeans(), DeletePointers(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, rnnlm::n, Rand(), RandUniform(), and SumClusterableObjf().

Referenced by main().

                                {
  size_t n_points_tot = 0, n_wrong_tot = 0;
  for (size_t n = 0;n < 3;n++) {
    // Test it by creating a random clustering and verifying that it does not make it worse, and
    // if done with the optimal parameters, makes it optimal.
    size_t n_clust = Rand() % 10;
    std::vector<Clusterable*> points;
    std::vector<int32> assignments_ref;
    for (size_t j = 0;j < n_clust;j++) {
      size_t n_points = 1 + Rand() % 5;
      BaseFloat clust_center  = (BaseFloat)j;
      for (size_t k = 0;k < n_points;k++) {
        points.push_back(new ScalarClusterable(clust_center + RandUniform()*0.01));
        assignments_ref.push_back(j);
      }
    }
    std::vector<Clusterable*> clusters;
    std::vector<int32> assignments;
    ClusterKMeansOptions kcfg;

    BaseFloat ans = ClusterKMeans(points, n_clust, &clusters, &assignments, kcfg);

    if (n < 3) ClusterKMeans(points, n_clust, NULL, NULL, kcfg);  // make sure no crash.

    BaseFloat clust_objf = SumClusterableObjf(clusters);

    KALDI_LOG << "TestClusterKmeans: objf after clustering is: "<<clust_objf<<", impr is: "<<ans<<'\n';

    if (clusters.size() != n_clust) {
      KALDI_LOG << "Warning: unexpected number of clusters "<<clusters.size()<<" vs. "<<n_clust<<"";
    }
    KALDI_ASSERT(assignments.size() == points.size());

    if (clust_objf < -1.0 * points.size()) {  // a bit high...
      KALDI_LOG << "Warning: ClusterKMeans did not work quite as well as expected";
    }

    int32 num_wrong = 0;
    for (size_t i = 0;i < points.size();i++) {
      size_t j = Rand() % points.size();
      if (assignments_ref[i] == assignments_ref[j]) {
        if (assignments[i] != assignments[j]) num_wrong++;
      } else
        if (assignments[i] == assignments[j]) num_wrong++;
    }
    KALDI_LOG << "num_wrong = "<<num_wrong<<'\n';

    n_points_tot += points.size();
    n_wrong_tot += num_wrong;

    DeletePointers(&clusters);
    DeletePointers(&points);
  }
  if (n_wrong_tot*4 > n_points_tot) {
    KALDI_LOG << "Got too many wrong in k-means test [may not be fatal, but check it out.";
    KALDI_ASSERT(0);
  }
}

TestClusterKMeansVector()

static void kaldi::TestClusterKMeansVector ( )

static

Definition at line 388 of file cluster-utils-test.cc.

References VectorBase< Real >::AddVec(), ClusterKMeans(), DeletePointers(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, rnnlm::n, ClusterKMeansOptions::num_tries, Rand(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), and SumClusterableObjf().

Referenced by main().

                                      {
  size_t n_points_tot = 0, n_wrong_tot = 0;
  for (size_t n = 0; n < 3; n++) {
    std::vector<int32> assignments_ref;
    int32 dim = 5 + Rand() % 5;
    // Test it by creating a random clustering and verifying that it does not make it worse, and
    // if done with the optimal parameters, makes it optimal.
    size_t n_clust = Rand() % 10;
    std::vector<Clusterable*> points;
    for (size_t j = 0; j < n_clust; j++) {
      size_t n_points = 1 + Rand() % 5;

      Vector<BaseFloat> clust_center(dim);
      clust_center.SetRandn();
      for (size_t k = 0; k < n_points; k++) {
        Vector<BaseFloat> point(dim);
        point.SetRandn();
        point.Scale(0.01);
        point.AddVec(1.0, clust_center);
        BaseFloat weight = 0.5 + 0.432 * (Rand() % 5);
        points.push_back(new VectorClusterable(point, weight));
        assignments_ref.push_back(j);
      }
    }
    std::vector<Clusterable*> clusters;
    std::vector<int32> assignments;
    ClusterKMeansOptions kcfg;
    kcfg.num_tries = 5;

    BaseFloat ans = ClusterKMeans(points, n_clust, &clusters, &assignments, kcfg);

    if (n < 3) ClusterKMeans(points, n_clust, NULL, NULL, kcfg);  // make sure no crash.

    BaseFloat clust_objf = SumClusterableObjf(clusters);

    KALDI_LOG << "TestClusterKmeans: objf after clustering is: "<<clust_objf<<", impr is: "<<ans<<'\n';

    if (clusters.size() != n_clust) {
      KALDI_LOG << "Warning: unexpected number of clusters "<<clusters.size()<<" vs. "<<n_clust<<"";
    }
    KALDI_ASSERT(assignments.size() == points.size());

    if (clust_objf < -1.0 * points.size()) {  // a bit high...
      KALDI_LOG << "Warning: ClusterKMeans did not work quite as well as expected";
    }


    int32 num_wrong = 0;
    for (size_t i = 0;i < points.size();i++) {
      size_t j = Rand() % points.size();
      if (assignments_ref[i] == assignments_ref[j]) {
        if (assignments[i] != assignments[j]) num_wrong++;
      } else
        if (assignments[i] == assignments[j]) num_wrong++;
    }

    n_points_tot += points.size();
    n_wrong_tot += num_wrong;

    KALDI_LOG << "num_wrong = " << num_wrong << ", num-points-tot = "
              << n_points_tot;

    DeletePointers(&clusters);
    DeletePointers(&points);
  }
  if (n_wrong_tot*4 > n_points_tot) {
    KALDI_LOG << "Got too many wrong in k-means test [may not be fatal, but check it out.";
    KALDI_ASSERT(0);
  }
}

TestClusterTopDown()

static void kaldi::TestClusterTopDown ( )

static

Definition at line 509 of file cluster-utils-test.cc.

References ClusterTopDown(), DeletePointers(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, rnnlm::n, Rand(), RandUniform(), SumClusterableObjf(), and TreeClusterOptions::thresh.

Referenced by main().

                                 {
  size_t n_points_tot = 0, n_wrong_tot = 0;
  for (size_t n = 0;n < 10;n++) {

    size_t n_clust = Rand() % 10;
    std::vector<Clusterable*> points;
    for (size_t j = 0;j < n_clust;j++) {
      size_t n_points = 1 + Rand() % 5;
      BaseFloat clust_center  = (BaseFloat)j;
      for (size_t k = 0;k < n_points;k++) points.push_back(new ScalarClusterable(clust_center + RandUniform()*0.01));
    }
    std::vector<Clusterable*> clusters;
    std::vector<int32> assignments;
    TreeClusterOptions tcfg;
    tcfg.thresh = 0.01;  // should prevent us splitting things in same  bucket.


    BaseFloat ans = ClusterTopDown(points, n_clust, &clusters, &assignments, tcfg);

    if (n < 3)  ClusterTopDown(points, n_clust, NULL, NULL, tcfg);  // make sure doesn't crash.

    BaseFloat clust_objf = SumClusterableObjf(clusters);

    KALDI_LOG << "ClusterTopDown: objf after clustering is: "<<clust_objf<<", impr is: "<<ans<<'\n';

    if (n<=2) // avoid generating too much output.
      KALDI_LOG << "Num nodes is "<<clusters.size()<<'\n';
    for (size_t i = 0;i < clusters.size();i++) {
      if (n<=2) {  // avoid generating too much output.
        KALDI_LOG << "Cluster "<<i<<": "<<((ScalarClusterable*)clusters[i])->Info()<<", objf is: "<<clusters[i]->Objf()<<"";
      }
    }
    KALDI_ASSERT(clusters.size() == n_clust);
    DeletePointers(&clusters);
    DeletePointers(&points);
  }
  if (n_wrong_tot*4 > n_points_tot) {
    KALDI_LOG << "Got too many wrong in k-means test [may not be fatal, but check it out.";
    KALDI_ASSERT(0);
  }
}

TestClusterUtils()

static void kaldi::TestClusterUtils ( )

static

Definition at line 25 of file cluster-utils-test.cc.

References Clusterable::Add(), Clusterable::Copy(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, Clusterable::Normalizer(), Clusterable::Objf(), Rand(), and RandGauss().

Referenced by main().

                               {  // just some very basic tests of the GaussClusterable class.
  BaseFloat varFloor = 0.1;
  size_t dim = 1 + Rand() % 10;
  size_t nGauss = 1 + Rand() % 10;
  std::vector< GaussClusterable * > v(nGauss);
  for (size_t i = 0;i < nGauss;i++) {
    v[i] = new GaussClusterable(dim, varFloor);
  }
  for (size_t i = 0;i < nGauss;i++) {
    size_t nPoints = 1 + Rand() % 30;
    for (size_t j = 0;j < nPoints;j++) {
      BaseFloat post = 0.5 *(Rand()%3);
      Vector<BaseFloat> vec(dim);
      for (size_t k = 0;k < dim;k++) vec(k) = RandGauss();
      v[i]->AddStats(vec, post);
    }
  }
  for (size_t i = 0;i+1 < nGauss;i++) {
    BaseFloat like_before = (v[i]->Objf() + v[i+1]->Objf()) / (v[i]->Normalizer() + v[i+1]->Normalizer());
    Clusterable *tmp = v[i]->Copy();
    tmp->Add( *(v[i+1]));
    BaseFloat like_after = tmp->Objf() / tmp->Normalizer();
    KALDI_LOG << "Like_before = " << like_before <<", after = "<<like_after <<" over "<<tmp->Normalizer()<<" frames.";
    if (tmp->Normalizer() > 0.1)
      KALDI_ASSERT(like_after <= like_before);  // should get worse after combining stats.
    delete tmp;
  }
  for (size_t i = 0;i < nGauss;i++)
    delete v[i];
}

TestClusterUtilsVector()

static void kaldi::TestClusterUtilsVector ( )

static

Definition at line 56 of file cluster-utils-test.cc.

References Clusterable::Add(), VectorClusterable::Add(), Clusterable::Copy(), kaldi::cu::Copy(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, Clusterable::Normalizer(), Clusterable::Objf(), VectorClusterable::Objf(), Rand(), RandUniform(), and VectorBase< Real >::SetRandn().

Referenced by main().

                                     {  // just some very basic tests of the VectorClusterable class.
  size_t dim = 2 + Rand() % 10;
  size_t num_vectors = 1 + Rand() % 10;
  std::vector<VectorClusterable*> v(num_vectors);
  for (size_t i = 0;i < num_vectors;i++) {
    BaseFloat weight = RandUniform();
    Vector<BaseFloat> vec(dim);
    vec.SetRandn();
    v[i] = new VectorClusterable(vec, weight);

    {
      VectorClusterable *tmp = static_cast<VectorClusterable*>(v[i]->Copy()),
          *tmp2 = static_cast<VectorClusterable*>(v[i]->Copy());
      tmp->Add(*tmp2);
      KALDI_ASSERT(fabs(tmp->Objf()) < 0.001);
      if (i > 0) {
        tmp->Add(*(v[i-1]));
        KALDI_ASSERT(tmp->Objf() < 0.0);
      }
      delete tmp;
      delete tmp2;
    }
  }

  for (size_t i = 0; i+1 < num_vectors; i++) {
    BaseFloat like_before = (v[i]->Objf() + v[i+1]->Objf()) / (v[i]->Normalizer() + v[i+1]->Normalizer());
    Clusterable *tmp = v[i]->Copy();
    tmp->Add( *(v[i+1]));
    BaseFloat like_after = tmp->Objf() / tmp->Normalizer();
    KALDI_LOG << "Like_before = " << like_before <<", after = "<<like_after <<" over "<<tmp->Normalizer()<<" frames.";
    if (tmp->Normalizer() > 0.1)
      KALDI_ASSERT(like_after <= like_before);  // should get worse after combining stats.
    delete tmp;
  }
  for (size_t i = 0;i < num_vectors;i++)
    delete v[i];
}

TestCompactLatticeTable()

void kaldi::TestCompactLatticeTable

(

bool

binary

)

Definition at line 41 of file kaldi-lattice-test.cc.

References TableWriter< Holder >::Close(), rnnlm::i, KALDI_ASSERT, RandCompactLattice(), RandomAccessTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                          {
  CompactLatticeWriter writer(binary ? "ark:tmpf" : "ark,t:tmpf");
  int N = 10;
  std::vector<CompactLattice*> lat_vec(N);
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    CompactLattice *fst = RandCompactLattice();
    lat_vec[i] = fst;
    writer.Write(key, *fst);
  }
  writer.Close();

  RandomAccessCompactLatticeReader reader("ark:tmpf");  
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    const CompactLattice &fst = reader.Value(key);
    KALDI_ASSERT(fst::Equal(fst, *(lat_vec[i])));
    delete lat_vec[i];
  }
}

TestCompactLatticeTableCross()

void kaldi::TestCompactLatticeTableCross

(

bool

binary

)

Definition at line 69 of file kaldi-lattice-test.cc.

References TableWriter< Holder >::Close(), fst::ConvertLattice(), rnnlm::i, KALDI_ASSERT, RandCompactLattice(), RandomAccessTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                               {
  CompactLatticeWriter writer(binary ? "ark:tmpf" : "ark,t:tmpf");
  int N = 10;
  std::vector<CompactLattice*> lat_vec(N);
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    CompactLattice *fst = RandCompactLattice();
    lat_vec[i] = fst;
    writer.Write(key, *fst);
  }
  writer.Close();

  RandomAccessLatticeReader reader("ark:tmpf");  
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    const Lattice &fst = reader.Value(key);
    CompactLattice fst2;
    ConvertLattice(fst, &fst2);
    KALDI_ASSERT(fst::Equal(fst2, *(lat_vec[i])));
    delete lat_vec[i];
  }
}

TestContainsNullPointers()

void kaldi::TestContainsNullPointers

(

)

Definition at line 190 of file stl-utils-test.cc.

References ContainsNullPointers(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                                {
  for (int p = 0; p < 100; p++) {
    std::vector<char*> vec;
    int sz = Rand() % 3;
    bool is_null = false;
    for (int i = 0;i < sz;i++) {
      vec.push_back(reinterpret_cast<char*>(static_cast<intptr_t>(Rand() % 2)));
      if (vec.back() == NULL)
        is_null = true;
    }
    KALDI_ASSERT(is_null == ContainsNullPointers(vec));
  }
}

TestContextDep()

void kaldi::TestContextDep

(

)

Definition at line 25 of file context-dep-test.cc.

References Clusterable::Add(), Clusterable::Copy(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Clusterable::Normalizer(), Clusterable::Objf(), Rand(), and RandGauss().

Referenced by main().

                      {
  BaseFloat varFloor = 0.1;
  size_t dim = 1 + Rand() % 20;
  size_t nGauss = 1 + Rand() % 10;
  std::vector< GaussClusterable * > v(nGauss);
  for (size_t i = 0;i < nGauss;i++) {
    v[i] = new GaussClusterable(dim, varFloor);
  }
  for (size_t i = 0;i < nGauss;i++) {
    size_t nPoints = 1 + Rand() % 30;
    for (size_t j = 0;j < nPoints;j++) {
      BaseFloat post = 0.5 *(Rand()%3);
      Vector<BaseFloat> vec(dim);
      for (size_t k = 0;k < dim;k++) vec(k) = RandGauss();
      v[i]->AddStats(vec, post);
    }
  }
  for (size_t i = 0;i+1 < nGauss;i++) {
    BaseFloat like_before = (v[i]->Objf() + v[i+1]->Objf()) / (v[i]->Normalizer() + v[i+1]->Normalizer());
    Clusterable *tmp = v[i]->Copy();
    tmp->Add(*(v[i+1]));
    BaseFloat like_after = tmp->Objf() / tmp->Normalizer();
    std::cout << "Like_before = " << like_before <<", after = "<<like_after <<" over "<<tmp->Normalizer()<<" frames.\n";
    if (tmp->Normalizer() > 0.1)
      KALDI_ASSERT(like_after <= like_before);  // should get worse after combining stats.
    delete tmp;
  }
  for (size_t i = 0;i < nGauss;i++)
    delete v[i];
}

TestConvertAlignment()

void kaldi::TestConvertAlignment

(

)

Definition at line 232 of file hmm-utils-test.cc.

References ConvertAlignment(), ContextDependencyInterface::Copy(), GenerateRandomAlignment(), GenRandContextDependencyLarge(), GenRandTopology(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, KALDI_WARN, MonophoneContextDependency(), RandInt(), SplitToPhones(), and TransitionModel::TransitionIdToPhone().

Referenced by main().

                            {
  bool old_reorder = (RandInt(0, 1) == 1),
      new_reorder = (RandInt(0, 1) == 1),
      new_tree = (RandInt(0, 1) == 1),
      new_topology = (RandInt(0, 1) == 1);
  if (!new_tree)
    new_topology = true;

  int32 subsample_factor = RandInt(1, 3);

  KALDI_LOG << " old-reorder = " << old_reorder
            << ", new-reorder = " << new_reorder
            << ", new-tree = " << new_tree
            << ", subsample-factor = " << subsample_factor;

  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_old,
      num_pdf_classes_new;

  ContextDependencyInterface *ctx_dep_old =
      GenRandContextDependencyLarge(phones, N, P,
                                    true, &num_pdf_classes_old),
      *ctx_dep_new;
  if (new_tree) {
    if (new_topology) {
      ctx_dep_new = GenRandContextDependencyLarge(phones, N, P,
                                                  true, &num_pdf_classes_new);
    } else {
      num_pdf_classes_new = num_pdf_classes_old;
      ctx_dep_new = MonophoneContextDependency(phones, num_pdf_classes_new);
    }
  } else {
    num_pdf_classes_new = num_pdf_classes_old;
    ctx_dep_new = ctx_dep_old->Copy();
  }


  HmmTopology topo_old = GenRandTopology(phones, num_pdf_classes_old),
      topo_new =  (new_topology ?
                   GenRandTopology(phones, num_pdf_classes_new) : topo_old);

  TransitionModel trans_model_old(*ctx_dep_old, topo_old),
      trans_model_new(*ctx_dep_new, topo_new);

  std::vector<int32> phone_sequence;
  int32 phone_sequence_length = RandInt(0, 20);
  for (int32 i = 0; i < phone_sequence_length; i++)
    phone_sequence.push_back(phones[RandInt(0, phones.size() - 1)]);
  std::vector<int32> old_alignment;
  GenerateRandomAlignment(*ctx_dep_old, trans_model_old,
                          old_reorder, phone_sequence,
                          &old_alignment);

  std::vector<int32> new_alignment;

  bool ans = ConvertAlignment(trans_model_old, trans_model_new, *ctx_dep_new,
                              old_alignment, subsample_factor, false,
                              new_reorder, NULL, &new_alignment);
  if(!ans) {
    KALDI_WARN << "Alignment conversion failed";
    // make sure it failed for a good reason.
    KALDI_ASSERT(new_topology || subsample_factor > 1);
  } else {
    std::vector<std::vector<int32> > old_split, new_split;
    bool b1 = SplitToPhones(trans_model_old, old_alignment, &old_split),
        b2 = SplitToPhones(trans_model_new, new_alignment, &new_split);
    KALDI_ASSERT(b1 && b2);
    KALDI_ASSERT(old_split.size() == new_split.size());
    for (size_t i = 0; i < new_split.size(); i++)
      KALDI_ASSERT(trans_model_old.TransitionIdToPhone(old_split[i].front()) ==
                   trans_model_new.TransitionIdToPhone(new_split[i].front()));
    if (!new_topology && subsample_factor == 1) {
      // we should be able to convert back and it'll be the same.
      std::vector<int32> old_alignment_copy;
      bool ans = ConvertAlignment(trans_model_new, trans_model_old, *ctx_dep_old,
                                  new_alignment, subsample_factor, false,
                                  old_reorder, NULL, &old_alignment_copy);
      KALDI_ASSERT(ans);
      KALDI_ASSERT(old_alignment_copy == old_alignment);
    }

  }
  delete ctx_dep_old;
  delete ctx_dep_new;
}

TestConvertPhnxToProns()

void kaldi::TestConvertPhnxToProns

(

)

Definition at line 28 of file hmm-utils-test.cc.

References ConvertPhnxToProns(), KALDI_ASSERT, and words.

Referenced by main().

                              {

  int32 word_start_sym = 1, word_end_sym = 2;
  { // empty test.
    std::vector<int32> phnx;
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans, ans_check;
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }

  { // test w/ one empty word.
    std::vector<int32> phnx; phnx.push_back(3);
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans;
    std::vector<std::vector<int32> > ans_check(1);
    ans_check[0].push_back(0);
    ans_check[0].push_back(3);
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }

  { // test w/ one empty word with two phones.
    std::vector<int32> phnx; phnx.push_back(3); phnx.push_back(4);
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans;
    std::vector<std::vector<int32> > ans_check(1);
    ans_check[0].push_back(0);
    ans_check[0].push_back(3);
    ans_check[0].push_back(4);
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }

  { // test w/ zero -> should fail.
    std::vector<int32> phnx; phnx.push_back(3); phnx.push_back(4);
    phnx.push_back(0);
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans;
    KALDI_ASSERT(!ConvertPhnxToProns(phnx, words, word_start_sym,
                                     word_end_sym, &ans));
  }

  { // test w/ unexpected word-end -> should fail.
    std::vector<int32> phnx; phnx.push_back(3); phnx.push_back(4);
    phnx.push_back(word_end_sym);
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans;
    KALDI_ASSERT(!ConvertPhnxToProns(phnx, words, word_start_sym,
                                     word_end_sym, &ans));

  }

  { // test w/ word-start but no word-end -> should fail.
    std::vector<int32> phnx; phnx.push_back(3); phnx.push_back(4);
    phnx.push_back(word_start_sym);
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans;
    KALDI_ASSERT(!ConvertPhnxToProns(phnx, words, word_start_sym,
                                     word_end_sym, &ans));

  }

  { // test w/ one empty word then one real word w/ zero phones.
    std::vector<int32> phnx; phnx.push_back(3); phnx.push_back(4);
    phnx.push_back(word_start_sym); phnx.push_back(word_end_sym);
    std::vector<int32> words; words.push_back(100);
    std::vector<std::vector<int32> > ans;
    std::vector<std::vector<int32> > ans_check(2);
    ans_check[0].push_back(0);
    ans_check[0].push_back(3);
    ans_check[0].push_back(4);
    ans_check[1].push_back(100);
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }

  { // test w/ one empty word then one real word w/ one phone..
    std::vector<int32> phnx; phnx.push_back(3); phnx.push_back(4);
    phnx.push_back(word_start_sym); phnx.push_back(5); phnx.push_back(word_end_sym);
    std::vector<int32> words; words.push_back(100);
    std::vector<std::vector<int32> > ans;
    std::vector<std::vector<int32> > ans_check(2);
    ans_check[0].push_back(0);
    ans_check[0].push_back(3);
    ans_check[0].push_back(4);
    ans_check[1].push_back(100);
    ans_check[1].push_back(5);
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }

  { // test w/ ONE real word w/ one phone..
    std::vector<int32> phnx;
    phnx.push_back(word_start_sym); phnx.push_back(5); phnx.push_back(word_end_sym);
    std::vector<int32> words; words.push_back(100);
    std::vector<std::vector<int32> > ans;
    std::vector<std::vector<int32> > ans_check(1);
    ans_check[0].push_back(100);
    ans_check[0].push_back(5);
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }

  { // test w/ ONE real word w/ one phone, but no
    // words supplied-- should fail.
    std::vector<int32> phnx;
    phnx.push_back(word_start_sym); phnx.push_back(5); phnx.push_back(word_end_sym);
    std::vector<int32> words;
    std::vector<std::vector<int32> > ans;
    KALDI_ASSERT(!ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans));
  }

  { // test w/ ONE real word w/ one phone, but two
    // words supplied-- should fail.
    std::vector<int32> phnx;
    phnx.push_back(word_start_sym); phnx.push_back(5); phnx.push_back(word_end_sym);
    std::vector<int32> words(2, 10);
    std::vector<std::vector<int32> > ans;
    KALDI_ASSERT(!ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans));
  }

  { // test w/ ONE real word w/ one phone, but word-id
    // is zero-- should fail.
    std::vector<int32> phnx;
    phnx.push_back(word_start_sym); phnx.push_back(5); phnx.push_back(word_end_sym);
    std::vector<int32> words(1, 0);
    std::vector<std::vector<int32> > ans;
    KALDI_ASSERT(!ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans));
  }

  { // test w/ ONE real word w/ two phones, then one
    // empty word...
    std::vector<int32> phnx;
    phnx.push_back(word_start_sym); phnx.push_back(5);
    phnx.push_back(7); phnx.push_back(word_end_sym);
    phnx.push_back(10);
    std::vector<int32> words; words.push_back(100);
    std::vector<std::vector<int32> > ans;
    std::vector<std::vector<int32> > ans_check(2);
    ans_check[0].push_back(100);
    ans_check[0].push_back(5);
    ans_check[0].push_back(7);
    ans_check[1].push_back(0);
    ans_check[1].push_back(10);
    KALDI_ASSERT(ConvertPhnxToProns(phnx, words, word_start_sym,
                                    word_end_sym, &ans)
                 && ans == ans_check);
  }
}

TestConvertStats()

void kaldi::TestConvertStats

(

)

Definition at line 72 of file build-tree-utils-test.cc.

References ConvertStats(), and KALDI_ASSERT.

Referenced by main().

                        {
  {
    BuildTreeStatsType stats;
    EventType evec;
    // this example is of ctx window (10, 11, 12), and pdf-class = 1.
    evec.push_back(std::pair<int32, int32>(-1, 1));
    evec.push_back(std::pair<int32, int32>(0, 10));
    evec.push_back(std::pair<int32, int32>(1, 11));
    evec.push_back(std::pair<int32, int32>(2, 12));
    stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(NULL)));
    int32 oldN = 3, oldP = 1, newN = 1, newP = 0;
    ConvertStats(oldN, oldP, newN, newP, &stats);
    EventType new_evec = stats[0].first;
    KALDI_ASSERT(new_evec.size() == 2);  // keys: -1, 0.
    KALDI_ASSERT(new_evec[0].first == -1 && new_evec[0].second == 1);
    KALDI_ASSERT(new_evec[1].first == 0 && new_evec[1].second == 11);
  }

  {  // as above, but convert to left bigram (N = 2, P = 1).
    BuildTreeStatsType stats;
    EventType evec;
    // this example is of ctx window (10, 11, 12), and pdf-class = 1.
    evec.push_back(std::pair<int32, int32>(-1, 1));
    evec.push_back(std::pair<int32, int32>(0, 10));
    evec.push_back(std::pair<int32, int32>(1, 11));
    evec.push_back(std::pair<int32, int32>(2, 12));
    stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(NULL)));
    int32 oldN = 3, oldP = 1, newN = 2, newP = 1;
    ConvertStats(oldN, oldP, newN, newP, &stats);
    EventType new_evec = stats[0].first;
    KALDI_ASSERT(new_evec.size() == 3);  // keys: -1, 0, 1.
    KALDI_ASSERT(new_evec[0].first == -1 && new_evec[0].second == 1);
    KALDI_ASSERT(new_evec[1].first == 0 && new_evec[1].second == 10);
    KALDI_ASSERT(new_evec[2].first == 1 && new_evec[2].second == 11);
  }

  {  // as above, but leave unchanged.
    BuildTreeStatsType stats;
    EventType evec;
    // this example is of ctx window (10, 11, 12), and pdf-class = 1.
    evec.push_back(std::pair<int32, int32>(-1, 1));
    evec.push_back(std::pair<int32, int32>(0, 10));
    evec.push_back(std::pair<int32, int32>(1, 11));
    evec.push_back(std::pair<int32, int32>(2, 12));
    stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(NULL)));
    int32 oldN = 3, oldP = 1, newN = 3, newP = 1;
    ConvertStats(oldN, oldP, newN, newP, &stats);
    EventType new_evec = stats[0].first;
    KALDI_ASSERT(new_evec == evec);
  }
}

TestConvertStringToInteger()

void kaldi::TestConvertStringToInteger

(

)

Definition at line 145 of file text-utils-test.cc.

References ConvertStringToInteger(), rnnlm::i, rnnlm::j, and KALDI_ASSERT.

Referenced by main().

                                  {
  int32 i;
  KALDI_ASSERT(ConvertStringToInteger("12345", &i) && i == 12345);
  KALDI_ASSERT(ConvertStringToInteger("-12345", &i) && i == -12345);
  char j;
  KALDI_ASSERT(!ConvertStringToInteger("-12345", &j));  // too big for char.

  KALDI_ASSERT(ConvertStringToInteger(" -12345 ", &i));  // whitespace accepted

  KALDI_ASSERT(!ConvertStringToInteger("a ", &i));  // non-integers rejected.

  KALDI_ASSERT(ConvertStringToInteger("0", &i) && i == 0);

  uint64 k;
  KALDI_ASSERT(ConvertStringToInteger("12345", &k) && k == 12345);
  KALDI_ASSERT(!ConvertStringToInteger("-12345", &k));  // unsigned,
                                                        // cannot convert.
}

TestConvertStringToReal()

void kaldi::TestConvertStringToReal

(

)

Definition at line 165 of file text-utils-test.cc.

References ConvertStringToReal(), rnnlm::d, and KALDI_ASSERT.

                               {
  Real d;
  KALDI_ASSERT(ConvertStringToReal("1", &d) && d == 1.0);
  KALDI_ASSERT(ConvertStringToReal("-1", &d) && d == -1.0);
  KALDI_ASSERT(ConvertStringToReal("-1", &d) && d == -1.0);
  KALDI_ASSERT(ConvertStringToReal(" -1 ", &d) && d == -1.0);
  KALDI_ASSERT(!ConvertStringToReal("-1 x", &d));
  KALDI_ASSERT(!ConvertStringToReal("-1f", &d));
  KALDI_ASSERT(ConvertStringToReal("12345.2", &d) && fabs(d-12345.2) < 1.0);
  KALDI_ASSERT(ConvertStringToReal("1.0e+08", &d) && fabs(d-1.0e+08) < 100.0);

  // it also works for inf or nan.
  KALDI_ASSERT(ConvertStringToReal("inf", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal(" inf", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("inf ", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal(" inf ", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("+inf", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("-inf", &d) && d < 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("Inf", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("INF", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("InF", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("infinity", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("-infinity", &d) && d < 0 && d - d != 0);
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE inf", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGEinf", &d));
  KALDI_ASSERT(!ConvertStringToReal("infGARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("inf_GARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("inf GARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE infinity", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGEinfinity", &d));
  KALDI_ASSERT(!ConvertStringToReal("infinityGARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("infinity_GARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("infinity GARBAGE", &d));
  KALDI_ASSERT(ConvertStringToReal("1.#INF", &d) && d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("-1.#INF", &d) && d < 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal("-1.#INF  ", &d) && d < 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal(" -1.#INF ", &d) && d < 0 && d - d != 0);
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE 1.#INF", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE1.#INF", &d));
  KALDI_ASSERT(!ConvertStringToReal("2.#INF", &d));
  KALDI_ASSERT(!ConvertStringToReal("-2.#INF", &d));
  KALDI_ASSERT(!ConvertStringToReal("1.#INFGARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("1.#INF_GARBAGE", &d));

  KALDI_ASSERT(ConvertStringToReal("nan", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("+nan", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("-nan", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("Nan", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("NAN", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("NaN", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal(" NaN", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("NaN ", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal(" NaN ", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("1.#QNAN", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("-1.#QNAN", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal("1.#QNAN  ", &d) && d != d);
  KALDI_ASSERT(ConvertStringToReal(" 1.#QNAN ", &d) && d != d);
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE nan", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGEnan", &d));
  KALDI_ASSERT(!ConvertStringToReal("nanGARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("nan_GARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("nan GARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE 1.#QNAN", &d));
  KALDI_ASSERT(!ConvertStringToReal("GARBAGE1.#QNAN", &d));
  KALDI_ASSERT(!ConvertStringToReal("2.#QNAN", &d));
  KALDI_ASSERT(!ConvertStringToReal("-2.#QNAN", &d));
  KALDI_ASSERT(!ConvertStringToReal("-1.#QNAN_GARBAGE", &d));
  KALDI_ASSERT(!ConvertStringToReal("-1.#QNANGARBAGE", &d));
}

TestCopyMapKeysToSet()

void kaldi::TestCopyMapKeysToSet

(

)

Definition at line 158 of file stl-utils-test.cc.

References CopyMapKeysToSet(), CopyMapKeysToVector(), CopyVectorToSet(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                            {
  for (int p = 0; p < 100; p++) {
    std::map<int, int> mp;
    int sz = Rand() % 20;
    for (int i = 0;i < sz;i++) mp[Rand() % 10] = Rand() % 20;
    std::vector<int> v;
    std::set<int> s;
    CopyMapKeysToVector(mp, &v);
    CopyMapKeysToSet(mp, &s);
    std::set<int> s2;
    CopyVectorToSet(v, &s2);
    KALDI_ASSERT(s == s2);
  }
}

TestCopyMapKeysToVector()

void kaldi::TestCopyMapKeysToVector

(

)

Definition at line 130 of file stl-utils-test.cc.

References CopyMapKeysToVector(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                               {
  for (int p = 0; p < 100; p++) {
    std::map<int, int> mp;
    int sz = Rand() % 20;
    for (int i = 0;i < sz;i++) mp[Rand() % 10] = Rand() % 20;
    std::vector<int> v;
    CopyMapKeysToVector(mp, &v);
    KALDI_ASSERT(mp.size() == v.size());
    for (size_t i = 0;i < v.size();i++) KALDI_ASSERT(mp.count(v[i]) == 1);
  }
}

TestCopyMapToVector()

void kaldi::TestCopyMapToVector

(

)

Definition at line 116 of file stl-utils-test.cc.

References CopyMapToVector(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                           {
  for (int p = 0; p < 100; p++) {
    std::map<int, int> mp;
    int sz = Rand() % 20;
    for (int i = 0;i < sz;i++) mp[Rand() % 10] = Rand() % 20;
    std::vector<std::pair<int, int> > v;
    CopyMapToVector(mp, &v);
    KALDI_ASSERT(mp.size() == v.size());
    for (size_t i = 0;i < v.size();i++)
      KALDI_ASSERT(mp[v[i].first] == v[i].second);
  }
}

TestCopyMapValuesToSet()

void kaldi::TestCopyMapValuesToSet

(

)

Definition at line 174 of file stl-utils-test.cc.

References CopyMapValuesToSet(), CopyMapValuesToVector(), CopyVectorToSet(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                              {
  for (int p = 0; p < 100; p++) {
    std::map<int, int> mp;
    int sz = Rand() % 20;
    for (int i = 0;i < sz;i++) mp[Rand() % 10] = Rand() % 20;
    std::vector<int> v;
    std::set<int> s;
    CopyMapValuesToVector(mp, &v);
    CopyMapValuesToSet(mp, &s);
    std::set<int> s2;
    CopyVectorToSet(v, &s2);
    KALDI_ASSERT(s == s2);
  }
}

TestCopyMapValuesToVector()

void kaldi::TestCopyMapValuesToVector

(

)

Definition at line 142 of file stl-utils-test.cc.

References CopyMapValuesToVector(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                                 {
  for (int p = 0; p < 100; p++) {
    std::map<int, int> mp;
    int sz = Rand() % 20;
    for (int i = 0;i < sz;i++) mp[Rand() % 10] = Rand() % 20;
    std::vector<int> v;
    CopyMapValuesToVector(mp, &v);
    KALDI_ASSERT(mp.size() == v.size());
    int i = 0;
    for (std::map<int, int>::iterator iter = mp.begin(); iter != mp.end();
         iter++) {
      KALDI_ASSERT(v[i++] == iter->second);
    }
  }
}

TestCopySetToVector()

void kaldi::TestCopySetToVector

(

)

Definition at line 103 of file stl-utils-test.cc.

References CopySetToVector(), rnnlm::i, KALDI_ASSERT, and Rand().

Referenced by main().

                           {
  for (int p = 0; p < 100; p++) {
    std::set<int> st;
    int sz = Rand() % 20;
    for (int i = 0;i < sz;i++) st.insert(Rand() % 10);
    std::vector<int> v;
    CopySetToVector(st, &v);
    KALDI_ASSERT(st.size() == v.size());
    for (size_t i = 0;i < v.size();i++) KALDI_ASSERT(st.count(v[i]) != 0);
  }
}

TestCuFindRowMaxId()

static void kaldi::TestCuFindRowMaxId ( int32  dim )

static

Definition at line 368 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), CuArrayBase< T >::CopyToVec(), Timer::Elapsed(), CuMatrixBase< Real >::FindRowMaxId(), KALDI_ASSERT, KALDI_LOG, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), and MatrixBase< Real >::SetRandn().

                                          {

  int32 dimM = dim, dimN = dimM + Rand() % 5;

  Matrix<Real> Hi(dimM, dimN);
  Hi.SetRandn();

  CuMatrix<Real> Di(dimM, dimN);
  Di.CopyFromMat(Hi);

  std::vector<int32> Hmax(dimM);
  CuArray<int32> Dmax(dimN);

  BaseFloat time_in_secs = 0.025;
  int iter = 0;
  Timer tim;
  for (;tim.Elapsed() < time_in_secs; iter++)
    Di.FindRowMaxId(&Dmax);


  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::FindRowMaxId" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";


  // on cpu
  for(MatrixIndexT r=0; r<Hi.NumRows(); r++) {
    Real max=-1.0e+20; int32 idx=-1;
    for(MatrixIndexT c=0; c<Hi.NumCols(); c++) {
      if(Hi(r,c) > max) { idx=c; max=Hi(r,c); }
    }
    Hmax[r] = idx;
  }
  std::vector<int32> Hmax2(dimM);
  Dmax.CopyToVec(&Hmax2);

  KALDI_ASSERT(Hmax == Hmax2);
}

TestCuMatrixAddDiagVecMat()

void kaldi::TestCuMatrixAddDiagVecMat	(	int32	dim,
		MatrixTransposeType	trans
	)

Definition at line 265 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::AddDiagVecMat(), Timer::Elapsed(), KALDI_LOG, kTrans, and CuVectorBase< Real >::SetRandn().

                                                                                             {
  BaseFloat time_in_secs = 0.015;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  CuVector<Real> v(dim);
  M.SetRandn();
  v.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++)
    N.AddDiagVecMat(1.0, v, M, trans, 0.0);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddDiagVecMat" << NameOf<Real>()
            << (trans == kTrans ? "[trans]" : "[no-trans]")
            << ", for dim = " << dim << ", speed was "
            << gflops << " gigaflops.";
}

TestCuMatrixAddMat()

void kaldi::TestCuMatrixAddMat	(	int32	dim,
		int32	num_row_blocks,
		int32	num_col_blocks
	)

Definition at line 169 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, rnnlm::j, KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                      {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> A(dim, dim), B(dim * num_row_blocks, dim * num_col_blocks);
  A.SetRandn();
  B.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    for (int32 i = 0; i < num_row_blocks; i++) {
      for (int32 j = 0; j < num_col_blocks; j++) {
        A.AddMat(0.0, CuSubMatrix<Real>(B, i * dim, dim, j * dim, dim));
      }
    }
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * num_row_blocks * num_col_blocks * iter)
                     / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddMat" << NameOf<Real>() << ", for dim = "
            << dim << "numRowBlocks = "<< num_row_blocks << "numColBlocks = "
            << num_col_blocks << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixAddMatBlocks()

void kaldi::TestCuMatrixAddMatBlocks	(	int32	dim,
		int32	num_row_blocks,
		int32	num_col_blocks
	)

Definition at line 192 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                            {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> A(dim, dim), B(dim * num_row_blocks, dim * num_col_blocks);
  A.SetRandn();
  B.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    A.AddMatBlocks(0.0, B);
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * num_row_blocks * num_col_blocks * iter)
                     / (tim.Elapsed() * 1.0e+09);
   KALDI_LOG << "For CuMatrix::AddMatBlocks" << NameOf<Real>() << ", for dim = "
             << dim << ", numRowBlocks = "<< num_row_blocks << ", numColBlocks = "
             << num_col_blocks << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixAddRowRanges()

void kaldi::TestCuMatrixAddRowRanges

(

int32

dim

)

Definition at line 958 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                 {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<Int32Pair> indexes(dim);
  for (int32 i = 0; i < dim; i++) {
    indexes[i].first = i;
    indexes[i].second = i + 1;
  }
  CuArray<Int32Pair> indexes_cuda(indexes);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.AddRowRanges(N, indexes_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddRowRanges" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixAddRows1()

void kaldi::TestCuMatrixAddRows1

(

int32

dim

)

Definition at line 886 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                             {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<int32> reorder(dim);
  for (int32 i = 0; i < dim; i++) {
    reorder[i] = i;
  }
  CuArray<int32> reorder_cuda(reorder);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.AddRows(0.5, N, reorder_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddRows" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixAddRows2()

void kaldi::TestCuMatrixAddRows2

(

int32

dim

)

Definition at line 910 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                                             {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<const Real*> reorder_src(dim, NULL);
  for (int32 i = 0; i < dim; i++) {
    reorder_src[i] = N.RowData(i);
  }
  CuArray<const Real*> reorder_src_cuda(reorder_src);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.AddRows(0.5, reorder_src_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddRows" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixAddToRows()

void kaldi::TestCuMatrixAddToRows

(

int32

dim

)

Definition at line 934 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                                              {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<Real*> reorder_dst(dim, NULL);
  for (int32 i = 0; i < dim; i++) {
    reorder_dst[i] = N.RowData(i);
  }
  CuArray<Real*> reorder_dst_cuda(reorder_dst);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.AddToRows(0.5, reorder_dst_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddToRows" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCholesky()

void kaldi::TestCuMatrixCholesky

(

int32

dim

)

Definition at line 652 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::AddToDiag(), CuMatrixBase< Real >::Cholesky(), Timer::Elapsed(), and KALDI_LOG.

                                                             {
  BaseFloat time_in_secs = 0.025;

  CuMatrix<Real> M(dim, dim);
  M.AddToDiag(100.0);
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++)
    M.Cholesky();

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::Cholesky" << NameOf<Real>()
            << ", for dim = " << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCompObjfAndDeriv()

static void kaldi::TestCuMatrixCompObjfAndDeriv ( int32  dim )

static

Definition at line 308 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::Add(), CuMatrixBase< Real >::ApplyFloor(), CuMatrixBase< Real >::ApplyLog(), ApproxEqual(), CuMatrix< Real >::CompObjfAndDeriv(), Timer::Elapsed(), rnnlm::i, CuMatrixBase< Real >::InvertElements(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kTrans, Rand(), RandUniform(), CuMatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::SetZero(), and TraceMatMat().

                                                    {
  BaseFloat time_in_secs = 0.025;
  // Previously tested for larger dims, but test was slow.

  int32 n_r = dim, n_c = dim + Rand() % 5;

  CuMatrix<Real> A(n_r, n_c), B(n_r, n_c);
  B.SetRandn();
  B.Add(1.0);
  B.ApplyFloor(1.0e-10);

  std::vector<MatrixElement<Real> > labels;
  for(int i = 0; i < n_r; i++) {
    for(int j = 0; j < n_c; j++) {
      // have approximately one weight per row of the matrix.
      if (Rand() % n_c == 0) {
        A(i, j) = RandUniform();
        MatrixElement<Real> t = {i, j, A(i, j)};
        labels.push_back(t);
      }
    }
  }
  CuMatrix<Real> C(n_r, n_c);

  int iter = 0;
  Timer tim;
  Real a = 0.0, b = 0.0;
  for (;tim.Elapsed() < time_in_secs; iter++)
    C.CompObjfAndDeriv(labels, B, &a, &b);

  BaseFloat gflops = (n_r * n_c * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CompObjfAndDeriv" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";


  // do it one more time for correctness test.
  C.SetZero();
  C.CompObjfAndDeriv(labels, B, &a, &b);

  KALDI_ASSERT(ApproxEqual(b, A.Sum()));

  // repeat the real test.
  Real sum2;  // sum(i, j) A(i, j) log(B(i, j));
  {
    CuMatrix<Real> Bcopy(B);
    Bcopy.ApplyLog();
    sum2 = TraceMatMat(Bcopy, A, kTrans);
  }

  KALDI_ASSERT(ApproxEqual(a, sum2));

  B.InvertElements();
  A.MulElements(B);  // each element of A is now A(i, j) / B(i, j);
  KALDI_ASSERT(ApproxEqual(A, C));


}

TestCuMatrixCopyFromSp()

void kaldi::TestCuMatrixCopyFromSp

(

int32

dim

)

Definition at line 712 of file cu-matrix-speed-test.cc.

References AssertEqual(), CuMatrixBase< Real >::CopyFromSp(), Timer::Elapsed(), KALDI_LOG, and CuPackedMatrix< Real >::SetRandn().

                                                               {
  BaseFloat time_in_secs = 0.025;
  CuSpMatrix<Real> S(dim);
  S.SetRandn();
  CuMatrix<Real> M(dim, dim);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyFromSp(S);
  }
  SpMatrix<Real> S_cpu(S);
  Matrix<Real> M_cpu(S_cpu);
  Matrix<Real> M2_cpu(M);
  AssertEqual(M_cpu, M2_cpu);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyFromSp" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCopyFromTp()

void kaldi::TestCuMatrixCopyFromTp	(	int32	dim,
		MatrixTransposeType	trans
	)

Definition at line 688 of file cu-matrix-speed-test.cc.

References AssertEqual(), CuMatrixBase< Real >::CopyFromTp(), Timer::Elapsed(), KALDI_LOG, kNoTrans, and CuPackedMatrix< Real >::SetRandn().

                                                                                          {
  BaseFloat time_in_secs = 0.025;
  CuTpMatrix<Real> T(dim);
  T.SetRandn();
  CuMatrix<Real> M(dim, dim);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyFromTp(T, trans);
  }
  TpMatrix<Real> T_cpu(T);
  Matrix<Real> M_cpu(T_cpu, trans);
  Matrix<Real> M2_cpu(M);
  AssertEqual(M_cpu, M2_cpu);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyFromTp" << (trans == kNoTrans ? "[NoTrans]":"[Trans]")
            << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCopyLowerToUpper()

void kaldi::TestCuMatrixCopyLowerToUpper

(

int32

dim

)

Definition at line 670 of file cu-matrix-speed-test.cc.

References AssertEqual(), CuMatrixBase< Real >::CopyLowerToUpper(), Timer::Elapsed(), KALDI_LOG, kTrans, and CuMatrixBase< Real >::SetRandn().

                                                                     {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyLowerToUpper();
  }
  CuMatrix<Real> M2(M, kTrans);
  AssertEqual(M, M2);
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyLowerToUpper" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCopyRows1()

void kaldi::TestCuMatrixCopyRows1

(

int32

dim

)

Definition at line 814 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                              {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<int32> reorder(dim);
  for (int32 i = 0; i < dim; i++) {
    reorder[i] = i;
  }
  CuArray<int32> reorder_cuda(reorder);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyRows(N, reorder_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyRows" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCopyRows2()

void kaldi::TestCuMatrixCopyRows2

(

int32

dim

)

Definition at line 838 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                                              {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<const Real*> reorder_src(dim, NULL);
  for (int32 i = 0; i < dim; i++) {
    reorder_src[i] = N.RowData(i);
  }
  CuArray<const Real*> reorder_src_cuda(reorder_src);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyRows(reorder_src_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyRows" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCopyToRows()

void kaldi::TestCuMatrixCopyToRows

(

int32

dim

)

Definition at line 862 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                                               {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();

  std::vector<Real*> reorder_dst(dim, NULL);
  for (int32 i = 0; i < dim; i++) {
    reorder_dst[i] = N.RowData(i);
  }
  CuArray<Real*> reorder_dst_cuda(reorder_dst);

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyToRows(reorder_dst_cuda);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyToRows" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixCopyUpperToLower()

void kaldi::TestCuMatrixCopyUpperToLower

(

int32

dim

)

Definition at line 736 of file cu-matrix-speed-test.cc.

References AssertEqual(), CuMatrixBase< Real >::CopyUpperToLower(), Timer::Elapsed(), KALDI_LOG, kTrans, kUndefined, CuMatrixBase< Real >::SetRandn(), and TestCuMatrixResize().

                                                                     {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.CopyUpperToLower();
  }
  CuMatrix<Real> M2(M, kTrans);
  AssertEqual(M, M2);
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::CopyUpperToLower" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixDiffGroupPnorm()

void kaldi::TestCuMatrixDiffGroupPnorm

(

int32

dim

)

Definition at line 553 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), CuMatrixBase< Real >::GroupPnorm(), KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                   {
  BaseFloat time_in_secs = 0.025;
  int32 group_size = 8;
  CuMatrix<Real> iv(dim, dim), ov(dim, dim / group_size);
  CuMatrix<Real> id(dim, dim), od(dim, dim / group_size);
  iv.SetRandn();
  od.SetRandn();
  ov.GroupPnorm(iv, 2.0);
  Timer tim;
  int32 iter = 0;

  for (; tim.Elapsed() < time_in_secs; iter++)
    id.DiffGroupPnorm(iv, ov, od, 2.0);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::DiffGroupPnorm" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixDiffLogSoftmax()

void kaldi::TestCuMatrixDiffLogSoftmax

(

int32

dim

)

Definition at line 482 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                   {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim), L(dim, dim);
  M.SetRandn();
  N.SetRandn();
  L.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    N.DiffLogSoftmaxPerRow(M, L);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::DiffLogSoftmaxPerRow" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixDiffSoftmax()

void kaldi::TestCuMatrixDiffSoftmax

(

int32

dim

)

Definition at line 464 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim), L(dim, dim);
  M.SetRandn();
  N.SetRandn();
  L.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    N.DiffSoftmaxPerRow(M, L);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::DiffSoftmaxPerRow" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixDivRowsVec()

void kaldi::TestCuMatrixDivRowsVec

(

int32

dim

)

Definition at line 97 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::DivRowsVec(), Timer::Elapsed(), KALDI_LOG, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                               {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  CuVector<Real> V(dim);
  M.SetRandn();
  V.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.DivRowsVec(V);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::DivRowsVec" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixGroupMax()

void kaldi::TestCuMatrixGroupMax

(

int32

dim

)

Definition at line 573 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), CuMatrixBase< Real >::GroupMax(), and KALDI_LOG.

                                                             {
  BaseFloat time_in_secs = 0.025;
  int32 group_size = 4;
  CuMatrix<Real> M(dim, dim), N(dim, dim / group_size);
  M.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++)
    N.GroupMax(M);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::GroupMax" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixGroupMaxAllGroupSizes()

void kaldi::TestCuMatrixGroupMaxAllGroupSizes

(

int32

dim

)

Definition at line 589 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), CuMatrixBase< Real >::GroupMax(), KALDI_LOG, kUndefined, and CuMatrixBase< Real >::SetRandn().

                                                                          {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs;) {
    for (int group_size = 1; group_size <= dim; group_size++) {
      if (dim % group_size == 0) {
        CuMatrix<Real> N(dim, dim / group_size, kUndefined);
        N.GroupMax(M);
        iter++;
      }
    }
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::GroupMax (all group sizes)" << NameOf<Real>()
            << ", for dim = " << dim << ", speed was " << gflops
            << " gigaflops.";
}

TestCuMatrixGroupMaxDeriv()

void kaldi::TestCuMatrixGroupMaxDeriv

(

int32

dim

)

Definition at line 612 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), CuMatrixBase< Real >::GroupMaxDeriv(), and KALDI_LOG.

                                                                  {
  BaseFloat time_in_secs = 0.025;
  int32 group_size = 4;
  CuMatrix<Real> M(dim, dim), N(dim, dim / group_size), O(dim, dim);
  M.SetRandn();
  N.GroupMax(M);
  Timer tim;
  int32 iter = 0;

  for (;tim.Elapsed() < time_in_secs; iter++)
    O.GroupMaxDeriv(M, N);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::GroupMaxDeriv" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixGroupPnorm()

void kaldi::TestCuMatrixGroupPnorm

(

int32

dim

)

Definition at line 536 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), CuMatrixBase< Real >::GroupPnorm(), and KALDI_LOG.

                                                               {
  BaseFloat time_in_secs = 0.025;
  int32 group_size = 4;
  CuMatrix<Real> M(dim, dim), N(dim, dim / group_size);
  M.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++)
    N.GroupPnorm(M, 2.0);

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::GroupPnorm" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixHeaviside()

void kaldi::TestCuMatrixHeaviside

(

int32

dim

)

Definition at line 427 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::ApplyHeaviside(), Timer::Elapsed(), KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                              {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    N.ApplyHeaviside();
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::Heaviside" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixLogSoftmax()

void kaldi::TestCuMatrixLogSoftmax

(

int32

dim

)

Definition at line 518 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::LogSoftMaxPerRow(), and CuMatrixBase< Real >::SetRandn().

                                                               {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    N.LogSoftMaxPerRow(M);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::LogSoftmax" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixLookup()

void kaldi::TestCuMatrixLookup

(

int32

dim

)

Definition at line 782 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), Int32Pair::first, rnnlm::j, KALDI_LOG, CuMatrixBase< Real >::Lookup(), Rand(), Int32Pair::second, and CuMatrixBase< Real >::SetRandn().

                                   {
  BaseFloat time_in_secs = 0.025;
  int32 dimM = dim, dimN = dim;
  CuMatrix<Real> H(dimM, dimN);
  H.SetRandn();
  std::vector<Int32Pair> indices;
  std::vector<Real> reference;
  std::vector<Real> output;
  // Generates the indices and the reference.
  int32 num_index = dim * dim;
  output.resize(num_index);
  for (int32 j = 0; j < num_index; j++) {
    MatrixIndexT r = Rand() % dimM;
    MatrixIndexT c = Rand() % dimN;

    Int32Pair tmp_pair;
    tmp_pair.first = r;
    tmp_pair.second = c;
    indices.push_back(tmp_pair);
    reference.push_back(H(r, c));
  }
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed()< time_in_secs; iter++)
    H.Lookup(indices, &(output[0]));

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::Lookup" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixMatMat()

void kaldi::TestCuMatrixMatMat

(

int32

dim

)

Definition at line 212 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::AddMatMat(), Timer::Elapsed(), KALDI_LOG, and kNoTrans.

                                                           {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim), O(dim, dim);
  M.SetRandn();
  N.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    O.AddMatMat(1.0, M, kNoTrans, N, kNoTrans, 0.0);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddMatMat" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixMatMatBatched()

void kaldi::TestCuMatrixMatMatBatched	(	int32	dim,
		int32	batchCount
	)

Definition at line 229 of file cu-matrix-speed-test.cc.

References AddMatMatBatched(), Timer::Elapsed(), rnnlm::i, KALDI_LOG, kNoTrans, and CuMatrixBase< Real >::SetRandn().

                                                                                    {
  std::vector<CuMatrix<Real>* > a(batchCount), b(batchCount), c(batchCount);
  std::vector<CuSubMatrix<Real>* > A, B, C;

  for (int32 i = 0; i < batchCount; i++) {
    // first create a Matrix intance and then creat a SubMatrix instance from that
    a[i] = new CuMatrix<Real>(dim, dim);
    b[i] = new CuMatrix<Real>(dim, dim);
    c[i] = new CuMatrix<Real>(dim, dim);
    a[i]->SetRandn();
    b[i]->SetRandn();
    A.push_back(new CuSubMatrix<Real>(*(a[i]), 0, a[i]->NumRows(), 0,
                                      a[i]->NumCols()));
    B.push_back(new CuSubMatrix<Real>(*(b[i]), 0, b[i]->NumRows(), 0,
                                      b[i]->NumCols()));
    C.push_back(new CuSubMatrix<Real>(*(c[i]), 0, c[i]->NumRows(), 0,
                                      c[i]->NumCols()));
  }
  BaseFloat time_in_secs = 0.025;
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    AddMatMatBatched(static_cast<Real>(1.0), C, A, kNoTrans, B, kNoTrans,
                     static_cast<Real>(0.0));
  }
  for (int32 i = 0; i< batchCount; i++) {
    delete a[i]; delete b[i]; delete c[i];
    delete A[i]; delete B[i]; delete C[i];
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * fdim * iter * batchCount) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::AddMatMatBatched" << NameOf<Real>() << ", for dim = " << dim
            << ", batchSize = " << batchCount << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixMax()

void kaldi::TestCuMatrixMax

(

int32

dim

)

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

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::Max(), and CuMatrixBase< Real >::SetRandn().

                                                        {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  Real result = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    result = M.Max();
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::TestCuMatrixMax" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops, result = " << result;
}

TestCuMatrixMin()

void kaldi::TestCuMatrixMin

(

int32

dim

)

Definition at line 80 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::Min(), and CuMatrixBase< Real >::SetRandn().

                                                        {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  Real result = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    result = M.Min();
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::TestCuMatrixMin" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops, result = " << result;
}

TestCuMatrixMulRowsGroupMat()

void kaldi::TestCuMatrixMulRowsGroupMat

(

int32

dim

)

Definition at line 445 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, and CuMatrixBase< Real >::SetRandn().

                                                                    {
  BaseFloat time_in_secs = 0.025;

  int32 group_size = 5;
  CuMatrix<Real> M(dim, dim * group_size), N(dim, dim);
  M.SetRandn();
  N.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    M.MulRowsGroupMat(N);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * group_size * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::MulRowsGroupMat" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixResize()

void TestCuMatrixResize

(

int32

size_multiple

)

Definition at line 41 of file cu-device-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, kUndefined, and RandInt().

Referenced by TestCuMatrixCopyUpperToLower().

                                                                     {
  int32 num_matrices = 256;
  BaseFloat time_in_secs = 0.2;

  std::vector<std::pair<int32, int32> > sizes(num_matrices);

  for (int32 i = 0; i < num_matrices; i++) {
    int32 num_rows = RandInt(1, 10);
    num_rows *= num_rows;
    num_rows *= size_multiple;
    int32 num_cols = RandInt(1, 10);
    num_cols *= num_cols;
    num_cols *= size_multiple;
    sizes[i].first = num_rows;
    sizes[i].second = num_rows;
  }

  std::vector<CuMatrix<BaseFloat> > matrices(num_matrices);

  Timer tim;
  size_t num_floats_processed = 0;
  for (;tim.Elapsed() < time_in_secs; ) {
    int32 matrix = RandInt(0, num_matrices - 1);
    if (matrices[matrix].NumRows() == 0) {
      int32 num_rows = sizes[matrix].first,
          num_cols = sizes[matrix].second;
      matrices[matrix].Resize(num_rows, num_cols, kUndefined);
      num_floats_processed += num_rows * num_cols;
    } else {
      matrices[matrix].Resize(0, 0);
    }
  }

  BaseFloat gflops = num_floats_processed / (tim.Elapsed() * 1.0e+09);

  KALDI_LOG << "For CuMatrix::Resize" << NameOf<Real>() << ", for size_multiple = "
            << size_multiple << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixSetZeroAboveDiag()

void kaldi::TestCuMatrixSetZeroAboveDiag

(

int32

dim

)

Definition at line 767 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetZeroAboveDiag().

                                                                     {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++)
    M.SetZeroAboveDiag();
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::SetZeroAboveDiag" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixSigmoid()

void kaldi::TestCuMatrixSigmoid

(

int32

dim

)

Definition at line 410 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::Sigmoid().

                                                            {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    N.Sigmoid(M);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::Sigmoid" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixSoftmax()

void kaldi::TestCuMatrixSoftmax

(

int32

dim

)

Definition at line 500 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SoftMaxPerRow().

                                                            {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim), N(dim, dim);
  M.SetRandn();
  N.SetRandn();
  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    N.SoftMaxPerRow(M);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::Softmax" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixSum()

void kaldi::TestCuMatrixSum

(

int32

dim

)

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

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::Sum().

                                                        {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  Real result = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    result = M.Sum();
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::TestCuMatrixSum" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops, result = " << result;
}

TestCuMatrixTraceMatMat()

void kaldi::TestCuMatrixTraceMatMat

(

int32

dim

)

Definition at line 630 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, kNoTrans, kTrans, rnnlm::n, CuMatrixBase< Real >::SetRandn(), and TraceMatMat().

                                                                {
  for (int32 n = 0; n < 2; n++) {
    MatrixTransposeType trans = (n == 0 ? kNoTrans : kTrans);
    BaseFloat time_in_secs = 0.02;

    CuMatrix<Real> M(dim, dim), N(dim, dim);
    M.SetRandn();
    N.SetRandn();
    Timer tim;
    int32 iter = 0;
    for (;tim.Elapsed() < time_in_secs; iter++) {
      TraceMatMat(M, N, trans);
    }
    BaseFloat fdim = dim;
    BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
    KALDI_LOG << "For CuMatrix::TraceMatMat" << NameOf<Real>()
              << (trans == kTrans ? " [transposed]" : "") << ", for dim = "
              << dim << ", speed was " << gflops << " gigaflops.";
  }
}

TestCuMatrixTransposeCross()

void kaldi::TestCuMatrixTransposeCross

(

int32

dim

)

Definition at line 148 of file cu-matrix-speed-test.cc.

References AssertEqual(), CuMatrixBase< Real >::CopyFromMat(), Timer::Elapsed(), KALDI_LOG, and kTrans.

                                                                   {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<float> Mf(dim / 2, dim), ref(dim, dim / 2);
  CuMatrix<Real> Md(dim, dim / 2);
  Mf.SetRandn();
  ref = Mf;

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    Md.CopyFromMat(Mf, kTrans);
    Mf.CopyFromMat(Md, kTrans);
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::TransposeCross" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops.";

  AssertEqual(ref, Mf);
}

TestCuMatrixTransposeNS()

void kaldi::TestCuMatrixTransposeNS

(

int32

dim

)

Definition at line 116 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::SetRandn(), and CuMatrix< Real >::Transpose().

                                                                {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim / 2);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.Transpose();
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter / 2) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::TransposeNS" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuMatrixTransposeS()

void kaldi::TestCuMatrixTransposeS

(

int32

dim

)

Definition at line 132 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuMatrixBase< Real >::SetRandn(), and CuMatrix< Real >::Transpose().

                                                               {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (; tim.Elapsed() < time_in_secs; iter++) {
    M.Transpose();
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG<< "For CuMatrix::TransposeS" << NameOf<Real>() << ", for dim = "
  << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuSparseMatrixTraceMatSmat()

void kaldi::TestCuSparseMatrixTraceMatSmat

(

int32

dim

)

Definition at line 983 of file cu-matrix-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, kNoTrans, kTrans, rnnlm::n, Rand(), CuMatrixBase< Real >::SetRandn(), and TraceMatSmat().

                                                                       {
  for (int32 n = 0; n < 2; n++) {
    MatrixTransposeType trans = (n == 0 ? kNoTrans : kTrans);
    BaseFloat time_in_secs = 0.02;

    CuMatrix<Real> M(dim, dim);
    M.SetRandn();

    std::vector<std::vector<std::pair<MatrixIndexT, Real> > > pairs(dim);
    for (auto && row : pairs) {
      row.push_back( { MatrixIndexT(Rand() % dim), Real(Rand() % dim) });
    }
    SparseMatrix<Real> Ncpu(dim, pairs);
    CuSparseMatrix<Real> N(Ncpu);

    Timer tim;
    int32 iter = 0;
    for (;tim.Elapsed() < time_in_secs; iter++) {
      TraceMatSmat(M, N, trans);
    }
    BaseFloat fdim = dim;
    BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
    KALDI_LOG << "For CuSparseMatrix::TraceMatSmat" << NameOf<Real>()
              << (trans == kTrans ? " [transposed]" : "") << ", for dim = "
              << dim << ", speed was " << gflops << " gigaflops.";
  }
}

TestCuVectorAddColSumMat()

void kaldi::TestCuVectorAddColSumMat	(	int32	dim,
		MatrixTransposeType	trans
	)

Definition at line 266 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::AddColSumMat(), Timer::Elapsed(), KALDI_LOG, kTrans, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                                                            {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  CuMatrix<Real> N(dim, dim);
  N.SetRandn();

  Timer tim;
  int32 iter = 0;

  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.AddColSumMat(1.0, N, 0.5);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::AddColSumMat" << NameOf<Real>()
            << (trans == kTrans ? "[trans]" : "[no-trans]") << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorAddDiagMat2()

void kaldi::TestCuVectorAddDiagMat2	(	int32	dim,
		MatrixTransposeType	trans
	)

Definition at line 222 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::AddDiagMat2(), Timer::Elapsed(), KALDI_LOG, kTrans, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                                                           {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  CuMatrix<Real> N(dim, dim);
  N.SetRandn();

  Timer tim;
  int32 iter = 0;

  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.AddDiagMat2(1.0, N, trans, 0.0);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::AddDiagMat2" << NameOf<Real>()
            << (trans == kTrans ? "[trans]" : "[no-trans]") << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorAddDiagMat2OnVariousShapes()

void kaldi::TestCuVectorAddDiagMat2OnVariousShapes	(	int32	dim,
		MatrixTransposeType	trans
	)

Definition at line 196 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::AddDiagMat2(), Timer::Elapsed(), KALDI_LOG, kNoTrans, kTrans, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                          {
  BaseFloat time_in_secs = 0.02;
  int32 size = 1024 * 32;
  CuVector<Real> v(trans == kNoTrans ? size / dim : dim);
  v.SetRandn();
  CuMatrix<Real> N(size / dim, dim);
  N.SetRandn();

  Timer tim;
  int32 iter = 0;

  for (; tim.Elapsed() < time_in_secs; iter++) {
    v.AddDiagMat2(1.0, N, trans, 0.0);
  }

  BaseFloat fdim = size;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::AddDiagMat2Shapes" << NameOf<Real>()
            << (trans == kTrans ? "[trans]" : "[no-trans]") << ", for dim = ("
            << size / dim << ", " << dim  << "), speed was " << gflops
            << " gigaflops.";
}

TestCuVectorAddDiagMatMat()

void kaldi::TestCuVectorAddDiagMatMat	(	int32	dim,
		MatrixTransposeType	transN,
		MatrixTransposeType	transO
	)

Definition at line 170 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::AddDiagMatMat(), Timer::Elapsed(), KALDI_LOG, kNoTrans, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                                                   {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  CuMatrix<Real> N(dim, dim), O(dim, dim);
  N.SetRandn();
  O.SetRandn();

  Timer tim;
  int32 iter = 0;

  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.AddDiagMatMat(1.0, N, transN, O, transO, 1.0);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::AddDiagMatMat" << NameOf<Real>()
            << (transN == kNoTrans ? "[no-trans],":"[trans],")
            << (transO == kNoTrans ? "[no-trans],":"[trans],")
            << " for dim = "<< dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorAddDiagMatMatShape()

void kaldi::TestCuVectorAddDiagMatMatShape	(	int32	num_rows,
		int32	num_cols,
		MatrixTransposeType	transM,
		MatrixTransposeType	transN
	)

Definition at line 372 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::AddDiagMatMat(), Timer::Elapsed(), KALDI_LOG, kNoTrans, kTrans, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(transM == kTrans ? num_cols : num_rows);
  v.SetRandn();
  CuMatrix<Real> M(num_rows, num_cols);
  CuMatrix<Real> N(transM != transN ? num_rows : num_cols,
                   transM != transN ? num_cols : num_rows);
  M.SetRandn();
  N.SetRandn();

  Timer tim;
  int32 iter = 0;

  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.AddDiagMatMat(1.0, M, transM, N, transN, 1.0);
  }

  BaseFloat fnr = num_rows;
  BaseFloat fnc = num_cols;
  BaseFloat gflops = (fnr * fnc * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::AddDiagMatMat" << NameOf<Real>()
            << (transM == kNoTrans ? "[no-trans],":"[trans],")
            << (transN == kNoTrans ? "[no-trans],":"[trans],")
            << " for dim = "<< num_rows << ", " << num_cols
            << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorAddRowSumMat()

void kaldi::TestCuVectorAddRowSumMat	(	int32	dim,
		MatrixTransposeType	trans
	)

Definition at line 244 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::AddRowSumMat(), Timer::Elapsed(), KALDI_LOG, kTrans, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                                                            {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  CuMatrix<Real> N(dim, dim);
  N.SetRandn();

  Timer tim;
  int32 iter = 0;

  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.AddRowSumMat(1.0, N, 0.5);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::AddRowSumMat" << NameOf<Real>()
            << (trans == kTrans ? "[trans]" : "[no-trans]") << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorApplyCeiling()

void kaldi::TestCuVectorApplyCeiling

(

int32

dim

)

Definition at line 330 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::ApplyCeiling(), Timer::Elapsed(), KALDI_LOG, RandInt(), and CuVectorBase< Real >::SetRandn().

                                                                 {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  Real threshold = RandInt(-35000, 35000) / Real(100);

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    MatrixIndexT dummy_count;
    v.ApplyCeiling(threshold, &dummy_count);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::ApplyCeiling" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";

}

TestCuVectorApplyCeilingNoCount()

void kaldi::TestCuVectorApplyCeilingNoCount

(

int32

dim

)

Definition at line 351 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::ApplyCeiling(), Timer::Elapsed(), KALDI_LOG, RandInt(), and CuVectorBase< Real >::SetRandn().

                                                                        {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  Real threshold = RandInt(-35000, 35000) / Real(100);

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.ApplyCeiling(threshold, nullptr);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::ApplyCeiling (no count variety)" << NameOf<Real>()
            << ", for dim = " << dim << ", speed was " << gflops
            << " gigaflops.";

}

TestCuVectorApplyFloor()

void kaldi::TestCuVectorApplyFloor

(

int32

dim

)

Definition at line 288 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::ApplyFloor(), Timer::Elapsed(), KALDI_LOG, RandInt(), and CuVectorBase< Real >::SetRandn().

                                                               {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  Real threshold = RandInt(-35000, 35000) / Real(100);

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    MatrixIndexT dummy_count;
    v.ApplyFloor(threshold, &dummy_count);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::ApplyFloor" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";

}

TestCuVectorApplyFloorNoCount()

void kaldi::TestCuVectorApplyFloorNoCount

(

int32

dim

)

Definition at line 309 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::ApplyFloor(), Timer::Elapsed(), KALDI_LOG, RandInt(), and CuVectorBase< Real >::SetRandn().

                                                                      {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> v(dim);
  v.SetRandn();
  Real threshold = RandInt(-35000, 35000) / Real(100);

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    v.ApplyFloor(threshold, nullptr);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::ApplyFloor (no count variety)" << NameOf<Real>()
            << ", for dim = " << dim << ", speed was " << gflops
            << " gigaflops.";

}

TestCuVectorCopyFromVec()

void kaldi::TestCuVectorCopyFromVec

(

int32

dim

)

Definition at line 79 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::CopyFromVec(), CU1DBLOCK, CuVectorBase< Real >::Data(), CuVectorBase< Real >::Dim(), Timer::Elapsed(), KALDI_LOG, kUndefined, CuVectorBase< Real >::SetRandn(), and VectorBase< Real >::Sum().

                                                                                    {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> M(dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    CuVector<OtherReal> v(dim);
    v.CopyFromVec(M);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::CopyFromVec" << NameOf<Real>() << " to "
            <<  NameOf<OtherReal>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorSoftmax()

void kaldi::TestCuVectorSoftmax

(

int32

dim

)

Definition at line 44 of file cu-vector-speed-test.cc.

References CuVectorBase< Real >::ApplySoftMax(), Timer::Elapsed(), KALDI_LOG, and CuVectorBase< Real >::SetRandn().

                                                            {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> M(dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    M.ApplySoftMax();
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::Softmax" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorSum()

void kaldi::TestCuVectorSum

(

int32

dim

)

Definition at line 62 of file cu-vector-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuVectorBase< Real >::SetRandn(), and CuVectorBase< Real >::Sum().

                                                        {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> M(dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    M.Sum();
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::Sum" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestCuVectorVecVecOne()

void kaldi::TestCuVectorVecVecOne

(

int32

dim

)

Definition at line 148 of file cu-vector-speed-test.cc.

References Timer::Elapsed(), KALDI_LOG, CuVectorBase< Real >::Set(), CuVectorBase< Real >::SetRandn(), and VecVec().

                                                              {
  BaseFloat time_in_secs = 0.02;
  CuVector<Real> M(dim);
  M.SetRandn();

  Timer tim;
  int32 iter = 0;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    CuVector<Real> ones(dim);
    ones.Set(1.0);
    VecVec(M, ones);
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuVector::VecVecOne" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestDistance()

static void kaldi::TestDistance ( )

static

Definition at line 117 of file cluster-utils-test.cc.

References AssertEqual(), and ScalarClusterable::Objf().

Referenced by main().

                           {
  ScalarClusterable a(1.0), b(2.5);
  AssertEqual(a.Objf(), 0.0);
  AssertEqual(b.Objf(), 0.0);
  AssertEqual(a.ObjfPlus(b), -a.Distance(b));  // since distance is negated objf-change, and original objfs were zero.
} // end namespace kaldi

TestDoTableSplit()

void kaldi::TestDoTableSplit

(

)

Definition at line 206 of file build-tree-utils-test.cc.

References DoTableSplit(), rnnlm::i, KALDI_ASSERT, EventMap::Lookup(), EventMap::Map(), RandInt(), and TrivialTree().

Referenced by main().

                        {
  EventValueType numvals = 11;
  for (size_t iter = 0;iter < 10;iter++) {
    BuildTreeStatsType stats;
    int32 nKeys = 3;
    EventKeyType k = RandInt(-1, nKeys-2);  // key we will split on.
    std::set<EventValueType> all_vals;
    for (size_t i = 0;i < 10;i++) {
      EventType evec;
      for (EventKeyType kk = -1;kk < nKeys-1;kk++) {
        EventValueType v = RandInt(0, numvals);
        if (kk == k) all_vals.insert(v);
        evec.push_back(std::make_pair(kk, v));
      }
      stats.push_back(std::pair<EventType, Clusterable*>(evec, (Clusterable*) NULL));
    }
    int32 nleaves = 0;
    EventMap *trivial_map = TrivialTree(&nleaves);

    EventMap *table_map = DoTableSplit(*trivial_map, k, stats, &nleaves);
    KALDI_ASSERT(nleaves <= numvals);
    for (size_t i = 0;i < 10;i++) {
      size_t idx1 = RandInt(0, stats.size()-1), idx2 = RandInt(0, stats.size()-1);
      EventAnswerType ans1;
      table_map->Map(stats[idx1].first, &ans1);
      EventAnswerType ans2;
      table_map->Map(stats[idx2].first, &ans2);

      EventValueType val1, val2;
      bool b = EventMap::Lookup(stats[idx1].first, k, &val1)
             && EventMap::Lookup(stats[idx2].first, k, &val2);
      KALDI_ASSERT(b);
      KALDI_ASSERT(val1 >= 0 );
      KALDI_ASSERT( (val1 == val2) == (ans1 == ans2) );
    }
    for (EventValueType i = 0;i < numvals+1;i++) {
      if (all_vals.count(i) == 0) {
        EventType v; v.push_back(std::make_pair(k, i));
        EventAnswerType ans;
        bool b = table_map->Map(v, &ans);
        KALDI_ASSERT(!b);  // check it maps stuff we never saw to undefined.
      }
    }
    delete trivial_map;
    delete table_map;
  }
}

TestEditDistance()

void kaldi::TestEditDistance

(

)

Definition at line 26 of file edit-distance-test.cc.

References KALDI_ASSERT, and LevenshteinEditDistance().

Referenced by main().

                        {
  std::vector<int32> a;
  std::vector<int32> b;
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 0);

  a.push_back(1);
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 1);

  b.push_back(1);
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 0);

  b.push_back(2);
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 1);

  a.push_back(2);
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 0);

  a.push_back(3);
  a.push_back(4);
  b.push_back(4);

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 1);

  a.push_back(5);

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 2);

  b.push_back(6);

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 2);

  a.push_back(1);
  b.push_back(1);

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 2);

  b.push_back(10);

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 3);
}

TestEditDistance2()

void kaldi::TestEditDistance2

(

)

Definition at line 112 of file edit-distance-test.cc.

References KALDI_ASSERT, LevenshteinEditDistance(), Rand(), and swap().

Referenced by main().

                         {
  std::vector<int32>  hyp;
  std::vector<int32>  ref;
  int32 ins, del, sub, total_cost;
  // initialize hypothesis
  hyp.push_back(1);
  hyp.push_back(3);
  hyp.push_back(4);
  hyp.push_back(5);
  // initialize reference
  ref.push_back(2);
  ref.push_back(3);
  ref.push_back(4);
  ref.push_back(5);
  ref.push_back(6);
  ref.push_back(7);
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 3  && ins == 0 && del == 2 && sub == 1);

  std::swap(hyp, ref);
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 3 && ins == 2 && del == 0 && sub == 1);

  hyp.clear();
  ref.clear();
  hyp.push_back(1);
  ref.push_back(1);
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 0 && ins+del+sub == 0);
  hyp.push_back(2);
  ref.push_back(3);
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 1 && ins == 0 && del == 0 && sub == 1);
  // randomized test
  size_t num = 0;
  for (; num < 1000; num ++) {
    int32  hyp_len = Rand()%11;
    int32  ref_len = Rand()%3;
    hyp.resize(hyp_len);
    ref.resize(ref_len);

    int32 index = 0;
    for (; index < hyp_len; index ++)
      hyp[index] = Rand()%4;
    for (index = 0; index < ref_len; index ++)
      ref[index] = Rand()%4;
    // current version
    total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
    // previous version
    int32 total_cost2 = LevenshteinEditDistance(hyp, ref);
    // verify both are the same
    KALDI_ASSERT(total_cost == total_cost2);
    KALDI_ASSERT(ins+del+sub == total_cost);
    KALDI_ASSERT(del-ins == static_cast<int32>(ref.size() -hyp.size()));
  }
  return;
}

TestEditDistance2String()

void kaldi::TestEditDistance2String

(

)

Definition at line 172 of file edit-distance-test.cc.

References KALDI_ASSERT, LevenshteinEditDistance(), Rand(), and swap().

Referenced by main().

                               {
  std::vector<std::string>  hyp;
  std::vector<std::string>  ref;
  int32 ins, del, sub, total_cost;
  // initialize hypothesis
  hyp.push_back("1");
  hyp.push_back("3");
  hyp.push_back("4");
  hyp.push_back("5");
  // initialize reference
  ref.push_back("2");
  ref.push_back("3");
  ref.push_back("4");
  ref.push_back("5");
  ref.push_back("6");
  ref.push_back("7");
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 3  && ins == 0 && del == 2 && sub == 1);

  std::swap(hyp, ref);
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 3 && ins == 2 && del == 0 && sub == 1);

  hyp.clear();
  ref.clear();
  hyp.push_back("1");
  ref.push_back("1");
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 0 && ins+del+sub == 0);
  hyp.push_back("2");
  ref.push_back("3");
  total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
  KALDI_ASSERT(total_cost == 1 && ins == 0 && del == 0 && sub == 1);
  // randomized test
  size_t num = 0;
  for (; num < 1000; num ++) {
    int32  hyp_len = Rand()%11;
    int32  ref_len = Rand()%3;
    hyp.resize(hyp_len);
    ref.resize(ref_len);

    int32 index = 0;
    for (; index < hyp_len; index ++)
      hyp[index] = Rand()%4;
    for (index = 0; index < ref_len; index ++)
      ref[index] = Rand()%4;
    // current version
    total_cost = LevenshteinEditDistance(ref, hyp, &ins, &del, &sub);
    // previous version
    int32 total_cost2 = LevenshteinEditDistance(hyp, ref);
    // verify both are the same
    KALDI_ASSERT(total_cost == total_cost2);
    KALDI_ASSERT(ins+del+sub == total_cost);
    KALDI_ASSERT(del-ins == static_cast<int32>(ref.size() -hyp.size()));
  }
  return;
}

TestEditDistanceString()

void kaldi::TestEditDistanceString

(

)

Definition at line 68 of file edit-distance-test.cc.

References KALDI_ASSERT, and LevenshteinEditDistance().

Referenced by main().

                              {
  std::vector<std::string> a;
  std::vector<std::string> b;
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 0);

  a.push_back("1");
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 1);

  b.push_back("1");
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 0);

  b.push_back("2");
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 1);

  a.push_back("2");
  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 0);

  a.push_back("3");
  a.push_back("4");
  b.push_back("4");

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 1);

  a.push_back("5");

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 2);

  b.push_back("6");

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 2);

  a.push_back("1");
  b.push_back("1");

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 2);

  b.push_back("10");

  KALDI_ASSERT(LevenshteinEditDistance(a, b) == 3);
}

TestEnsureClusterableVectorNotNull()

static void kaldi::TestEnsureClusterableVectorNotNull ( )

static

Definition at line 147 of file cluster-utils-test.cc.

References DeletePointers(), EnsureClusterableVectorNotNull(), and KALDI_ASSERT.

Referenced by main().

                                                 {
  ScalarClusterable a(1.0), b(2.5);
  std::vector<Clusterable*> vec(4);
  vec[1] = a.Copy(); vec[3] = a.Copy();
  EnsureClusterableVectorNotNull(&vec);
  KALDI_ASSERT(vec[0] != NULL && vec[2] != NULL && vec[0]->Objf() == 0 && vec[2]->Objf() == 0 && vec[0] != vec[2] && vec[0] != vec[1]);
  DeletePointers(&vec);
}

TestEventMap()

void kaldi::TestEventMap

(

)

Definition at line 27 of file event-map-test.cc.

References GetTreeStructure(), rnnlm::i, KALDI_ASSERT, TableEventMap::Map(), EventMap::MaxResult(), and Rand().

Referenced by main().

                    {
  typedef EventKeyType KeyType;
  typedef EventValueType ValueType;
  typedef EventAnswerType AnswerType;


  ConstantEventMap *C0a = new ConstantEventMap(0);
  {
    int32 num_leaves;
    std::vector<int32> parents;
    bool a = GetTreeStructure(*C0a, &num_leaves, &parents);
    KALDI_ASSERT(a && parents.size() == 1 && parents[0] == 0);
  }
  ConstantEventMap *C1b = new ConstantEventMap(1);
  {
    int32 num_leaves;
    std::vector<int32> parents;
    bool a = GetTreeStructure(*C1b, &num_leaves, &parents);
    KALDI_ASSERT(!a); // since C1b's leaves don't start from 0.
  }
  
  std::vector<EventMap*> tvec;
  tvec.push_back(C0a);
  tvec.push_back(C1b);

  TableEventMap *T1 = new TableEventMap(1, tvec);  // takes ownership of C0a, C1b
  KALDI_ASSERT(T1->MaxResult() == 1);

  {
    int32 num_leaves;
    std::vector<int32> parents;
    bool a = GetTreeStructure(*T1, &num_leaves, &parents);
    KALDI_ASSERT(a && parents.size() == 3 && parents[0] == 2
                 && parents[1] == 2 && parents[2] == 2);
  }
  
  ConstantEventMap *C0c = new ConstantEventMap(0);
  ConstantEventMap *C1d = new ConstantEventMap(1);

  std::map<ValueType, EventMap*> tmap;
  tmap[0] = C0c; tmap[1] = C1d;
  TableEventMap *T2 = new TableEventMap(1, tmap);  // takes ownership of pointers C0c and C1d.

  std::vector<ValueType> vec;
  vec.push_back(4);
  vec.push_back(5);


  ConstantEventMap *D1 = new ConstantEventMap(10);  // owned by D3 below
  ConstantEventMap *D2 = new ConstantEventMap(15);  // owned by D3 below

  SplitEventMap *D3 = new   SplitEventMap(1, vec, D1, D2);

  // Test different initializer  for TableEventMap where input maps ints to ints.
  for (size_t i = 0;i < 100;i++) {
    size_t nElems = Rand() % 10;  // num of value->answer pairs.
    std::map<ValueType, AnswerType> init_map;
    for (size_t i = 0;i < nElems;i++) {
      init_map[Rand() % 10] = Rand() % 5;
    }
    EventKeyType key = Rand() % 10;
    TableEventMap T3(key, init_map);
    for (size_t i = 0; i < 10; i++) {
      EventType vec;
      vec.push_back(std::make_pair(key, (ValueType) i));
      AnswerType ans;
      // T3.Map(vec, &ans);
      if (init_map.count(i) == 0) {
        KALDI_ASSERT( ! T3.Map(vec, &ans) );  // false
      } else {
        bool b = T3.Map(vec, &ans);
        KALDI_ASSERT(b);
        KALDI_ASSERT(ans == init_map[i]);  // true
      }
    }
  }

  delete T1;
  delete T2;
  delete D3;
}

TestEventMapIo()

void kaldi::TestEventMapIo

(

bool

binary

)

Definition at line 178 of file event-map-test.cc.

References CopySetToVector(), KALDI_ASSERT, Rand(), RandomEventMap(), EventMap::Read(), and EventMap::Write().

Referenced by main().

                                 {
  for (size_t p = 0; p < 20; p++) {
    int32 max_key = 10;
    int32 num_keys = 1 + (Rand() % (max_key - 1));
    std::set<EventKeyType> key_set;
    // - 5 to allow negative keys.  These are allowed.
    while (key_set.size() < (size_t)num_keys) key_set.insert( (Rand() % (2*max_key)) - 5);
    std::vector<EventKeyType> key_vec;
    CopySetToVector(key_set, &key_vec);
    EventMap *rand_map = RandomEventMap(key_vec);

    std::ostringstream str_out;
    EventMap::Write(str_out, binary, rand_map);


    if (p < 1) {
      std::cout << "Random map is: "<<str_out.str()<<'\n';
    }

    std::istringstream str_in(str_out.str());

    EventMap *read_map = EventMap::Read(str_in, binary);
    std::ostringstream str2_out;
    EventMap::Write(str2_out, binary, read_map);

    // Checking we can write the map, read it in, and get the same string form.
    KALDI_ASSERT(str_out.str() == str2_out.str());
    delete read_map;
    delete rand_map;
  }
}

TestEventMapMapValues()

void kaldi::TestEventMapMapValues

(

)

Definition at line 270 of file event-map-test.cc.

References rnnlm::i, KALDI_ASSERT, kMaxVal, EventMap::Map(), EventMap::MapValues(), Rand(), and RandomEventMap().

Referenced by main().

                             {
  std::vector<EventKeyType> keys;
  keys.push_back(1); // these keys are 
  keys.push_back(2); // hardwired into the code below, do not change
  EventMap *em = RandomEventMap(keys);
  EventType empty_event;

  unordered_set<EventKeyType> mapped_keys;
  unordered_map<EventKeyType,EventKeyType> value_map;
  if (Rand() % 2 == 0) mapped_keys.insert(1);
  if (Rand() % 2 == 0) mapped_keys.insert(2);

  EventValueType v_offset = Rand() % kMaxVal;
  for (EventValueType v = 0; v < kMaxVal; v++)
    value_map[v] = (v + v_offset) % kMaxVal;
    
  EventMap *mapped_em = em->MapValues(mapped_keys, value_map);
  
  for (int32 i = 0; i < 10; i++) {
    EventType event, mapped_event;
    for (int32 key = 1; key <= 2; key++) {
      if (Rand() % 2 == 0) {
        EventValueType value = Rand() % kMaxVal;
        event.push_back(std::make_pair(key, value));
        EventValueType mapped_value;
        if (mapped_keys.count(key) == 0) mapped_value = value;
        else mapped_value = value_map[value];
        mapped_event.push_back(std::make_pair(key, mapped_value));
      }
    }
    EventAnswerType answer, answer2;
    if (em->Map(event, &answer)) {
      bool ret = mapped_em->Map(mapped_event, &answer2);
      KALDI_ASSERT(ret);
      KALDI_ASSERT(answer == answer2);
    }
  }
  delete em;
  delete mapped_em;
}

TestEventMapPrune()

void kaldi::TestEventMapPrune

(

)

Definition at line 210 of file event-map-test.cc.

References EventMap::Copy(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, EventMap::Map(), EventMap::MultiMap(), EventMap::Prune(), Rand(), RandomEventMap(), and SortAndUniq().

Referenced by main().

                         {
  const EventAnswerType no_ans = -10;
  std::vector<EventKeyType> keys;
  keys.push_back(1); // these keys are 
  keys.push_back(2); // hardwired into the code below, do not change
  EventMap *em = RandomEventMap(keys);
  EventType empty_event;
  std::vector<EventAnswerType> all_answers;
  em->MultiMap(empty_event, &all_answers);
  SortAndUniq(&all_answers);
  std::vector<EventMap*> new_leaves;
  std::vector<EventAnswerType> mapping;
  for (size_t i = 0; i < all_answers.size(); i++) {
    EventAnswerType ans = all_answers[i];
    KALDI_ASSERT(ans >= 0);
    new_leaves.resize(ans + 1, NULL);
    mapping.resize(ans + 1, no_ans);
    EventAnswerType map_to;
    if (Rand() % 2 == 0) map_to = -1;
    else map_to = Rand() % 20;
    new_leaves[ans] = new ConstantEventMap(map_to);
    mapping[ans] = map_to;
  }
  EventMap *mapped_em = em->Copy(new_leaves),
      *pruned_em = mapped_em->Prune();
  for (size_t i = 0; i < new_leaves.size(); i++)
    delete new_leaves[i];
  for (int32 i = 0; i < 10; i++) {
    EventType event;
    for (int32 key = 1; key <= 2; key++) {
      if (Rand() % 2 == 0) {
        EventValueType value = Rand() % 20;
        event.push_back(std::make_pair(key, value));
      }
    }
    EventAnswerType answer, answer2;
    if (em->Map(event, &answer)) {
      bool ret;
      if (pruned_em == NULL) ret = false;
      else ret = pruned_em->Map(event, &answer2);
      KALDI_ASSERT(answer >= 0);
      EventAnswerType mapped_ans = mapping[answer];
      KALDI_ASSERT(mapped_ans != no_ans);
      if (mapped_ans == -1) {
        if (ret == false)
          KALDI_LOG << "Answer was correctly pruned away.";
        else
          KALDI_LOG << "Answer was not pruned away [but this is not required]";
      } else {
        KALDI_ASSERT(ret == true);
        KALDI_ASSERT(answer2 == mapped_ans);
        KALDI_LOG << "Answers match " << answer << " -> " << answer2;
      }
    }
  }
  delete em;
  delete mapped_em;
  delete pruned_em;
}

TestEventTypeIo()

void kaldi::TestEventTypeIo

(

bool

binary

)

Definition at line 110 of file event-map-test.cc.

References Output::Close(), rnnlm::i, KALDI_ASSERT, Rand(), ReadEventType(), Output::Stream(), Input::Stream(), and WriteEventType().

Referenced by main().

                                  {
  for (size_t p = 0; p < 20; p++) {
    EventType event_vec;
    size_t size = Rand() % 20;
    event_vec.resize(size);
    for (size_t i = 0;i < size;i++) {
      event_vec[i].first = Rand() % 10 + (i > 0 ? event_vec[i-1].first : 0);
      event_vec[i].second = Rand() % 20;
    }


    {
      const char *filename = "tmpf";
      Output ko(filename, binary);
      std::ostream &outfile = ko.Stream();
      WriteEventType(outfile, binary, event_vec);
      ko.Close();

      {
        bool binary_in;
        Input ki(filename, &binary_in);
        std::istream &infile = ki.Stream();
        EventType evec2;
        evec2.push_back(std::pair<EventKeyType, EventValueType>(1, 1));  // make it nonempty.
        ReadEventType(infile, binary_in, &evec2);
        KALDI_ASSERT(evec2 == event_vec);
      }
    }
  }

  unlink("tmpf");
}

TestFindAllKeys()

void kaldi::TestFindAllKeys

(

)

Definition at line 148 of file build-tree-utils-test.cc.

References CopyMapKeysToSet(), CopyMapToVector(), CopySetToVector(), FindAllKeys(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, kAllKeysInsistIdentical, kAllKeysIntersection, kAllKeysUnion, and RandInt().

Referenced by main().

                       {
  for (size_t iter = 0;iter < 10;iter++) {
    BuildTreeStatsType stats;
    std::set<EventKeyType> all_keys_union;
    std::set<EventKeyType> all_keys_intersection;

    for (size_t i = 0;i < 3;i++) {
      std::map<EventKeyType, EventValueType> key_vals;
      for (size_t j = 0;j < 5;j++) {
        EventKeyType k = RandInt(-2, 1);
        EventValueType v = RandInt(0, 10);
        key_vals[k] =  v;
      }
      EventType evec;
      CopyMapToVector(key_vals, &evec);
      stats.push_back(std::pair<EventType, Clusterable*>(evec, (Clusterable*) NULL));
      std::set<EventKeyType> s;
      CopyMapKeysToSet(key_vals, &s);
      if (i == 0) { all_keys_union = s; all_keys_intersection = s; }
      else {
        std::set<EventKeyType> new_intersection;
        for (std::set<EventKeyType>::iterator iter = s.begin(); iter != s.end(); iter++) {
          all_keys_union.insert(*iter);
          if (all_keys_intersection.count(*iter) != 0) new_intersection.insert(*iter);
        }
        all_keys_intersection = new_intersection;
      }
    }

    {  // test in union mode.
      std::vector<EventKeyType> keys1, keys2;
      CopySetToVector(all_keys_union, &keys1);
      FindAllKeys(stats, kAllKeysUnion, &keys2);
      KALDI_ASSERT(keys1 == keys2);
    }
    {  // test in intersection mode.
      std::vector<EventKeyType> keys1, keys2;
      CopySetToVector(all_keys_intersection, &keys1);
      FindAllKeys(stats, kAllKeysIntersection, &keys2);
      KALDI_ASSERT(keys1 == keys2);
    }
    {  // test in insist-same mode.
      std::vector<EventKeyType> keys1, keys2;
      CopySetToVector(all_keys_intersection, &keys1);
      try {
        FindAllKeys(stats, kAllKeysInsistIdentical, &keys2);  // note, it SHOULD throw an exception here.
        // This is for testing purposes.  It gets caught.
        KALDI_ASSERT(keys1 == keys2);
        KALDI_ASSERT(all_keys_union == all_keys_intersection);
      } catch(...) {  // it should throw exception if all keys are not the same.
        KALDI_LOG << "Ignore previous error.";
        KALDI_ASSERT(all_keys_union != all_keys_intersection);
      }
    }
  }
}

TestFmpe()

void kaldi::TestFmpe

(

)

Definition at line 79 of file fmpe-test.cc.

References Fmpe::AccStats(), MatrixBase< Real >::AddMat(), Fmpe::ComputeFeatures(), GetFeatDeriv(), GetGmmLike(), rnnlm::i, kaldi::unittest::InitRandDiagGmm(), MatrixBase< Real >::IsZero(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kTrans, FmpeUpdateOptions::learning_rate, MatrixBase< Real >::NumCols(), DiagGmm::NumGauss(), MatrixBase< Real >::NumRows(), Rand(), RandGauss(), Fmpe::Read(), Output::Stream(), Input::Stream(), TraceMatMat(), Fmpe::Update(), and Fmpe::Write().

Referenced by main().

                {
  int32 dim = 10 + (Rand() % 10);
  int32 num_comp = 10 + (Rand() % 10);
  DiagGmm gmm;
  unittest::InitRandDiagGmm(dim, num_comp, &gmm);
  
  int32 num_frames = 20;
  Matrix<BaseFloat> feats(num_frames, dim);

  for (int32 i = 0; i < num_frames; i++)
    for (int32 j = 0; j < dim; j++)
      feats(i, j) = RandGauss();

  FmpeOptions opts; // Default.
  {
    Fmpe fmpe(gmm, opts);
    {
      bool binary = (Rand() % 2 == 1);
      Output ko("tmpf", binary);
      fmpe.Write(ko.Stream(), binary);
    }
  }
  Fmpe fmpe(gmm, opts);
  {
    bool binary_in;
    Input ki("tmpf", &binary_in);
    fmpe.Read(ki.Stream(), binary_in);
  }

  // We'll first be testing that the feature derivative is
  // accurate, by measuring a small random offset in feature space.
  {
    Matrix<BaseFloat> deriv;
    Matrix<BaseFloat> random_offset(feats.NumRows(), feats.NumCols());
    for (int32 i = 0; i < feats.NumRows(); i++)
      for (int32 j = 0; j < feats.NumCols(); j++)
        random_offset(i, j) = 1.0e-03 * RandGauss();
    BaseFloat like_before = GetGmmLike(gmm, feats);
    feats.AddMat(1.0, random_offset);
    BaseFloat like_after = GetGmmLike(gmm, feats);
    feats.AddMat(-1.0, random_offset); // undo the change.
    GetFeatDeriv(gmm, feats, &deriv);
    BaseFloat change1 = like_after - like_before,
        change2 = TraceMatMat(random_offset, deriv, kTrans);
    KALDI_LOG << "Random offset led to like change "
              << change1 << " (manually), and " << change2
              << " (derivative)";
    // note: not making this threshold smaller, as don't want
    // spurious failures.  Seems to be OK though.
    KALDI_ASSERT( fabs(change1-change2) < 0.15*fabs(change1+change2));
  }

  std::vector<std::vector<int32> > gselect(feats.NumRows()); // make it have all Gaussians...
  for (int32 i = 0; i < feats.NumRows(); i++)
    for (int32 j = 0; j < gmm.NumGauss(); j++)
      gselect[i].push_back(j);

  Matrix<BaseFloat> fmpe_offset;
  // Check that the fMPE feature offset is zero.
  fmpe.ComputeFeatures(feats, gselect, &fmpe_offset);
  KALDI_ASSERT(fmpe_offset.IsZero());
  
  // Note: we're just using the ML objective function here.
  // This is just to make sure the derivatives are all computed
  // correctly.
  BaseFloat like_before_update = GetGmmLike(gmm, feats);
  // Now get stats for update.
  FmpeStats stats(fmpe);
  Matrix<BaseFloat> deriv;
  GetFeatDeriv(gmm, feats, &deriv);
  fmpe.AccStats(feats, gselect, deriv, NULL, &stats);
  FmpeUpdateOptions update_opts;
  update_opts.learning_rate = 0.001; // so linear assumption is more valid.
  BaseFloat delta = fmpe.Update(update_opts, stats);

  fmpe.ComputeFeatures(feats, gselect, &fmpe_offset);
  feats.AddMat(1.0, fmpe_offset);

  BaseFloat like_after_update = GetGmmLike(gmm, feats);

  BaseFloat delta2 = like_after_update - like_before_update;
  KALDI_LOG << "Change predicted by fMPE Update function is "
            << delta << ", change computed directly is "
            << delta2;
  KALDI_ASSERT(fabs(delta-delta2) < 0.15 * fabs(delta+delta2));
  
  unlink("tmpf");
}

TestGenRandContextDependency()

void kaldi::TestGenRandContextDependency

(

)

Definition at line 74 of file context-dep-test.cc.

References Output::Close(), CopySetToVector(), GenRandContextDependency(), ContextDependency::GetPdfInfo(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), ContextDependency::Read(), Output::Stream(), Input::Stream(), and ContextDependency::Write().

Referenced by main().

                                    {
  bool binary = (Rand()%2 == 0);
  size_t num_phones = 1 + Rand() % 10;
  std::set<int32> phones_set;
  while (phones_set.size() < num_phones) phones_set.insert(Rand() % (num_phones + 5));
  std::vector<int32> phones;
  CopySetToVector(phones_set, &phones);
  bool ensure_all_covered = (Rand() % 2 == 0);
  std::vector<int32> phone2num_pdf_classes;
  ContextDependency *dep = GenRandContextDependency(phones,
                                                    ensure_all_covered,  // false == don't ensure all phones covered.
                                                    &phone2num_pdf_classes);
  // stuff here.
  const char *filename = "tmpf";
  {
    Output ko(filename, binary);
    std::ostream &outfile = ko.Stream();
    {  // Test GetPdfInfo
      std::vector<std::vector<std::pair<int32, int32> > > pdf_info;
      dep->GetPdfInfo(phones, phone2num_pdf_classes, &pdf_info);
      std::vector<bool> all_phones(phones.back()+1, false);  // making sure all covered.
      for (size_t i = 0; i < pdf_info.size(); i++) {
        KALDI_ASSERT(!pdf_info[i].empty());  // make sure pdf seen.
        for (size_t j = 0; j < pdf_info[i].size(); j++) {
          int32 idx = pdf_info[i][j].first;
          KALDI_ASSERT(static_cast<size_t>(idx) < all_phones.size());
          all_phones[pdf_info[i][j].first] = true;
        }
      }
      if (ensure_all_covered)
        for (size_t k = 0; k < phones.size(); k++) KALDI_ASSERT(all_phones[phones[k]]);
    }

    dep->Write(outfile, binary);
    ko.Close();
  }
  {
    bool binary_in;
    Input ki(filename, &binary_in);
    std::istream &infile = ki.Stream();
    ContextDependency dep2;
    dep2.Read(infile, binary_in);

    std::ostringstream ostr1, ostr2;
    dep->Write(ostr1, false);
    dep2.Write(ostr2, false);
    KALDI_ASSERT(ostr1.str() == ostr2.str());
  }

  delete dep;

  unlink("tmpf");
  
  std::cout << "Note: any \"serious error\" warnings preceding this line are OK.\n";
}

TestGenRandStats()

void kaldi::TestGenRandStats

(

)

Definition at line 25 of file build-tree-test.cc.

References DeleteBuildTreeStats(), GenRandStats(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_VLOG, kPdfClass, EventMap::Lookup(), Rand(), RandUniform(), WriteBasicType(), WriteBuildTreeStats(), and WriteIntegerVector().

Referenced by main().

                        {
  for (int32 p = 0; p < 2; p++) {
    int32 dim = 1 + Rand() % 40;
    int32 num_phones = 1 + Rand() % 40;
    int32 num_stats = 1 +  (Rand() % 20);
    int32 N = 2 + Rand() % 2;  // 2 or 3.
    int32 P = Rand() % N;
    float ctx_dep_prob = 0.5 + 0.5*RandUniform();
    std::vector<int32> phone_ids(num_phones);
    for (size_t i = 0;i < (size_t)num_phones;i++)
      phone_ids[i] = (i == 0 ? (Rand() % 2) : phone_ids[i-1] + 1 + (Rand()%2));
    int32 max_phone = *std::max_element(phone_ids.begin(), phone_ids.end());
    std::vector<int32> hmm_lengths(max_phone+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]]);
    }
    BuildTreeStatsType stats;
    // put false for all_covered argument.
    // if it doesn't really ensure that all are covered with true, this will induce
    // failure in the test of context-fst.
    GenRandStats(dim, num_stats, N, P, phone_ids, hmm_lengths, is_ctx_dep, false, &stats);
    std::cout << "Writing random stats.";
    std::cout <<"dim = " << dim << '\n';
    std::cout <<"num_phones = " << num_phones << '\n';
    std::cout <<"num_stats = " << num_stats << '\n';
    std::cout <<"N = "<< N << '\n';
    std::cout <<"P = "<< P << '\n';
    std::cout << "is-ctx-dep = ";
    for (size_t i = 0;i < is_ctx_dep.size();i++)
      WriteBasicType(std::cout, false, static_cast<bool>(is_ctx_dep[i]));
    std::cout << "hmm_lengths = "; WriteIntegerVector(std::cout, false, hmm_lengths);
    std::cout << "phone_ids = "; WriteIntegerVector(std::cout, false, phone_ids);
    std::cout << "Stats are: \n";
    WriteBuildTreeStats(std::cout, false, stats);


    // Now check the properties of the stats.
    for (size_t i = 0;i < stats.size();i++) {
      EventValueType central_phone;
      bool b = EventMap::Lookup(stats[i].first, P, &central_phone);
      KALDI_ASSERT(b);
      EventValueType position;
      b = EventMap::Lookup(stats[i].first, kPdfClass, &position);
      KALDI_ASSERT(b);
      KALDI_ASSERT(position>=0 && position < hmm_lengths[central_phone]);

      for (EventKeyType j = 0; j < N; j++) {
        if (j != P) {  // non-"central" phone.
          EventValueType ctx_phone;
          b = EventMap::Lookup(stats[i].first, j, &ctx_phone);
          KALDI_ASSERT(is_ctx_dep[central_phone] == b);
        }
      }
    }
    DeleteBuildTreeStats(&stats);
  }
}

TestHashList()

void kaldi::TestHashList

(

)

Definition at line 29 of file hash-list-test.cc.

References HashList< I, T >::Clear(), count, HashList< I, T >::Delete(), HashList< I, T >::Find(), HashList< I, T >::GetList(), rnnlm::i, HashList< I, T >::Insert(), rnnlm::j, KALDI_ASSERT, Rand(), HashList< I, T >::SetSize(), and swap().

                                                 {
  typedef typename HashList<Int, T>::Elem Elem;

  HashList<Int, T> hash;
  hash.SetSize(200);  // must be called before use.
  std::map<Int, T> m1;
  for (size_t j = 0; j < 50; j++) {
    Int key = Rand() % 200;
    T val = Rand() % 50;
    m1[key] = val;
    Elem *e = hash.Find(key);
    if (e) e->val = val;
    else  hash.Insert(key, val);
  }


  std::map<Int, T> m2;

  for (int i = 0; i < 100; i++) {
    m2.clear();
    for (typename std::map<Int, T>::const_iterator iter = m1.begin();
        iter != m1.end();
        iter++) {
      m2[iter->first + 1] = iter->second;
    }
    std::swap(m1, m2);

    Elem *h = hash.Clear(), *tmp;

    hash.SetSize(100 + Rand() % 100);  // note, SetSize is relatively cheap
    // operation as long as we are not increasing the size more than it's ever
    // previously been increased to.

    for (; h != NULL; h = tmp) {
      hash.Insert(h->key + 1, h->val);
      tmp = h->tail;
      hash.Delete(h);  // think of this like calling delete.
    }

    // Now make sure h and m2 are the same.
    const Elem *list = hash.GetList();
    size_t count = 0;
    for (; list != NULL; list = list->tail, count++) {
      KALDI_ASSERT(m1[list->key] == list->val);
    }

    for (size_t j = 0; j < 10; j++) {
      Int key = Rand() % 200;
      bool found_m1 = (m1.find(key) != m1.end());
      if (found_m1) m1[key];
      Elem *e = hash.Find(key);
      KALDI_ASSERT((e != NULL) == found_m1);
      if (found_m1)
        KALDI_ASSERT(m1[key] == e->val);
    }

    KALDI_ASSERT(m1.size() == count);
  }
}

TestHmmTopology()

void kaldi::TestHmmTopology

(

)

Definition at line 27 of file hmm-topology-test.cc.

References GenRandTopology(), GetDefaultTopology(), KALDI_ASSERT, HmmTopology::MinLength(), Rand(), RandInt(), HmmTopology::Read(), and HmmTopology::Write().

Referenced by main().

                       {
  bool binary = (Rand()%2 == 0);

  std::string input_str = "<Topology>\n"
      "<TopologyEntry>\n"
      "<ForPhones> 1 2 3 4 5 6 7 8 9 </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"
      "  <TopologyEntry>\n"
      "  <ForPhones> 10 11 13  </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 </State>"
      "  </TopologyEntry>\n"
      "  </Topology>\n";

  std::string chain_input_str = "<Topology>\n"
      "<TopologyEntry>\n"
      "<ForPhones> 1 2 3 4 5 6 7 8 9 </ForPhones>\n"
      " <State> 0 <ForwardPdfClass> 0 <SelfLoopPdfClass> 1\n"
      "  <Transition> 0 0.5\n"
      "  <Transition> 1 0.5\n"
      " </State> \n"
      " <State> 1 </State>\n"
      "</TopologyEntry>\n"
      "</Topology>\n";

  HmmTopology topo;

  if (RandInt(0, 1) == 0) {
    topo = GenRandTopology();
  } else {
    std::istringstream iss(input_str);
    topo.Read(iss, false);
    KALDI_ASSERT(topo.MinLength(3) == 3);
    KALDI_ASSERT(topo.MinLength(11) == 2);
  }

  std::ostringstream oss;
  topo.Write(oss, binary);

  HmmTopology topo2;
  // std::cout << oss.str() << '\n' << std::flush;
  std::istringstream iss2(oss.str());
  topo2.Read(iss2, binary);

  {  // test equality.
    std::ostringstream oss1, oss2;
    topo.Write(oss1, false);
    topo2.Write(oss2, false);
    KALDI_ASSERT(oss1.str() == oss2.str());
  }

  {  // test chain topology
    HmmTopology chain_topo;
    std::istringstream chain_iss(chain_input_str);
    chain_topo.Read(chain_iss, false);
    KALDI_ASSERT(chain_topo.MinLength(3) == 1);
  }

  {  // make sure GetDefaultTopology does not crash.
    std::vector<int32> phones;
    phones.push_back(1);
    phones.push_back(2);
    GetDefaultTopology(phones);
  }
}

TestInf()

void kaldi::TestInf

(

)

Definition at line 242 of file text-utils-test.cc.

References ConvertStringToReal(), rnnlm::d, and KALDI_ASSERT.

               {
  Real d;
  KALDI_ASSERT(ConvertStringToReal(std::to_string(exp(10000)), &d) &&
               d > 0 && d - d != 0);
  KALDI_ASSERT(ConvertStringToReal(std::to_string(-exp(10000)), &d) &&
               d < 0 && d - d != 0);
}

TestIsLine()

void kaldi::TestIsLine

(

)

Definition at line 304 of file text-utils-test.cc.

References IsLine(), and KALDI_ASSERT.

Referenced by main().

                  {
  KALDI_ASSERT(IsLine("a"));
  KALDI_ASSERT(IsLine("a b"));
  KALDI_ASSERT(!IsLine("a\nb"));
  KALDI_ASSERT(!IsLine("a b "));
  KALDI_ASSERT(!IsLine(" a b"));
}

TestIsSorted()

static void kaldi::TestIsSorted ( )

static

Definition at line 26 of file stl-utils-test.cc.

References rnnlm::i, IsSorted(), KALDI_ASSERT, and Rand().

Referenced by main().

                           {
  for (int i = 0;i < 100;i++) {
    std::vector<int> vec, vec2;
    int len = Rand()%5;
    for (int i = 0;i < len;i++)
      vec.push_back(Rand() % 10);
    vec2 = vec;
    std::sort(vec2.begin(), vec2.end());
    KALDI_ASSERT(IsSorted(vec) == (vec == vec2));
  }
}

TestIsSortedAndUniq()

static void kaldi::TestIsSortedAndUniq ( )

static

Definition at line 38 of file stl-utils-test.cc.

References rnnlm::i, IsSortedAndUniq(), KALDI_ASSERT, and Rand().

Referenced by main().

                                  {
  for (int i = 0;i < 100;i++) {
    std::vector<int> vec, vec2;
    int len = Rand()%5;
    for (int i = 0;i < len;i++)
      vec.push_back(Rand() % 10);

    if (!IsSortedAndUniq(vec)) {
      bool ok = false;
      for (size_t i = 0; i+1 < (size_t)len; i++)
        if (vec[i] >= vec[i+1]) ok = true;  // found out-of-order or dup.
      KALDI_ASSERT(ok);
    } else {  // is sorted + uniq.
      for (size_t i = 0; i+1 < (size_t)len; i++)
        KALDI_ASSERT(vec[i] < vec[i+1]);
    }
  }
}

TestIsToken()

void kaldi::TestIsToken

(

)

Definition at line 288 of file text-utils-test.cc.

References IsToken(), and KALDI_ASSERT.

Referenced by main().

                   {
  KALDI_ASSERT(IsToken("a"));
  KALDI_ASSERT(IsToken("ab"));
  KALDI_ASSERT(!IsToken("ab "));
  KALDI_ASSERT(!IsToken(" ab"));
  KALDI_ASSERT(!IsToken("a b"));
  KALDI_ASSERT(IsToken("\231"));  // typical non-ASCII printable character,
                                  // something with an accent.
  KALDI_ASSERT(!IsToken("\377"));  // character 255, which is a form of space.
  KALDI_ASSERT(IsToken("a-b,c,d=ef"));
  KALDI_ASSERT(!IsToken("a\nb"));
  KALDI_ASSERT(!IsToken("a\tb"));
  KALDI_ASSERT(!IsToken("ab\t"));
  KALDI_ASSERT(!IsToken(""));
}

TestIvectorExtraction()

void kaldi::TestIvectorExtraction	(	const IvectorExtractor &	extractor,
		const MatrixBase< BaseFloat > &	feats,
		const FullGmm &	fgmm
	)

Definition at line 85 of file ivector-extractor-test.cc.

References IvectorExtractorUtteranceStats::AccStats(), OnlineIvectorEstimationStats::AccStats(), FullGmm::ComponentPosteriors(), IvectorExtractor::GetAuxf(), OnlineIvectorEstimationStats::GetIvector(), IvectorExtractor::GetIvectorDistribution(), rnnlm::i, IvectorExtractor::IvectorDependentWeights(), IvectorExtractor::IvectorDim(), KALDI_ASSERT, KALDI_LOG, kUndefined, MatrixBase< Real >::NumCols(), IvectorExtractorUtteranceStats::NumFrames(), FullGmm::NumGauss(), IvectorExtractor::NumGauss(), MatrixBase< Real >::NumRows(), OnlineIvectorEstimationStats::ObjfChange(), IvectorExtractor::PriorOffset(), and MatrixBase< Real >::Row().

Referenced by UnitTestIvectorExtractor().

                                                {
  if (extractor.IvectorDependentWeights())
    return;  // Nothing to do as online iVector estimator does not work in this
             // case.
  int32 num_frames = feats.NumRows(),
      feat_dim = feats.NumCols(),
      num_gauss = extractor.NumGauss(),
      ivector_dim = extractor.IvectorDim();
  Posterior post(num_frames);

  double tot_log_like = 0.0;
  for (int32 t = 0; t < num_frames; t++) {
    SubVector<BaseFloat> frame(feats, t);
    Vector<BaseFloat> posterior(fgmm.NumGauss(), kUndefined);
    tot_log_like += fgmm.ComponentPosteriors(frame, &posterior);
    for (int32 i = 0; i < posterior.Dim(); i++)
      post[t].push_back(std::make_pair(i, posterior(i)));
  }
    
  // The zeroth and 1st-order stats are in "utt_stats".
  IvectorExtractorUtteranceStats utt_stats(num_gauss, feat_dim,
                                           false);
  utt_stats.AccStats(feats, post);

  OnlineIvectorEstimationStats online_stats(extractor.IvectorDim(),
                                            extractor.PriorOffset(),
                                            0.0);
  
  for (int32 t = 0; t < num_frames; t++) {
    online_stats.AccStats(extractor, feats.Row(t), post[t]);
  }
  
  Vector<double> ivector1(ivector_dim), ivector2(ivector_dim);

  extractor.GetIvectorDistribution(utt_stats, &ivector1, NULL);

  int32 num_cg_iters = -1;  // for testing purposes, compute it exactly.
  online_stats.GetIvector(num_cg_iters, &ivector2);

  KALDI_LOG << "ivector1 = " << ivector1;
  KALDI_LOG << "ivector2 = " << ivector2;

  // objf change vs. default iVector.  note, here I'm using objf
  // and auxf pretty much interchangeably :-(
  double objf_change2 = online_stats.ObjfChange(ivector2) *
      utt_stats.NumFrames();

  Vector<double> ivector_baseline(ivector_dim);
  ivector_baseline(0) = extractor.PriorOffset();
  double objf_change1 = extractor.GetAuxf(utt_stats, ivector1) -
      extractor.GetAuxf(utt_stats, ivector_baseline);
  KALDI_LOG << "objf_change1 = " << objf_change1
            << ", objf_change2 = " << objf_change2;
  
  KALDI_ASSERT(ivector1.ApproxEqual(ivector2));
}

TestIvectorExtractorIO()

void kaldi::TestIvectorExtractorIO

(

const IvectorExtractor &

extractor

)

Definition at line 28 of file ivector-extractor-test.cc.

References KALDI_ASSERT, Rand(), IvectorExtractor::Read(), and IvectorExtractor::Write().

Referenced by UnitTestIvectorExtractor().

                                                               {
  std::ostringstream ostr;
  bool binary = (Rand() % 2 == 0);
  extractor.Write(ostr, binary);
  std::istringstream istr(ostr.str());
  IvectorExtractor extractor2;
  extractor2.Read(istr, binary);
  std::ostringstream ostr2;
  extractor2.Write(ostr2, binary);
  KALDI_ASSERT(ostr.str() == ostr2.str());
}

TestIvectorExtractorStatsIO()

void kaldi::TestIvectorExtractorStatsIO

(

IvectorExtractorStats &

stats

)

Definition at line 39 of file ivector-extractor-test.cc.

References IvectorExtractorStats::Add(), KALDI_ASSERT, Rand(), IvectorExtractorStats::Read(), and IvectorExtractorStats::Write().

Referenced by UnitTestIvectorExtractor().

                                                               {
  std::ostringstream ostr;
  bool binary = (Rand() % 2 == 0);
  stats.Write(ostr, binary);
  std::istringstream istr(ostr.str());
  IvectorExtractorStats stats2;
  stats2.Read(istr, binary);
  std::ostringstream ostr2;
  stats2.Write(ostr2, binary);
  
  if (binary) {
    // this was failing in text mode, due to differences like
    // 8.2244e+06 vs  8.22440e+06
    KALDI_ASSERT(ostr.str() == ostr2.str());
  }
  
  { // Test I/O of IvectorExtractorStats and that it works identically with the "add"
    // mechanism.  We only test this with binary == true; otherwise it's not
    // identical due to limited precision.
    std::ostringstream ostr;
    bool binary = true;
    stats.Write(ostr, binary);
    IvectorExtractorStats stats2;
    {
      std::istringstream istr(ostr.str());
      stats2.Read(istr, binary);
    }
    {
      std::istringstream istr(ostr.str());
      stats2.Read(istr, binary, true); // add to existing.
    }
    IvectorExtractorStats stats3(stats);
    stats3.Add(stats);
    
    std::ostringstream ostr2;
    stats2.Write(ostr2, false);

    std::ostringstream ostr3;
    stats3.Write(ostr3, false);

    //if (binary) {
    //  KALDI_ASSERT(ostr2.str() == ostr3.str());
    //}
  }
}

TestLatticeTable()

void kaldi::TestLatticeTable

(

bool

binary

)

Definition at line 99 of file kaldi-lattice-test.cc.

References TableWriter< Holder >::Close(), rnnlm::i, KALDI_ASSERT, RandLattice(), RandomAccessTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                   {
  LatticeWriter writer(binary ? "ark:tmpf" : "ark,t:tmpf");
  int N = 10;
  std::vector<Lattice*> lat_vec(N);
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    Lattice *fst = RandLattice();
    lat_vec[i] = fst;
    writer.Write(key, *fst);
  }
  writer.Close();

  RandomAccessLatticeReader reader("ark:tmpf");  
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    const Lattice &fst = reader.Value(key);
    KALDI_ASSERT(fst::Equal(fst, *(lat_vec[i])));
    delete lat_vec[i];
  }
}

TestLatticeTableCross()

void kaldi::TestLatticeTableCross

(

bool

binary

)

Definition at line 128 of file kaldi-lattice-test.cc.

References TableWriter< Holder >::Close(), fst::ConvertLattice(), rnnlm::i, KALDI_ASSERT, Rand(), RandLattice(), RandomAccessTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                        {
  LatticeWriter writer(binary ? "ark:tmpf" : "ark,t:tmpf");
  int N = 10;
  std::vector<Lattice*> lat_vec(N);
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    Lattice *fst = RandLattice();
    lat_vec[i] = fst;
    writer.Write(key, *fst);
  }
  writer.Close();

  RandomAccessCompactLatticeReader reader("ark:tmpf");  
  for (int i = 0; i < N; i++) {
    char buf[2];
    buf[0] = '0' + i;
    buf[1] = '\0';
    std::string key = "key" + std::string(buf);
    const CompactLattice &fst = reader.Value(key);
    Lattice fst2;
    ConvertLattice(fst, &fst2);
    KALDI_ASSERT(fst::RandEquivalent(fst2, *(lat_vec[i]), 5, 0.01, Rand(), 10));
    delete lat_vec[i];
  }
}

TestLevenshteinAlignment()

void kaldi::TestLevenshteinAlignment

(

)

Definition at line 231 of file edit-distance-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, LevenshteinAlignment(), LevenshteinEditDistance(), and Rand().

Referenced by main().

                                {
  for (size_t i = 0; i < 100; i++) {
    size_t a_sz = Rand() % 5, b_sz = Rand() % 5;
    std::vector<int32> a, b;
    for (size_t j = 0; j < a_sz; j++) a.push_back(Rand() % 10);
    for (size_t j = 0; j < b_sz; j++) b.push_back(Rand() % 10);
    int32 eps_sym = -1;
    std::vector<std::pair<int32, int32> > ans;

    int32 e1 = LevenshteinEditDistance(a, b),
        e2 = LevenshteinAlignment(a, b, eps_sym, &ans);
    KALDI_ASSERT(e1 == e2);

    std::vector<int32> a2, b2;
    for (size_t i = 0; i < ans.size(); i++) {
      if (ans[i].first != eps_sym) a2.push_back(ans[i].first);
      if (ans[i].second != eps_sym) b2.push_back(ans[i].second);
    }
    KALDI_ASSERT(a == a2);
    KALDI_ASSERT(b == b2);
  }
}

TestLocateSymbolRange()

void kaldi::TestLocateSymbolRange

(

)

Definition at line 52 of file kaldi-error-test.cc.

References VerifySymbolRange().

Referenced by main().

                             {
  VerifySymbolRange("", false, "");
  VerifySymbolRange(
      R"TRACE(./kaldi-error-test(_ZN5kaldi13UnitTestErrorEv+0xb) [0x804965d])TRACE",
      true, "_ZN5kaldi13UnitTestErrorEv");
  // It is ok thread_start is not found because it is a C symbol.
  VerifySymbolRange(
      R"TRACE(31  libsystem_pthread.dylib             0x00007fff6fe4e40d thread_start + 13)TRACE",
      false, "");
  VerifySymbolRange(
      R"TRACE(0 server 0x000000010f67614d _ZNK5kaldi13MessageLogger10LogMessageEv + 813)TRACE",
      true, "_ZNK5kaldi13MessageLogger10LogMessageEv");
  VerifySymbolRange(
      R"TRACE(29  libsystem_pthread.dylib             0x00007fff6fe4f2eb _pthread_body + 126)TRACE",
      true, "_pthread_body");
}

TestMergePairVectorSumming()

void kaldi::TestMergePairVectorSumming

(

)

Definition at line 220 of file stl-utils-test.cc.

References rnnlm::i, IsSorted(), KALDI_ASSERT, MergePairVectorSumming(), and Rand().

Referenced by main().

                                  {
  for (int p = 0; p < 100; p++) {
    std::vector<std::pair<int32, int16> > v;
    std::map<int32, int16> m;
    int sz = Rand() % 10;
    for (size_t i = 0; i < sz; i++) {
      int32 key = Rand() % 10;
      int16 val = (Rand() % 5) - 2;
      v.push_back(std::make_pair(key, val));
      if (m.count(key) == 0) m[key] = val;
      else
        m[key] += val;
    }
    MergePairVectorSumming(&v);
    KALDI_ASSERT(IsSorted(v));
    for (size_t i = 0; i < v.size(); i++) {
      KALDI_ASSERT(v[i].second == m[v[i].first]);
      KALDI_ASSERT(v[i].second != 0.0);
      if (i > 0) KALDI_ASSERT(v[i].first > v[i-1].first);
    }
    for (std::map<int32, int16>::const_iterator iter = m.begin();
         iter != m.end(); ++iter) {
      if (iter->second != 0) {
        size_t i;
        for (i = 0; i < v.size(); i++)
          if (v[i].first == iter->first) break;
        KALDI_ASSERT(i != v.size());  // Or we didn't find this
        // key in v.
      }
    }
  }
}

TestMinimizeCompactLattice()

void kaldi::TestMinimizeCompactLattice

(

)

Definition at line 47 of file minimize-lattice-test.cc.

References KALDI_ASSERT, fst::MinimizeCompactLattice(), fst::PushCompactLatticeStrings(), fst::PushCompactLatticeWeights(), Rand(), and RandDeterministicCompactLattice().

Referenced by main().

                                  {
  CompactLattice *clat = RandDeterministicCompactLattice();
  CompactLattice clat2(*clat);
  BaseFloat delta = (Rand() % 2 == 0 ? 1.0 : 1.0e-05);

  // Minimization will only work well on determinized and pushed lattices.
  PushCompactLatticeStrings(&clat2);
  PushCompactLatticeWeights(&clat2);
  
  MinimizeCompactLattice(&clat2, delta);
  KALDI_ASSERT(fst::RandEquivalent(*clat, clat2, 5, delta, Rand(), 10));
  
  delete clat;
}

TestMonophoneContextDependency()

void kaldi::TestMonophoneContextDependency

(

)

Definition at line 56 of file context-dep-test.cc.

References CopySetToVector(), ContextDependency::GetPdfInfo(), rnnlm::i, KALDI_ASSERT, MonophoneContextDependency(), and Rand().

Referenced by main().

                                      {
  std::set<int32> phones_set;
  for (size_t i = 1; i <= 20; i++) phones_set.insert(1 + Rand() % 30);
  std::vector<int32> phones;
  CopySetToVector(phones_set, &phones);
  std::vector<int32> phone2num_classes(1 + *std::max_element(phones.begin(), phones.end()));
  for (size_t i = 0; i < phones.size(); i++)
    phone2num_classes[phones[i]] = 3;
  ContextDependency *cd = MonophoneContextDependency(phones,
                                                     phone2num_classes);

  std::vector<std::vector<std::pair<int32, int32> > >  pdf_info;
  cd->GetPdfInfo(phones, phone2num_classes, &pdf_info);
  KALDI_ASSERT(pdf_info.size() == phones.size() * 3 &&
       pdf_info[Rand() % pdf_info.size()].size() == 1);
  delete cd;
}

TestNan()

void kaldi::TestNan

(

)

Definition at line 236 of file text-utils-test.cc.

References ConvertStringToReal(), rnnlm::d, and KALDI_ASSERT.

               {
  Real d;
  KALDI_ASSERT(ConvertStringToReal(std::to_string(sqrt(-1)), &d) && d != d);
}

TestObjfMinus()

static void kaldi::TestObjfMinus ( )

static

Definition at line 107 of file cluster-utils-test.cc.

References AssertEqual(), and ScalarClusterable::Objf().

Referenced by main().

                            {
  ScalarClusterable a(1.0), b(2.5);
  AssertEqual(a.Objf(), 0.0);
  AssertEqual(b.Objf(), 0.0);
  a.Add(b);
  AssertEqual(a.ObjfMinus(b), 0.0);
  a.Add(b);
  AssertEqual(a.ObjfMinus(b), -0.5 * (1.0-2.5)*(1.0-2.5));
}

TestObjfPlus()

static void kaldi::TestObjfPlus ( )

static

Definition at line 95 of file cluster-utils-test.cc.

References AssertEqual(), KALDI_LOG, and ScalarClusterable::Objf().

Referenced by main().

                           {
  ScalarClusterable a(1.0), b(2.5);
  AssertEqual(a.Objf(), (BaseFloat)0.0);
  AssertEqual(b.Objf(), (BaseFloat)0.0);
  AssertEqual( a.ObjfPlus(b), -0.5 * (1.0-2.5)*(1.0-2.5));  // 0.5 because half-distance, squared = 1/4, times two points...
  KALDI_LOG << "Non-binary Output:";
  a.Write(std::cerr, false);
  std::cerr << "\nBinary Output:\n";
  a.Write(std::cerr, true);
  std::cerr << "\n";
}

TestOnlineAppendFeature()

void kaldi::TestOnlineAppendFeature

(

)

Definition at line 290 of file online-feature-test.cc.

References OnlineGenericBaseFeature< C >::AcceptWaveform(), OfflineFeatureTpl< F >::Compute(), WaveData::Data(), FrameExtractionOptions::dither, MfccOptions::frame_opts, PlpOptions::frame_opts, GetOutput(), PlpOptions::htk_compat, rnnlm::i, OnlineGenericBaseFeature< C >::InputFinished(), rnnlm::j, KALDI_ASSERT, MelBanksOptions::low_freq, PlpOptions::mel_opts, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), FrameExtractionOptions::preemph_coeff, RandomSplit(), WaveData::Read(), FrameExtractionOptions::remove_dc_offset, FrameExtractionOptions::round_to_power_of_two, FrameExtractionOptions::samp_freq, WaveData::SampFreq(), PlpOptions::use_energy, and FrameExtractionOptions::window_type.

Referenced by main().

                               {
  std::ifstream is("../feat/test_data/test.wav", std::ios_base::binary);
  WaveData wave;
  wave.Read(is);
  KALDI_ASSERT(wave.Data().NumRows() == 1);
  SubVector<BaseFloat> waveform(wave.Data(), 0);

  // the parametrization object for 1st stream mfcc feature
  MfccOptions mfcc_op;
  mfcc_op.frame_opts.dither = 0.0;
  mfcc_op.frame_opts.preemph_coeff = 0.0;
  mfcc_op.frame_opts.window_type = "hamming";
  mfcc_op.frame_opts.remove_dc_offset = false;
  mfcc_op.frame_opts.round_to_power_of_two = true;
  mfcc_op.frame_opts.samp_freq = wave.SampFreq();
  mfcc_op.mel_opts.low_freq = 0.0;
  mfcc_op.htk_compat = false;
  mfcc_op.use_energy = false;  // C0 not energy.
  Mfcc mfcc(mfcc_op);

  // compute mfcc offline
  Matrix<BaseFloat> mfcc_feats;
  mfcc.Compute(waveform, 1.0, &mfcc_feats);  // vtln not supported

  // the parametrization object for 2nd stream plp feature
  PlpOptions plp_op;
  plp_op.frame_opts.dither = 0.0;
  plp_op.frame_opts.preemph_coeff = 0.0;
  plp_op.frame_opts.window_type = "hamming";
  plp_op.frame_opts.remove_dc_offset = false;
  plp_op.frame_opts.round_to_power_of_two = true;
  plp_op.frame_opts.samp_freq = wave.SampFreq();
  plp_op.mel_opts.low_freq = 0.0;
  plp_op.htk_compat = false;
  plp_op.use_energy = false;  // C0 not energy.
  Plp plp(plp_op);

  // compute plp offline
  Matrix<BaseFloat> plp_feats;
  plp.Compute(waveform, 1.0, &plp_feats);  // vtln not supported

  // compare
  // The test waveform is about 1.44s long, so
  // we try to break it into from 5 pieces to 9(not essential to do so)
  for (int32 num_piece = 5; num_piece < 10; num_piece++) {
    OnlineMfcc online_mfcc(mfcc_op);
    OnlinePlp online_plp(plp_op);
    OnlineAppendFeature online_mfcc_plp(&online_mfcc, &online_plp);

    std::vector<int32> piece_length(num_piece);
    bool ret = RandomSplit(waveform.Dim(), &piece_length, num_piece);
    KALDI_ASSERT(ret);
    int32 offset_start = 0;
    for (int32 i = 0; i < num_piece; i++) {
      Vector<BaseFloat> wave_piece(
        waveform.Range(offset_start, piece_length[i]));
      online_mfcc.AcceptWaveform(wave.SampFreq(), wave_piece);
      online_plp.AcceptWaveform(wave.SampFreq(), wave_piece);
      offset_start += piece_length[i];
    }
    online_mfcc.InputFinished();
    online_plp.InputFinished();

    Matrix<BaseFloat> online_mfcc_plp_feats;
    GetOutput(&online_mfcc_plp, &online_mfcc_plp_feats);

    // compare mfcc_feats & plp_features with online_mfcc_plp_feats
    KALDI_ASSERT(mfcc_feats.NumRows() == online_mfcc_plp_feats.NumRows()
      && plp_feats.NumRows() == online_mfcc_plp_feats.NumRows()
      && mfcc_feats.NumCols() + plp_feats.NumCols()
         == online_mfcc_plp_feats.NumCols());
    for (MatrixIndexT i = 0; i < online_mfcc_plp_feats.NumRows(); i++) {
      for (MatrixIndexT j = 0; j < mfcc_feats.NumCols(); j++) {
        KALDI_ASSERT(std::abs(mfcc_feats(i, j) - online_mfcc_plp_feats(i, j))
          < 0.0001*std::max(1.0, static_cast<double>(std::abs(mfcc_feats(i, j))
                                    + std::abs(online_mfcc_plp_feats(i, j)))));
      }
      for (MatrixIndexT k = 0; k < plp_feats.NumCols(); k++) {
        KALDI_ASSERT(
          std::abs(plp_feats(i, k) -
            online_mfcc_plp_feats(i, mfcc_feats.NumCols() + k))
          < 0.0001*std::max(1.0, static_cast<double>(std::abs(plp_feats(i, k))
            +std::abs(online_mfcc_plp_feats(i, mfcc_feats.NumCols() + k)))));
      }
    }
  }
}

TestOnlineCmnInput()

void kaldi::TestOnlineCmnInput

(

)

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

References VectorBase< Real >::AddRowSumMat(), VectorBase< Real >::AddVec(), MatrixBase< Real >::ApproxEqual(), OnlineCacheInput::GetCachedData(), GetOutput(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Row(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::SetZero().

Referenced by main().

                          { // We're also testing OnlineCacheInput here.
  int32 dim = 2 + Rand() % 5; // dimension of features.
  int32 num_frames = 10 + Rand() % 10;
  
  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixInput matrix_input(input_feats);
  int32 cmn_window = 10 + Rand() % 20;
  int32 min_window = 1 + Rand() % (cmn_window - 1);
  if (Rand() % 3 == 0) min_window = cmn_window;
  
  OnlineCmnInput cmn_input(&matrix_input, cmn_window,
                           min_window);
  OnlineCacheInput cache_input(&cmn_input);
  
  Matrix<BaseFloat> output_feats1;
  GetOutput(&cache_input, &output_feats1);
  
  Matrix<BaseFloat> output_feats2(input_feats);
  for (int32 i = 0; i < output_feats2.NumRows(); i++) {
    SubVector<BaseFloat> this_row(output_feats2, i);
    if (i == 0 && min_window == 0) this_row.SetZero();
    else if (i < min_window) {
      int32 window_nframes = std::min(min_window, input_feats.NumRows());
      Vector<BaseFloat> this_sum(dim);
      SubMatrix<BaseFloat> this_block(input_feats, 0, window_nframes,
                                      0, dim);
      this_sum.AddRowSumMat(1.0, this_block, 0.0);
      this_row.AddVec(-1.0 / window_nframes, this_sum);
    } else {
      int32 window_nframes = std::min(i, cmn_window);
      Vector<BaseFloat> this_sum(dim);
      SubMatrix<BaseFloat> this_block(input_feats, i - window_nframes, window_nframes,
                                      0, dim);
      this_sum.AddRowSumMat(1.0, this_block, 0.0);
      this_row.AddVec(-1.0 / window_nframes, this_sum);
    }
  }
  KALDI_ASSERT(output_feats1.NumRows() == output_feats2.NumRows());
  for (int32 i = 0; i < output_feats2.NumRows(); i++) {
    if (!output_feats1.Row(i).ApproxEqual(output_feats2.Row(i))) {
      KALDI_ERR << "Rows differ " << i << ", " << input_feats.Row(i) << output_feats1.Row(i)
                << output_feats2.Row(i);
    }
  }
  KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
  Matrix<BaseFloat> output_feats3;
  cache_input.GetCachedData(&output_feats3);
  KALDI_ASSERT(output_feats1.ApproxEqual(output_feats3));
}

TestOnlineDeltaFeature()

void kaldi::TestOnlineDeltaFeature

(

)

Definition at line 97 of file online-feature-test.cc.

References MatrixBase< Real >::ApproxEqual(), ComputeDeltas(), GetOutput(), KALDI_ASSERT, DeltaFeaturesOptions::order, and DeltaFeaturesOptions::window.

Referenced by main().

                              {
  int32 dim = 2 + rand() % 5;  // dimension of features.
  int32 num_frames = 100 + rand() % 100;
  DeltaFeaturesOptions opts;
  opts.order = rand() % 3;
  opts.window = 1 + rand() % 3;

  int32 output_dim = dim * (1 + opts.order);

  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixFeature matrix_feats(input_feats);
  OnlineDeltaFeature delta_feats(opts, &matrix_feats);

  Matrix<BaseFloat> output_feats1;
  GetOutput(&delta_feats, &output_feats1);

  Matrix<BaseFloat> output_feats2(num_frames, output_dim);
  ComputeDeltas(opts, input_feats, &output_feats2);

  KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
}

TestOnlineDeltaInput()

void kaldi::TestOnlineDeltaInput

(

)

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

References MatrixBase< Real >::ApproxEqual(), ComputeDeltas(), GetOutput(), KALDI_ASSERT, DeltaFeaturesOptions::order, Rand(), and DeltaFeaturesOptions::window.

Referenced by main().

                            {
  int32 dim = 2 + Rand() % 5; // dimension of features.
  int32 num_frames = 100 + Rand() % 100;
  DeltaFeaturesOptions opts;
  opts.order = Rand() % 3;
  opts.window = 1 + Rand() % 3;

  int32 output_dim = dim * (1 + opts.order);
  
  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();
  
  OnlineMatrixInput matrix_input(input_feats);
  OnlineDeltaInput delta_input(opts, &matrix_input);

  Matrix<BaseFloat> output_feats1;
  GetOutput(&delta_input, &output_feats1);

  Matrix<BaseFloat> output_feats2(num_frames, output_dim);
  ComputeDeltas(opts, input_feats, &output_feats2);

  KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
}

TestOnlineFeatureMatrix()

void kaldi::TestOnlineFeatureMatrix

(

)

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

References OnlineFeatureMatrix::GetFrame(), OnlineFeatureMatrix::IsValidFrame(), KALDI_ASSERT, OnlineFeatureMatrixOptions::num_tries, Rand(), MatrixBase< Real >::Row(), and MatrixBase< Real >::SetRandn().

Referenced by main().

                               {
  int32 dim = 2 + Rand() % 5; // dimension of features.
  int32 num_frames = 100 + Rand() % 100;

  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixInput matrix_input(input_feats);
  OnlineFeatureMatrixOptions opts;
  opts.num_tries = 100; // makes it very unlikely we'll get that many timeouts.
  OnlineFeatureMatrix online_feature_matrix(opts, &matrix_input);

  for (int32 frame = 0; frame < num_frames; frame++) {
    KALDI_ASSERT(online_feature_matrix.IsValidFrame(frame));
    KALDI_ASSERT(online_feature_matrix.GetFrame(frame).ApproxEqual(input_feats.Row(frame)));
  }
  KALDI_ASSERT(!online_feature_matrix.IsValidFrame(num_frames));
}

TestOnlineLdaInput()

void kaldi::TestOnlineLdaInput

(

)

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

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::ApproxEqual(), VectorBase< Real >::CopyColFromMat(), GetOutput(), KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::SetRandn(), and SpliceFrames().

Referenced by main().

                          {
  int32 dim = 2 + Rand() % 5; // dimension of features.
  int32 num_frames = 100 + Rand() % 100;
  int32 left_context = Rand() % 3, right_context = Rand() % 3;
  bool have_offset = (Rand() % 2 == 0);
  int32 lda_input_dim = (dim * (left_context + 1 + right_context)),
      lda_output_dim = 1 + Rand() % 5; // this can even be more than
       // the input dim, the class doesn't care.
  
  Matrix<BaseFloat> transform(lda_output_dim, lda_input_dim +
                              (have_offset ? 1 : 0));
  transform.SetRandn();
  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixInput matrix_input(input_feats);
  OnlineLdaInput lda_input(&matrix_input, transform, left_context, right_context);

  Matrix<BaseFloat> output_feats1;
  GetOutput(&lda_input, &output_feats1);
  Matrix<BaseFloat> temp_feats;
  SpliceFrames(input_feats, left_context, right_context, &temp_feats);
  Matrix<BaseFloat> output_feats2(temp_feats.NumRows(), transform.NumRows());
  if (!have_offset) {
    output_feats2.AddMatMat(1.0, temp_feats, kNoTrans, transform, kTrans, 0.0);
  } else {
    SubMatrix<BaseFloat> linear_part(transform, 0, transform.NumRows(),
                                     0, transform.NumCols() - 1);
    output_feats2.AddMatMat(1.0, temp_feats, kNoTrans, linear_part, kTrans, 0.0);
    Vector<BaseFloat> offset(transform.NumRows());
    offset.CopyColFromMat(transform, transform.NumCols() - 1);
    output_feats2.AddVecToRows(1.0, offset);
  }
  KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
}

TestOnlineMatrixCacheFeature()

void kaldi::TestOnlineMatrixCacheFeature

(

)

Definition at line 83 of file online-feature-test.cc.

References AssertEqual(), GetOutput(), and MatrixBase< Real >::SetRandn().

Referenced by main().

                                    {
  int32 dim = 2 + rand() % 5;  // dimension of features.
  int32 num_frames = 100 + rand() % 100;

  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixFeature matrix_feats(input_feats);

  Matrix<BaseFloat> output_feats;
  GetOutput(&matrix_feats, &output_feats);
  AssertEqual(input_feats, output_feats);
}

TestOnlineMatrixInput()

void kaldi::TestOnlineMatrixInput

(

)

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

References AssertEqual(), GetOutput(), Rand(), and MatrixBase< Real >::SetRandn().

Referenced by main().

                             {
  int32 dim = 2 + Rand() % 5; // dimension of features.
  int32 num_frames = 100 + Rand() % 100;

  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixInput matrix_input(input_feats);
  
  Matrix<BaseFloat> output_feats;
  GetOutput(&matrix_input, &output_feats);
  AssertEqual(input_feats, output_feats);
}

TestOnlineMfcc()

void kaldi::TestOnlineMfcc

(

)

Definition at line 146 of file online-feature-test.cc.

References OnlineGenericBaseFeature< C >::AcceptWaveform(), AssertEqual(), OfflineFeatureTpl< F >::Compute(), WaveData::Data(), FrameExtractionOptions::dither, MfccOptions::frame_opts, GetOutput(), rnnlm::i, OnlineGenericBaseFeature< C >::InputFinished(), KALDI_ASSERT, MatrixBase< Real >::NumRows(), RandInt(), RandomSplit(), WaveData::Read(), and WaveData::SampFreq().

Referenced by main().

                      {
  std::ifstream is("../feat/test_data/test.wav", std::ios_base::binary);
  WaveData wave;
  wave.Read(is);
  KALDI_ASSERT(wave.Data().NumRows() == 1);
  SubVector<BaseFloat> waveform(wave.Data(), 0);

  // the parametrization object
  MfccOptions op;
  op.frame_opts.dither = 0.0;
  op.frame_opts.preemph_coeff = 0.0;
  op.frame_opts.window_type = "hamming";
  op.frame_opts.remove_dc_offset = false;
  op.frame_opts.round_to_power_of_two = true;
  op.frame_opts.samp_freq = wave.SampFreq();
  op.mel_opts.low_freq = 0.0;
  op.htk_compat = false;
  op.use_energy = false;  // C0 not energy.
  if (RandInt(0, 1) == 0)
    op.frame_opts.snip_edges = false;
  Mfcc mfcc(op);

  // compute mfcc offline
  Matrix<BaseFloat> mfcc_feats;
  mfcc.Compute(waveform, 1.0, &mfcc_feats);  // vtln not supported

  // compare
  // The test waveform is about 1.44s long, so
  // we try to break it into from 5 pieces to 9(not essential to do so)
  for (int32 num_piece = 5; num_piece < 10; num_piece++) {
    OnlineMfcc online_mfcc(op);
    std::vector<int32> piece_length(num_piece, 0);

    bool ret = RandomSplit(waveform.Dim(), &piece_length, num_piece);
    KALDI_ASSERT(ret);

    int32 offset_start = 0;
    for (int32 i = 0; i < num_piece; i++) {
      Vector<BaseFloat> wave_piece(
        waveform.Range(offset_start, piece_length[i]));
      online_mfcc.AcceptWaveform(wave.SampFreq(), wave_piece);
      offset_start += piece_length[i];
    }
    online_mfcc.InputFinished();

    Matrix<BaseFloat> online_mfcc_feats;
    GetOutput(&online_mfcc, &online_mfcc_feats);

    AssertEqual(mfcc_feats, online_mfcc_feats);
  }
}

TestOnlinePlp()

void kaldi::TestOnlinePlp

(

)

Definition at line 198 of file online-feature-test.cc.

References OnlineGenericBaseFeature< C >::AcceptWaveform(), AssertEqual(), OfflineFeatureTpl< F >::Compute(), WaveData::Data(), FrameExtractionOptions::dither, PlpOptions::frame_opts, GetOutput(), rnnlm::i, OnlineGenericBaseFeature< C >::InputFinished(), KALDI_ASSERT, MatrixBase< Real >::NumRows(), RandomSplit(), WaveData::Read(), and WaveData::SampFreq().

Referenced by main().

                     {
  std::ifstream is("../feat/test_data/test.wav", std::ios_base::binary);
  WaveData wave;
  wave.Read(is);
  KALDI_ASSERT(wave.Data().NumRows() == 1);
  SubVector<BaseFloat> waveform(wave.Data(), 0);

  // the parametrization object
  PlpOptions op;
  op.frame_opts.dither = 0.0;
  op.frame_opts.preemph_coeff = 0.0;
  op.frame_opts.window_type = "hamming";
  op.frame_opts.remove_dc_offset = false;
  op.frame_opts.round_to_power_of_two = true;
  op.frame_opts.samp_freq = wave.SampFreq();
  op.mel_opts.low_freq = 0.0;
  op.htk_compat = false;
  op.use_energy = false;  // C0 not energy.
  Plp plp(op);

  // compute plp offline
  Matrix<BaseFloat> plp_feats;
  plp.Compute(waveform, 1.0, &plp_feats);  // vtln not supported

  // compare
  // The test waveform is about 1.44s long, so
  // we try to break it into from 5 pieces to 9(not essential to do so)
  for (int32 num_piece = 5; num_piece < 10; num_piece++) {
    OnlinePlp online_plp(op);
    std::vector<int32> piece_length(num_piece);
    bool ret = RandomSplit(waveform.Dim(), &piece_length, num_piece);
    KALDI_ASSERT(ret);

    int32 offset_start = 0;
    for (int32 i = 0; i < num_piece; i++) {
      Vector<BaseFloat> wave_piece(
        waveform.Range(offset_start, piece_length[i]));
      online_plp.AcceptWaveform(wave.SampFreq(), wave_piece);
      offset_start += piece_length[i];
    }
    online_plp.InputFinished();

    Matrix<BaseFloat> online_plp_feats;
    GetOutput(&online_plp, &online_plp_feats);

    AssertEqual(plp_feats, online_plp_feats);
  }
}

TestOnlineSpliceFrames()

void kaldi::TestOnlineSpliceFrames

(

)

Definition at line 121 of file online-feature-test.cc.

References MatrixBase< Real >::ApproxEqual(), GetOutput(), KALDI_ASSERT, OnlineSpliceOptions::left_context, OnlineSpliceOptions::right_context, and SpliceFrames().

Referenced by main().

                              {
  int32 dim = 2 + rand() % 5;  // dimension of features.
  int32 num_frames = 100 + rand() % 100;
  OnlineSpliceOptions opts;
  opts.left_context  = 1 + rand() % 4;
  opts.right_context = 1 + rand() % 4;

  int32 output_dim = dim * (1 + opts.left_context + opts.right_context);

  Matrix<BaseFloat> input_feats(num_frames, dim);
  input_feats.SetRandn();

  OnlineMatrixFeature matrix_feats(input_feats);
  OnlineSpliceFrames splice_frame(opts, &matrix_feats);

  Matrix<BaseFloat> output_feats1;
  GetOutput(&splice_frame, &output_feats1);

  Matrix<BaseFloat> output_feats2(num_frames, output_dim);
  SpliceFrames(input_feats, opts.left_context, opts.right_context,
    &output_feats2);

  KALDI_ASSERT(output_feats1.ApproxEqual(output_feats2));
}

TestOnlineTransform()

void kaldi::TestOnlineTransform

(

)

Definition at line 247 of file online-feature-test.cc.

References OnlineGenericBaseFeature< C >::AcceptWaveform(), ApplyAffineTransform(), AssertEqual(), WaveData::Data(), OnlineGenericBaseFeature< C >::Dim(), FrameExtractionOptions::dither, MfccOptions::frame_opts, GetOutput(), rnnlm::i, OnlineGenericBaseFeature< C >::InputFinished(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), WaveData::Read(), MatrixBase< Real >::Row(), WaveData::SampFreq(), and MatrixBase< Real >::SetRandn().

Referenced by main().

                           {
  std::ifstream is("../feat/test_data/test.wav", std::ios_base::binary);
  WaveData wave;
  wave.Read(is);
  KALDI_ASSERT(wave.Data().NumRows() == 1);
  SubVector<BaseFloat> waveform(wave.Data(), 0);

  // build online feature interface, take OnlineMfcc as an example
  MfccOptions op;
  op.frame_opts.dither = 0.0;
  op.frame_opts.preemph_coeff = 0.0;
  op.frame_opts.window_type = "hamming";
  op.frame_opts.remove_dc_offset = false;
  op.frame_opts.round_to_power_of_two = true;
  op.frame_opts.samp_freq = wave.SampFreq();
  op.mel_opts.low_freq = 0.0;
  op.htk_compat = false;
  op.use_energy = false;  // C0 not energy.
  OnlineMfcc online_mfcc(op);

  online_mfcc.AcceptWaveform(wave.SampFreq(), waveform);
  online_mfcc.InputFinished();
  Matrix<BaseFloat> mfcc_feats;
  GetOutput(&online_mfcc, &mfcc_feats);

  // Affine transform
  Matrix<BaseFloat> trans(online_mfcc.Dim(), online_mfcc.Dim() + 1);
  trans.SetRandn();
  OnlineTransform online_trans(trans, &online_mfcc);

  Matrix<BaseFloat> trans_feats;
  GetOutput(&online_trans, &trans_feats);

  Matrix<BaseFloat> output_feats(mfcc_feats.NumRows(), mfcc_feats.NumCols());
  for (int32 i = 0; i < mfcc_feats.NumRows(); i++) {
    Vector<BaseFloat> vec_tmp(mfcc_feats.Row(i));
    ApplyAffineTransform(trans, &vec_tmp);
    output_feats.CopyRowFromVec(vec_tmp, i);
  }

  AssertEqual(trans_feats, output_feats);
}

TestPossibleValues()

void kaldi::TestPossibleValues

(

)

Definition at line 38 of file build-tree-utils-test.cc.

References CopyMapToVector(), CopySetToVector(), rnnlm::i, rnnlm::j, KALDI_ASSERT, PossibleValues(), and RandInt().

Referenced by main().

                          {
  BuildTreeStatsType stats;
  std::map<EventKeyType, std::set<EventValueType> > all_key_vals;
  for (size_t i = 0;i < 20;i++) {
    std::map<EventKeyType, EventValueType> key_vals;
    for (size_t j = 0;j < 20;j++) {
      EventKeyType k = RandInt(-5, 10);
      EventValueType v = RandInt(0, 10);
      if (key_vals.count(k) == 0) {
        key_vals[ k ] =  v;
        all_key_vals[k].insert(v);
      }
    }
    EventType evec;
    CopyMapToVector(key_vals, &evec);
    stats.push_back(std::pair<EventType, Clusterable*>(evec, (Clusterable*)NULL));
  }
  for (std::map<EventKeyType, std::set<EventValueType> >::iterator iter = all_key_vals.begin();
      iter != all_key_vals.end(); iter++) {
    EventKeyType key = iter->first;
    std::vector<EventValueType> vals1, vals2;
    CopySetToVector(iter->second, &vals1);
    PossibleValues(key, stats, &vals2);
    if (vals1 != vals2) {
      printf("vals differ!\n");
      for (size_t i = 0;i < vals1.size();i++) std::cout << vals1[i] << " ";
      std::cout<<'\n';
      for (size_t i = 0;i < vals2.size();i++) std::cout << vals2[i] << " ";
      std::cout<<'\n';
      KALDI_ASSERT(0);
    }
  }
}

TestPosteriorIo()

void kaldi::TestPosteriorIo

(

)

Definition at line 53 of file posterior-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, RandInt(), RandUniform(), ReadPosterior(), and WritePosterior().

Referenced by main().

                       {
  int32 post_size = RandInt(0, 5);
  post_size = post_size * post_size;
  Posterior post(post_size);
  for (int32 i = 0; i < post.size(); i++) {
    int32 s = RandInt(0, 3);
    for (int32 j = 0; j < s; j++)
      post[i].push_back(std::pair<int32,BaseFloat>(
          RandInt(-10, 100), RandUniform()));
  }
  bool binary = (RandInt(0, 1) == 0);
  std::ostringstream os;
  WritePosterior(os, binary, post);
  Posterior post2;
  if (RandInt(0, 1) == 0)
    post2 = post;
  std::istringstream is(os.str());
  ReadPosterior(is, binary, &post2);
  if (binary) {
    KALDI_ASSERT(post == post2);
  } else {
    KALDI_ASSERT(post.size() == post2.size());
    for (int32 i = 0; i < post.size(); i++) {
      KALDI_ASSERT(post[i].size() == post2[i].size());
      for (int32 j = 0; j < post[i].size(); j++) {
        KALDI_ASSERT(post[i][j].first == post2[i][j].first &&
                     fabs(post[i][j].second - post2[i][j].second) < 0.01);
      }
    }
  }
}

TestPushCompactLatticeStrings()

void kaldi::TestPushCompactLatticeStrings

(

)

Definition at line 39 of file push-lattice-test.cc.

References KALDI_ASSERT, fst::PushCompactLatticeStrings(), Rand(), RandCompactLattice(), and CompactLatticeWeightTpl< WeightType, IntType >::Zero().

Referenced by main().

                                     {
  CompactLattice *clat = RandCompactLattice();
  CompactLattice clat2(*clat);
  PushCompactLatticeStrings(&clat2);
  KALDI_ASSERT(fst::RandEquivalent(*clat, clat2, 5, 0.001, Rand(), 10));
  for (CompactLatticeArc::StateId s = 0; s < clat2.NumStates(); s++) {
    if (s == 0)
      continue; // We don't check state zero, as the "leftover string" stays
                // there.
    int32 first_label = -1;
    bool ok = false;
    bool first_label_set = false;
    for (ArcIterator<CompactLattice> aiter(clat2, s); !aiter.Done();
         aiter.Next()) {
      if (aiter.Value().weight.String().size() == 0) {
        ok = true;
      } else {
        int32 this_label = aiter.Value().weight.String().front();
        if (first_label_set) {
          if (this_label != first_label) ok = true;
        } else {
          first_label = this_label;
          first_label_set = true;
        }
      }
    }
    if (clat2.Final(s) != CompactLatticeWeight::Zero()) {
      if (clat2.Final(s).String().size() == 0) ok = true;
      else {
        int32 this_label = clat2.Final(s).String().front();
        if (first_label_set && this_label != first_label) ok = true;
      }
    }
    KALDI_ASSERT(ok);
  }
  delete clat;
}

TestPushCompactLatticeWeights()

void kaldi::TestPushCompactLatticeWeights

(

)

Definition at line 77 of file push-lattice-test.cc.

References ApproxEqual(), KALDI_ASSERT, KALDI_ERR, LatticeWeightTpl< BaseFloat >::One(), fst::Plus(), fst::PushCompactLatticeWeights(), Rand(), and RandCompactLattice().

Referenced by main().

                                     {
  CompactLattice *clat = RandCompactLattice();
  CompactLattice clat2(*clat);
  PushCompactLatticeWeights(&clat2);
  KALDI_ASSERT(fst::RandEquivalent(*clat, clat2, 5, 0.001, Rand(), 10));
  for (CompactLatticeArc::StateId s = 0; s < clat2.NumStates(); s++) {
    if (s == 0)
      continue; // We don't check state zero, as the "leftover string" stays
                // there.
    LatticeWeight sum = clat2.Final(s).Weight();
    for (ArcIterator<CompactLattice> aiter(clat2, s); !aiter.Done();
         aiter.Next()) {
      sum = Plus(sum, aiter.Value().weight.Weight());
    }
    if (!ApproxEqual(sum, LatticeWeight::One())) {
      {
        fst::FstPrinter<CompactLatticeArc> printer(clat2, NULL, NULL,
                                                   NULL, true, true, "\t");
        printer.Print(&std::cerr, "<unknown>");
      }
      {
        fst::FstPrinter<CompactLatticeArc> printer(*clat, NULL, NULL,
                                                   NULL, true, true, "\t");
        printer.Print(&std::cerr, "<unknown>");
      }
      KALDI_ERR << "Bad lattice being pushed.";
    }
  }
  delete clat;
}

TestQuestionsInitRand()

void kaldi::TestQuestionsInitRand

(

)

Definition at line 640 of file build-tree-utils-test.cc.

References EventMap::Check(), CopySetToVector(), Questions::GetQuestionsOf(), Questions::HasQuestionsForKey(), rnnlm::i, QuestionsForKey::initial_questions, Questions::InitRand(), rnnlm::j, KALDI_ASSERT, KALDI_ERR, kAllKeysIntersection, kAllKeysUnion, Rand(), Questions::Read(), and Questions::Write().

Referenced by main().

                             {
  // testing Questions::InitRand() function.  Also testing I/O of Questions class.
  for (int32 p = 0;p < 10;p++) {
    std::vector<EventKeyType>  keys_all, keys_some;
    {
      std::set<EventKeyType> keys_all_set, keys_some_set;
      int32 num_all = Rand() % 3, num_some = Rand() % 3;
      for (int32 i = 0;i < num_all;i++) keys_all_set.insert(Rand() % 10);
      for (int32 i = 0;i < num_some;i++) {
        int32 k = Rand() % 10;
        if (keys_all_set.count(k) == 0) keys_some_set.insert(k);
      }
      CopySetToVector(keys_all_set, &keys_all);
      CopySetToVector(keys_some_set, &keys_some);
    }
    std::set<EventKeyType> keys_all_saw_set;
    // Now we have two distinct sets of keys keys_all and keys_some.
    // We now create the Clusterable* stuff.
    BuildTreeStatsType dummy_stats;  // dummy because the Clusterable *pointers are actually NULL.
    size_t n_stats = Rand() % 100;
    // make sure we sometimes have empty or just one stats: may find extra bugs.
    if (n_stats > 90) n_stats = 0;
    if (n_stats > 80) n_stats = 1;

    for (size_t i = 0;i < n_stats;i++) {  // Create stats...
      EventType evec;
      for (size_t j = 0;j < keys_all.size();j++) {
        evec.push_back(std::make_pair( keys_all[j], (EventValueType)(Rand() % 10)));
        keys_all_saw_set.insert(keys_all[j]);
      }
      for (size_t j = 0;j < keys_some.size();j++)
        if (Rand() % 2 == 0) {  // randomly w.p. 1/2
          evec.push_back(std::make_pair( keys_some[j], (EventValueType)(Rand() % 10)));
          keys_all_saw_set.insert(keys_some[j]);
        }
      std::sort(evec.begin(), evec.end());  // sorts on keys.
      EventMap::Check(evec);
      dummy_stats.push_back(std::make_pair(evec, (Clusterable*)NULL));
    }
    Questions qo;  // all default.
    bool intersection = (p%2 == 0);
    int32 num_quest = Rand() % 10, num_iters = rand () % 5;
    qo.InitRand(dummy_stats, num_quest, num_iters, intersection ? kAllKeysIntersection : kAllKeysUnion);

    for (int i = 0; i < 2; i++) {
      // Here, test I/O of questions class.
      bool binary = (i == 0);
      std::ostringstream oss;
      qo.Write(oss, binary);

      std::istringstream iss(oss.str());
      Questions qo2;
      qo2.Read(iss, binary);

      std::ostringstream oss2;
      qo2.Write(oss2, binary);

      if (oss.str() != oss2.str()) {
        KALDI_ERR << "Questions I/O failure: " << oss.str() << " vs. " << oss2.str();
      }
    }

    if (n_stats > 0) {
      if (p < 2) {
        for (size_t i = 0;i < keys_all.size();i++) {
          KALDI_ASSERT(qo.HasQuestionsForKey(keys_all[i]));
          const QuestionsForKey &opts = qo.GetQuestionsOf(keys_all[i]);
          std::cout << "num-quest: "<< opts.initial_questions.size() << '\n';
          for (size_t j = 0;j < opts.initial_questions.size();j++) {
            for (size_t k = 0;k < opts.initial_questions[j].size();k++)
              std::cout << opts.initial_questions[j][k] <<" ";
            std::cout << '\n';
          }
        }
      }
      if (intersection) {
        for (size_t i = 0;i < keys_all.size();i++) {
          KALDI_ASSERT(qo.HasQuestionsForKey(keys_all[i]));
          qo.GetQuestionsOf(keys_all[i]);
        }
      } else {  // union: expect to see all keys that were in the data.
        for (std::set<int32>::iterator iter = keys_all_saw_set.begin(); iter != keys_all_saw_set.end(); iter++) {
          KALDI_ASSERT(qo.HasQuestionsForKey(*iter));
        }
      }
    }
  }
}

TestRecyclingVector()

void kaldi::TestRecyclingVector

(

)

Definition at line 378 of file online-feature-test.cc.

References RecyclingVector::At(), rnnlm::i, KALDI_ASSERT, RecyclingVector::PushBack(), VectorBase< Real >::Set(), and RecyclingVector::Size().

Referenced by main().

                           {
  RecyclingVector full_vec;
  RecyclingVector shrinking_vec(10);
  for (int i = 0; i != 100; ++i) {
    Vector <BaseFloat> data(1);
    data.Set(i);
    full_vec.PushBack(new Vector<BaseFloat>(data));
    shrinking_vec.PushBack(new Vector<BaseFloat>(data));
  }
  KALDI_ASSERT(full_vec.Size() == 100);
  KALDI_ASSERT(shrinking_vec.Size() == 100);

  // full_vec should contain everything
  for (int i = 0; i != 100; ++i) {
    Vector <BaseFloat> *data = full_vec.At(i);
    KALDI_ASSERT(data != nullptr);
    KALDI_ASSERT((*data)(0) == static_cast<BaseFloat>(i));
  }

  // shrinking_vec may throw an exception for the first 90 elements
  int caught_exceptions = 0;
  for (int i = 0; i != 90; ++i) {
    try {
      shrinking_vec.At(i);
    } catch (const std::runtime_error &) {
      ++caught_exceptions;
    }
  }
  // it may actually store a bit more elements for performance efficiency considerations
  KALDI_ASSERT(caught_exceptions >= 80);

  // shrinking_vec should contain the last 10 elements
  for (int i = 90; i != 100; ++i) {
    Vector <BaseFloat> *data = shrinking_vec.At(i);
    KALDI_ASSERT(data != nullptr);
    KALDI_ASSERT((*data)(0) == static_cast<BaseFloat>(i));
  }
}

TestRefineClusters()

static void kaldi::TestRefineClusters ( )

static

Definition at line 286 of file cluster-utils-test.cc.

References AssertEqual(), DeletePointers(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, rnnlm::n, RefineClustersOptions::num_iters, Rand(), RandUniform(), RefineClusters(), SumClusterableObjf(), and RefineClustersOptions::top_n.

Referenced by main().

                                 {
  for (size_t n = 0;n < 4;n++) {
    // Test it by creating a random clustering and verifying that it does not make it worse, and
    // if done with the optimal parameters, makes it optimal.
    size_t n_clust = Rand() % 10;
    std::vector<Clusterable*> points;
    for (size_t j = 0;j < n_clust;j++) {
      size_t n_points = 1 + Rand() % 5;
      BaseFloat clust_center  = (BaseFloat)j;
      for (size_t k = 0;k < n_points;k++) points.push_back(new ScalarClusterable(clust_center + RandUniform()*0.01));
    }
    std::vector<Clusterable*> clusters(n_clust);
    std::vector<int32> assignments(points.size());
    for (size_t i = 0;i < clusters.size();i++) clusters[i] = new ScalarClusterable();
    // assign each point to a random cluster.
    for (size_t i = 0;i < points.size();i++) {
      assignments[i] = Rand() % n_clust;
      clusters[assignments[i]]->Add(*(points[i]));
    }
    BaseFloat points_objf = SumClusterableObjf(points),
        clust_objf_before = SumClusterableObjf(clusters),
        clust_objf_after;

    KALDI_ASSERT(points_objf >= clust_objf_before -
                 (std::abs(points_objf)+std::abs(clust_objf_before))*0.001);

    RefineClustersOptions cfg;
    cfg.num_iters = 10000;  // very large.
    cfg.top_n = 2 + (Rand() % 20);
    BaseFloat impr = RefineClusters(points, &clusters, &assignments, cfg);

    clust_objf_after = SumClusterableObjf(clusters);
    KALDI_LOG << "TestRefineClusters: objfs are: "<<points_objf<<" "<<clust_objf_before<<" "<<clust_objf_after<<", impr = "<<impr<<'\n';
    if (cfg.top_n >=(int32) n_clust) {  // check exact.
      KALDI_ASSERT(clust_objf_after <= 0.01*points.size());
    }
    AssertEqual(clust_objf_after - clust_objf_before, impr);
    DeletePointers(&clusters);
    DeletePointers(&points);

  }
}

TestReverseVector()

void kaldi::TestReverseVector

(

)

Definition at line 204 of file stl-utils-test.cc.

References rnnlm::i, KALDI_ASSERT, Rand(), and ReverseVector().

Referenced by main().

                         {
  for (int p = 0; p < 100; p++) {
    std::vector<int> vec;
    int sz = Rand() % 5;
    for (int i = 0;i < sz;i++)
      vec.push_back(Rand() % 4);
    std::vector<int> vec2(vec), vec3(vec);
    ReverseVector(&vec2);
    ReverseVector(&vec2);
    KALDI_ASSERT(vec2 == vec);
    ReverseVector(&vec3);
    for (size_t i = 0; i < vec.size(); i++)
      KALDI_ASSERT(vec[i] == vec3[vec.size()-1-i]);
  }
}

TestSetOfNumbers()

void kaldi::TestSetOfNumbers

(

bool

binary

)

Definition at line 30 of file const-integer-set-test.cc.

References ConstIntegerSet< I >::begin(), ConstIntegerSet< I >::count(), ConstIntegerSet< I >::end(), rnnlm::i, ConstIntegerSet< I >::Init(), KALDI_ASSERT, Rand(), ConstIntegerSet< I >::Read(), ConstIntegerSet< I >::size(), Input::Stream(), swap(), and ConstIntegerSet< I >::Write().

                                                       {
  std::set<Int> baseline_set;
  size_t n_in_set = (Rand() % 3) * 50 + (Rand() % 4);  // may be less than this.
  size_t max = (Int) (Rand() % 100) + 1;
  for (size_t i = 0; i < n_in_set; i++) {
    Int to_add((Int) (Rand() % max));
    baseline_set.insert(to_add);
  }

  std::vector<Int> vector_set;
  for (typename std::set<Int>::iterator iter = baseline_set.begin();
       iter!= baseline_set.end();iter++)
    vector_set.push_back(*iter);
  if (vector_set.size() != 0) {
    for (size_t i = 0;i < 10;i++)  // randomize order.
      std::swap(vector_set[Rand()%vector_set.size()],
                vector_set[Rand()%vector_set.size()]);
  }

  ConstIntegerSet<Int> my_set1(baseline_set);

  ConstIntegerSet<Int> my_set2(vector_set);

  ConstIntegerSet<Int> my_set3;
  my_set3.Init(baseline_set);

  ConstIntegerSet<Int> my_set4;
  my_set4.Init(vector_set);

  {
    my_set4.Write(Output("tmpf", binary).Stream(), binary);
  }

  ConstIntegerSet<Int> my_set5;
  {
    bool binary_in;
    Input ki("tmpf", &binary_in);
    my_set5.Read(ki.Stream(), binary_in);
  }


  // if (enable_iterators) {
  size_t sz = baseline_set.size(), sz1 = my_set1.size(), sz2 = my_set2.size(),
      sz3 = my_set3.size(), sz4 = my_set4.size(), sz5 = my_set5.size();
  KALDI_ASSERT(sz == sz1 && sz == sz2 && sz == sz3 && sz == sz4 && sz == sz5);
  // }
  for (size_t i = 0;i < 100;i++) {
    Int some_int;
    if (i%2 == 0 && vector_set.size() != 0)
      some_int = vector_set[Rand()%vector_set.size()];
    else
      some_int = Rand() % max;
    bool in_baseline = (baseline_set.count(some_int) != 0);
    bool in_my_set1 = (my_set1.count(some_int) != 0);
    bool in_my_set2 = (my_set2.count(some_int) != 0);
    bool in_my_set3 = (my_set3.count(some_int) != 0);
    bool in_my_set4 = (my_set4.count(some_int) != 0);
    bool in_my_set5 = (my_set5.count(some_int) != 0);

    if (in_baseline) {
      KALDI_ASSERT(in_my_set1&&in_my_set2&&in_my_set3&&in_my_set4&&in_my_set5);
    } else {
      KALDI_ASSERT(!in_my_set1&&!in_my_set2&&!in_my_set3&&!in_my_set4&&
                   !in_my_set5);
    }
  }

  //  if (enable_iterators) {
  typename std::set<Int>::iterator baseline_iter = baseline_set.begin();
  typename ConstIntegerSet<Int>::iterator my_iter1 = my_set1.begin();
  typename ConstIntegerSet<Int>::iterator my_iter2 = my_set2.begin();
  typename ConstIntegerSet<Int>::iterator my_iter3 = my_set3.begin();
  typename ConstIntegerSet<Int>::iterator my_iter4 = my_set4.begin();
  typename ConstIntegerSet<Int>::iterator my_iter5 = my_set5.begin();
  while (baseline_iter != baseline_set.end()) {
    KALDI_ASSERT(my_iter1 != my_set1.end());
    KALDI_ASSERT(my_iter2 != my_set2.end());
    KALDI_ASSERT(my_iter3 != my_set3.end());
    KALDI_ASSERT(my_iter4 != my_set4.end());
    KALDI_ASSERT(my_iter5 != my_set5.end());
    KALDI_ASSERT(*baseline_iter == *my_iter1);
    KALDI_ASSERT(*baseline_iter == *my_iter2);
    KALDI_ASSERT(*baseline_iter == *my_iter3);
    KALDI_ASSERT(*baseline_iter == *my_iter4);
    KALDI_ASSERT(*baseline_iter == *my_iter5);
    baseline_iter++;
    my_iter1++;
    my_iter2++;
    my_iter3++;
    my_iter4++;
    my_iter5++;
  }
  KALDI_ASSERT(my_iter1 == my_set1.end());
  KALDI_ASSERT(my_iter2 == my_set2.end());
  KALDI_ASSERT(my_iter3 == my_set3.end());
  KALDI_ASSERT(my_iter4 == my_set4.end());
  KALDI_ASSERT(my_iter5 == my_set5.end());
  // }
}

TestShareEventMapLeaves()

void kaldi::TestShareEventMapLeaves

(

)

Definition at line 535 of file build-tree-utils-test.cc.

References CopySetToVector(), DeleteBuildTreeStats(), DoTableSplitMultiple(), rnnlm::i, Questions::InitRand(), rnnlm::j, KALDI_ASSERT, KALDI_WARN, kAllKeysInsistIdentical, MakeEventPair(), EventMap::MultiMap(), PossibleValues(), Rand(), RandGauss(), RandUniform(), ShareEventMapLeaves(), SortAndUniq(), SplitDecisionTree(), and TrivialTree().

Referenced by main().

                               {
  // this is modified from TestClusterEventMapRestricted() [rather arbitrarily].


  int32 num_keys = 1 + Rand() % 4;
  std::vector<EventKeyType> keys;

  {  // randomly choose keys.  Will always define all of them.
    std::set<EventKeyType> keys_set;
    while (keys_set.size() < (size_t)num_keys)
      keys_set.insert(  (Rand() % (num_keys + 10)) - 3 );
    CopySetToVector(keys_set, &keys);
  }


  BuildTreeStatsType stats;

  int32 n_stats = 1 + (Rand() % 10);
  n_stats *= n_stats;  // up to 81 stats.

  for (size_t i = 0; i < (size_t)n_stats; i++) {
    EventType evec;

    for (size_t j = 0; j < keys.size(); j++) {
      EventValueType val = Rand() % 100;
      evec.push_back(std::make_pair(keys[j], val));
    }
    stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(new ScalarClusterable(RandGauss()))));
  }

  std::vector<EventKeyType> special_keys;
  for (size_t i = 0; i < keys.size(); i++)
    if (RandUniform() < 0.5) special_keys.push_back(keys[i]);


  int32 nleaves = 0;
  EventMap *trivial_map = TrivialTree(&nleaves);


  // We do a complete split on these keys.
  EventMap *table_split_map = DoTableSplitMultiple(*trivial_map, special_keys,
                                                   stats, &nleaves);

  std::cout << "TestClusterEventMapRestricted: after splitting on "<<special_keys.size()<<" keys, nleaves = " <<nleaves<<'\n';
  // We now do decision tree split.
  int nleaves_after_table_split = nleaves;
  Questions qo;  // all default.
  int32 num_quest = Rand() % 10, num_iters = rand () % 5;
  qo.InitRand(stats, num_quest, num_iters, kAllKeysInsistIdentical);
  float thresh = 0.001;
  int32 max_leaves = 100;
  BaseFloat impr;
  BaseFloat smallest_split;
  EventMap *split_tree = SplitDecisionTree(*table_split_map, stats, qo, thresh, max_leaves,
                                           &nleaves, &impr, &smallest_split);
  KALDI_ASSERT((nleaves <= max_leaves || nleaves == nleaves_after_table_split) && smallest_split >= thresh);

  std::cout << "TestShareEventMapLeaves: after building decision tree, " <<nleaves<<'\n';

  if (special_keys.size() == 0) {
    KALDI_WARN << "TestShareEventMapLeaves(): could not test since key not always defined.";
    delete split_tree;
    delete trivial_map;
    delete table_split_map;
    DeleteBuildTreeStats(&stats);
    return;
  }
  EventKeyType key = special_keys[Rand() % special_keys.size()];
  std::vector<EventValueType> values;
  bool always_defined = PossibleValues(key, stats, &values);
  KALDI_ASSERT(always_defined);

  std::set<EventValueType> to_share;
  for (size_t i = 0; i < 3; i++) to_share.insert(values[Rand() % values.size()]);

  std::vector<std::vector<EventValueType> > share_value;
  for (std::set<EventValueType>::iterator iter = to_share.begin();
      iter != to_share.end();
      iter++) {
    share_value.resize(share_value.size()+1);
    share_value.back().push_back(*iter);
  }
  int num_leaves;
  EventMap *shared = ShareEventMapLeaves(*split_tree,
                                         key,
                                         share_value,
                                         &num_leaves);
  KALDI_ASSERT(num_leaves <= nleaves);
  for (size_t i = 0; i < share_value.size(); i++) {
    EventType evec;
    std::vector<EventAnswerType> answers;
    evec.push_back(MakeEventPair(key, share_value[i][0]));
    shared->MultiMap(evec, &answers);
    SortAndUniq(&answers);
    KALDI_ASSERT(answers.size() == 1);  // should have been shared.
  }
  delete shared;

  delete split_tree;
  delete trivial_map;
  delete table_split_map;
  DeleteBuildTreeStats(&stats);
}

TestSortAndUniq()

static void kaldi::TestSortAndUniq ( )

static

Definition at line 79 of file stl-utils-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, rnnlm::n, Rand(), and SortAndUniq().

Referenced by main().

                              {
  for (int i = 0;i < 100;i++) {
    std::vector<int>  vec;

    int len = Rand()%5;
    for (int i = 0;i < len;i++) {
      int n = Rand() % 100;
      bool ok = true;
      for (size_t j = 0;j < vec.size();j++) if (vec[j] == n) ok = false;
      if (ok)  vec.push_back(n);
    }
    // don't sort.
    std::vector<int> vec2(vec);  // make sure all things in "vec" represented
                                 // in vec2.
    int len2 = Rand()%10;
    if (vec.size() > 0)  // add more, randomly.
      for (int i = 0;i < len2;i++)
        vec2.push_back(vec[Rand()%vec.size()]);
    SortAndUniq(&vec2);
    std::sort(vec.begin(), vec.end());
    KALDI_ASSERT(vec == vec2);
  }
}

TestSplitDecisionTree()

void kaldi::TestSplitDecisionTree

(

)

Definition at line 730 of file build-tree-utils-test.cc.

References EventMap::Check(), CopySetToVector(), DeleteBuildTreeStats(), Questions::GetQuestionsOf(), Questions::HasQuestionsForKey(), rnnlm::i, QuestionsForKey::initial_questions, Questions::InitRand(), rnnlm::j, KALDI_ASSERT, kAllKeysIntersection, ObjfGivenMap(), Rand(), RandGauss(), SplitDecisionTree(), SplitStatsByMap(), and TrivialTree().

Referenced by main().

                             {
  // part of the code is the same as the code for testing Questions::InitRand() function.
  for (int32 p = 0;p < 4;p++) {
    std::vector<EventKeyType>  keys_all, keys_some;
    {
      std::set<EventKeyType> keys_all_set, keys_some_set;
      int32 num_all = Rand() % 3, num_some = Rand() % 3;
      for (int32 i = 0;i < num_all;i++) keys_all_set.insert(Rand() % 10);
      for (int32 i = 0;i < num_some;i++) {
        int32 k = Rand() % 10;
        if (keys_all_set.count(k) == 0) keys_some_set.insert(k);
      }
      CopySetToVector(keys_all_set, &keys_all);
      CopySetToVector(keys_some_set, &keys_some);
    }
    std::set<EventKeyType> keys_all_saw_set;
    // Now we have two distinct sets of keys keys_all and keys_some.
    // We now create the Clusterable* stuff.
    BuildTreeStatsType stats;  // dummy because the Clusterable *pointers are actually NULL.
    size_t n_stats = Rand() % 100;
    // make sure we sometimes have empty or just one stats: may find extra bugs.
    if (n_stats > 90) n_stats = 0;
    if (n_stats > 80) n_stats = 1;

    for (size_t i = 0;i < n_stats;i++) {  // Create stats...
      EventType evec;
      for (size_t j = 0;j < keys_all.size();j++) {
        evec.push_back(std::make_pair( keys_all[j], (EventValueType)(Rand() % 10)));
        keys_all_saw_set.insert(keys_all[j]);
      }
      for (size_t j = 0;j < keys_some.size();j++)
        if (Rand() % 2 == 0) {  // randomly w.p. 1/2
          evec.push_back(std::make_pair( keys_some[j], (EventValueType)(Rand() % 10)));
          keys_all_saw_set.insert(keys_some[j]);
        }
      std::sort(evec.begin(), evec.end());  // sorts on keys.
      EventMap::Check(evec);
      stats.push_back(std::make_pair(evec, (Clusterable*) new ScalarClusterable(RandGauss())));
    }
    Questions qo;  // all default.
    BaseFloat thresh = 0.00001;  // these stats have a count of 1... need v. small thresh to get them to merge.
    // 0.000001 tries to ensure everything is split.

    bool intersection = true;  // keep borrowed code later on happy.

    int32 num_quest = Rand() % 10, num_iters = rand () % 5;
    qo.InitRand(stats, num_quest, num_iters, kAllKeysIntersection);

    if (n_stats > 0) {
      if (p < 2) {
        for (size_t i = 0;i < keys_all.size();i++) {
          KALDI_ASSERT(qo.HasQuestionsForKey(keys_all[i]));
          const QuestionsForKey &opts = qo.GetQuestionsOf(keys_all[i]);
          std::cout << "num-quest: "<< opts.initial_questions.size() << '\n';
          for (size_t j = 0;j < opts.initial_questions.size();j++) {
            for (size_t k = 0;k < opts.initial_questions[j].size();k++)
              std::cout << opts.initial_questions[j][k] <<" ";
            std::cout << '\n';
          }
        }
      }
      if (intersection) {
        for (size_t i = 0;i < keys_all.size();i++) {
          KALDI_ASSERT(qo.HasQuestionsForKey(keys_all[i]));
          qo.GetQuestionsOf(keys_all[i]);
        }
      } else {  // union: expect to see all keys that were in the data.
        for (std::set<int32>::iterator iter = keys_all_saw_set.begin(); iter != keys_all_saw_set.end(); iter++) {
          KALDI_ASSERT(qo.HasQuestionsForKey(*iter));
        }
      }
      std::cout << "num_quest = " <<num_quest<<", num_iters = "<<num_iters<<'\n';
      // OK, now want to do decision-tree split.

      int32 num_leaves = 0;
      int32 max_leaves = 50;
      EventMap *trivial_tree = TrivialTree(&num_leaves);

      BaseFloat impr, smallest_split;
      EventMap *split_tree = SplitDecisionTree(*trivial_tree, stats, qo, thresh, max_leaves,
                                               &num_leaves, &impr, &smallest_split);
      KALDI_ASSERT(num_leaves <= max_leaves && smallest_split >= thresh);

      {
        BaseFloat impr_check = ObjfGivenMap(stats, *split_tree) - ObjfGivenMap(stats, *trivial_tree);
        std::cout << "Objf impr is " << impr << ", computed differently: " <<impr_check<<'\n';
        KALDI_ASSERT(fabs(impr - impr_check) < 0.1);
      }


      std::cout << "After splitting, num_leaves = " << num_leaves << '\n';

      std::vector<BuildTreeStatsType> mapped_stats;
      SplitStatsByMap(stats, *split_tree, &mapped_stats);
      std::cout << "Assignments of stats to leaves is:\n";
      for (size_t i = 0; i < mapped_stats.size(); i++) {
        std::cout << " [ leaf "<<i<<"]: ";
        for (size_t j = 0; j < mapped_stats[i].size(); j++) {
          std::cout << ((ScalarClusterable*)(mapped_stats[i][j].second))->Info() << " ";
        }
        std::cout << '\n';
      }
      delete trivial_tree;
      delete split_tree;
      DeleteBuildTreeStats(&stats);
    }
  }
}

TestSplitStatsByKey()

void kaldi::TestSplitStatsByKey

(

)

Definition at line 123 of file build-tree-utils-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, EventMap::Lookup(), Rand(), and SplitStatsByKey().

Referenced by main().

                           {
  {
    BuildTreeStatsType stats;
    for(int32 i = 0; i < 100; i++) {
      EventType evec;
      if (Rand() % 2)
        evec.push_back(std::make_pair(12, Rand() % 10));
      evec.push_back(std::make_pair(10, Rand() % 10));
      if (Rand() % 2)
        evec.push_back(std::make_pair(8, Rand() % 10));
      std::sort(evec.begin(), evec.end());
      stats.push_back(std::make_pair(evec, static_cast<Clusterable*>(NULL)));
    }
    std::vector<BuildTreeStatsType> stats_vec;
    SplitStatsByKey(stats, 10, &stats_vec);
    for(int32 i = 0; i < static_cast<int32>(stats_vec.size()); i++) {
      for(int32 j = 0; j < static_cast<int32>(stats_vec[i].size()); j++) {
        EventAnswerType ans;
        bool ok = EventMap::Lookup(stats_vec[i][j].first, 10, &ans);
        KALDI_ASSERT(ok && ans == i);
      }
    }
  }
}

TestSplitStringOnFirstSpace()

void kaldi::TestSplitStringOnFirstSpace

(

)

Definition at line 266 of file text-utils-test.cc.

References KALDI_ASSERT, and SplitStringOnFirstSpace().

Referenced by main().

                                   {
  std::string a, b;
  SplitStringOnFirstSpace("a b", &a, &b);
  KALDI_ASSERT(a == "a" && b == "b");
  SplitStringOnFirstSpace("aa bb", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "bb");
  SplitStringOnFirstSpace("aa", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "");
  SplitStringOnFirstSpace(" aa \n\t ", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "");
  SplitStringOnFirstSpace("  \n\t ", &a, &b);
  KALDI_ASSERT(a == "" && b == "");
  SplitStringOnFirstSpace(" aa   bb \n\t ", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "bb");
  SplitStringOnFirstSpace(" aa   bb cc ", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "bb cc");
  SplitStringOnFirstSpace(" aa   bb  cc ", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "bb  cc");
  SplitStringOnFirstSpace(" aa   bb  cc", &a, &b);
  KALDI_ASSERT(a == "aa" && b == "bb  cc");
}

TestSplitStringToFloats()

void kaldi::TestSplitStringToFloats

(

)

Definition at line 123 of file text-utils-test.cc.

References KALDI_ASSERT, and SplitStringToFloats().

Referenced by main().

                               {
  {
    std::vector<float> v;
    KALDI_ASSERT(SplitStringToFloats("-1:2.5:4", ":", false, &v) == true
           && v.size() == 3 && v[0] == -1 && v[1] == 2.5 && v[2] == 4);
    KALDI_ASSERT(SplitStringToFloats("-1:2.5:4:", ":", false, &v) == false);
    KALDI_ASSERT(SplitStringToFloats(":-1::2:4:", ":", true, &v) == true
           && v.size() == 3 && v[0] == -1 && v[1] == 2 && v[2] == 4);
    KALDI_ASSERT(SplitStringToFloats("-1\n2.5\t4", " \n\t\r", false, &v) == true
           && v.size() == 3 && v[0] == -1 && v[1] == 2.5 && v[2] == 4);
    KALDI_ASSERT(SplitStringToFloats(" ", " \n\t\r", true, &v) == true
           && v.size() == 0);
    KALDI_ASSERT(SplitStringToFloats("", " \n\t\r", false, &v) == true
           && v.size() == 0);
  }

  {
    std::vector<double> v;
    KALDI_ASSERT(SplitStringToFloats("-1:2:4", ":", false, &v) == true);
  }
}

TestSplitStringToIntegers()

void kaldi::TestSplitStringToIntegers

(

)

Definition at line 98 of file text-utils-test.cc.

References KALDI_ASSERT, and SplitStringToIntegers().

Referenced by main().

                                 {
  {
    std::vector<int32> v;
    KALDI_ASSERT(SplitStringToIntegers("-1:2:4", ":", false, &v) == true
           && v.size() == 3 && v[0] == -1 && v[1] == 2 && v[2] == 4);
    KALDI_ASSERT(SplitStringToIntegers("-1:2:4:", ":", false, &v) == false);
    KALDI_ASSERT(SplitStringToIntegers(":-1::2:4:", ":", true, &v) == true
           && v.size() == 3 && v[0] == -1 && v[1] == 2 && v[2] == 4);
    KALDI_ASSERT(SplitStringToIntegers("-1\n2\t4", " \n\t\r", false, &v) == true
           && v.size() == 3 && v[0] == -1 && v[1] == 2 && v[2] == 4);
    KALDI_ASSERT(SplitStringToIntegers(" ", " \n\t\r", true, &v) == true
           && v.size() == 0);
    KALDI_ASSERT(SplitStringToIntegers("", " \n\t\r", false, &v) == true
           && v.size() == 0);
  }

  {
    std::vector<uint32> v;
    KALDI_ASSERT(SplitStringToIntegers("-1:2:4", ":", false, &v) == false);
    // cannot put negative number in uint32.
  }
}

TestSplitStringToVector()

void kaldi::TestSplitStringToVector

(

)

Definition at line 41 of file text-utils-test.cc.

References full, GetRandChar(), GetRandDelim(), rnnlm::i, rnnlm::j, JoinVectorToString(), KALDI_ASSERT, Rand(), and SplitStringToVector().

Referenced by main().

                               {
  // srand((unsigned int)time(NULL));
  // didn't compile on cygwin.

  {
    std::vector<std::string> str_vec;
    SplitStringToVector("", " ", false, &str_vec);
    KALDI_ASSERT(str_vec.size() == 1);  // If this fails it may just mean
    // that someone changed the
    // semantics of SplitStringToVector in a reasonable way.
    SplitStringToVector("", " ", true, &str_vec);
    KALDI_ASSERT(str_vec.empty());
  }
  for (int j = 0; j < 100; j++) {
    std::vector<std::string> str_vec;
    int sz = Rand() % 73;
    std::string full;
    for (int i = 0; i < sz-1; i++) {
      full.push_back((Rand() % 7 == 0)? GetRandDelim() : GetRandChar());
    }
    std::string delim;
    delim.push_back(GetRandDelim());
    bool omit_empty_strings = (Rand() %2 == 0)? true : false;
    SplitStringToVector(full, delim.c_str(), omit_empty_strings, &str_vec);
    std::string new_full;
    for (size_t i = 0; i < str_vec.size(); i++) {
      if (omit_empty_strings) KALDI_ASSERT(str_vec[i] != "");
      new_full.append(str_vec[i]);
      if (i < str_vec.size() -1) new_full.append(delim);
    }
    std::string new_full2;
    JoinVectorToString(str_vec, delim.c_str(), omit_empty_strings, &new_full2);
    if (omit_empty_strings) {  // sequences of delimiters cannot be matched
      size_t start = full.find_first_not_of(delim),
          end = full.find_last_not_of(delim);
      if (start == std::string::npos) {  // only delimiters
        KALDI_ASSERT(end == std::string::npos);
      } else {
        std::string full_test;
        char last = '\0';
        for (size_t i = start; i <= end; i++) {
          if (full[i] != last || last != *delim.c_str())
            full_test.push_back(full[i]);
          last = full[i];
        }
        if (!full.empty()) {
          KALDI_ASSERT(new_full.compare(full_test) == 0);
          KALDI_ASSERT(new_full2.compare(full_test) == 0);
        }
      }
    } else if (!full.empty()) {
      KALDI_ASSERT(new_full.compare(full) == 0);
      KALDI_ASSERT(new_full2.compare(full) == 0);
    }
  }
}

TestSplitToPhones()

void kaldi::TestSplitToPhones

(

)

Definition at line 203 of file hmm-utils-test.cc.

References GenerateRandomAlignment(), GenRandTransitionModel(), TransitionModel::GetPhones(), rnnlm::i, rnnlm::j, KALDI_ASSERT, RandInt(), SplitToPhones(), and TransitionModel::TransitionIdToPhone().

Referenced by main().

                         {
  ContextDependency *ctx_dep = NULL;
  TransitionModel *trans_model = GenRandTransitionModel(&ctx_dep);
  std::vector<int32> phone_seq;
  int32 num_phones = RandInt(0, 10);
  const std::vector<int32> &phone_list = trans_model->GetPhones();
  for (int32 i = 0; i < num_phones; i++) {
    int32 rand_phone = phone_list[RandInt(0, phone_list.size() - 1)];
    phone_seq.push_back(rand_phone);
  }
  bool reorder = (RandInt(0, 1) == 0);
  std::vector<int32> alignment;
  GenerateRandomAlignment(*ctx_dep, *trans_model, reorder,
                          phone_seq, &alignment);
  std::vector<std::vector<int32> > split_alignment;
  SplitToPhones(*trans_model, alignment, &split_alignment);
  KALDI_ASSERT(split_alignment.size() == phone_seq.size());
  for (size_t i = 0; i < split_alignment.size(); i++) {
    KALDI_ASSERT(!split_alignment[i].empty());
    for (size_t j = 0; j < split_alignment[i].size(); j++) {
      int32 transition_id = split_alignment[i][j];
      KALDI_ASSERT(trans_model->TransitionIdToPhone(transition_id) ==
                   phone_seq[i]);
    }
  }
  delete trans_model;
  delete ctx_dep;
}

TestStringsApproxEqual()

void kaldi::TestStringsApproxEqual

(

)

Definition at line 313 of file text-utils-test.cc.

References KALDI_ASSERT, and StringsApproxEqual().

Referenced by main().

                              {
  // we must test the test.
  KALDI_ASSERT(!StringsApproxEqual("a", "b"));
  KALDI_ASSERT(!StringsApproxEqual("1", "2"));
  KALDI_ASSERT(StringsApproxEqual("1.234", "1.235", 2));
  KALDI_ASSERT(!StringsApproxEqual("1.234", "1.235", 3));
  KALDI_ASSERT(StringsApproxEqual("x 1.234 y", "x 1.2345 y", 3));
  KALDI_ASSERT(!StringsApproxEqual("x 1.234 y", "x 1.2345 y", 4));
  KALDI_ASSERT(StringsApproxEqual("x 1.234 y 6.41", "x 1.235 y 6.49", 1));
  KALDI_ASSERT(!StringsApproxEqual("x 1.234 y 6.41", "x 1.235 y 6.49", 2));
  KALDI_ASSERT(StringsApproxEqual("x 1.234 y 6.41", "x 1.235 y 6.411", 2));
  KALDI_ASSERT(StringsApproxEqual("x 1.0 y", "x 1.0001 y", 3));
  KALDI_ASSERT(!StringsApproxEqual("x 1.0 y", "x 1.0001 y", 4));
}

TestSum()

static void kaldi::TestSum ( )

static

Definition at line 137 of file cluster-utils-test.cc.

References AssertEqual(), Clusterable::Objf(), and SumClusterable().

Referenced by main().

                      {
  ScalarClusterable a(1.0), b(2.5);
  std::vector<Clusterable*> vec;
  vec.push_back(&a);
  vec.push_back(&b);
  Clusterable *sum = SumClusterable(vec);
  AssertEqual(a.ObjfPlus(b),  sum->Objf());
  delete sum;
}

TestSumObjfAndSumNormalizer()

static void kaldi::TestSumObjfAndSumNormalizer ( )

static

Definition at line 125 of file cluster-utils-test.cc.

References AssertEqual(), ScalarClusterable::Objf(), SumClusterableNormalizer(), and SumClusterableObjf().

Referenced by main().

                                          {
  ScalarClusterable a(1.0), b(2.5);
  AssertEqual(a.Objf(), 0.0);
  AssertEqual(b.Objf(), 0.0);
  a.Add(b);
  std::vector<Clusterable*> vec;
  vec.push_back(&a);
  vec.push_back(&a);
  AssertEqual(SumClusterableObjf(vec), 2*vec[0]->Objf());
  AssertEqual(SumClusterableNormalizer(vec), 2*vec[0]->Normalizer());
}

TestSymInvertPosDef()

void kaldi::TestSymInvertPosDef

(

int32

dim

)

Definition at line 286 of file cu-matrix-speed-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), Timer::Elapsed(), KALDI_LOG, kNoTrans, CuMatrixBase< Real >::SymAddMat2(), and CuMatrixBase< Real >::SymInvertPosDef().

                                                            {
  BaseFloat time_in_secs = 0.025;
  CuMatrix<Real> M(dim, dim * 2), N(dim, dim);
  M.SetRandn();
  N.SymAddMat2(1.0, M, kNoTrans, 0.0);
  CuMatrix<Real> Ncopy(N);

  int iter = 0;
  Timer tim;
  for (;tim.Elapsed() < time_in_secs; iter++) {
    Ncopy.CopyFromMat(N);
    Ncopy.SymInvertPosDef();
  }

  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuMatrix::TestCuInvertPosDef" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

TestTaskSequencer()

void kaldi::TestTaskSequencer

(

)

Definition at line 105 of file kaldi-thread-test.cc.

References rnnlm::i, KALDI_ASSERT, TaskSequencerConfig::num_threads, TaskSequencerConfig::num_threads_total, Rand(), and TaskSequencer< C >::Run().

Referenced by main().

                         {
  TaskSequencerConfig config;
  config.num_threads = 1 + Rand() % 20;
  if (Rand() % 2 == 1 )
    config.num_threads_total = config.num_threads + Rand() % config.num_threads;

  int32 num_tasks = Rand() % 100;

  std::vector<int32> task_output;
  {
    TaskSequencer<MyTaskClass> sequencer(config);
    for (int32 i = 0; i < num_tasks; i++) {
      sequencer.Run(new MyTaskClass(i, &task_output));
    }
  } // and let "sequencer" be destroyed, which waits for the last threads.
  KALDI_ASSERT(task_output.size() == static_cast<size_t>(num_tasks));
  for (int32 i = 0; i < num_tasks; i++)
    KALDI_ASSERT(task_output[i] == i);
}

TestThreads()

void kaldi::TestThreads

(

)

Definition at line 62 of file kaldi-thread-test.cc.

References g_num_threads, KALDI_ASSERT, and RunMultiThreaded().

Referenced by main().

                   {
  g_num_threads = 8;
  // run method with temporary threads on 8 threads
  // Note: uncomment following line for the possibility of simple benchmarking
  // for(int i=0; i<100000; i++)
  {
    int32 max_to_count = 10000, tot = 0;
    MyThreadClass c(max_to_count, &tot);
    RunMultiThreaded(c);
    KALDI_ASSERT(tot == (10000*(10000-1))/2);
  }
  g_num_threads = 1;
  // let's try the same, but with only one thread
  {
    int32 max_to_count = 10000, tot = 0;
    MyThreadClass c(max_to_count, &tot);
    RunMultiThreaded(c);
    KALDI_ASSERT(tot == (10000*(10000-1))/2);
  }
}

TestTransitionModel()

void kaldi::TestTransitionModel

(

)

Definition at line 26 of file transition-model-test.cc.

References TransitionModel::Compatible(), GenRandTransitionModel(), KALDI_ASSERT, TransitionModel::Read(), and TransitionModel::Write().

Referenced by main().

                           {

  TransitionModel *trans_model = GenRandTransitionModel(NULL);

  bool binary = (rand() % 2 == 0);

  std::ostringstream os;
  trans_model->Write(os, binary);

  TransitionModel trans_model2;
  std::istringstream is2(os.str());
  trans_model2.Read(is2, binary);

  {
    std::ostringstream os1, os2;
    trans_model->Write(os1, false);
    trans_model2.Write(os2, false);
    KALDI_ASSERT(os1.str() == os2.str());
    KALDI_ASSERT(trans_model->Compatible(trans_model2));
  }
  delete trans_model;
}

TestTreeCluster()

static void kaldi::TestTreeCluster ( )

static

Definition at line 461 of file cluster-utils-test.cc.

References DeletePointers(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, rnnlm::n, Rand(), RandUniform(), SumClusterableObjf(), TreeClusterOptions::thresh, and TreeCluster().

Referenced by main().

                              {
  size_t n_points_tot = 0, n_wrong_tot = 0;
  for (size_t n = 0;n < 10;n++) {

    int32 n_clust = Rand() % 10;
    std::vector<Clusterable*> points;
    for (int32 j = 0;j < n_clust;j++) {
      int32 n_points = 1 + Rand() % 5;
      BaseFloat clust_center  = (BaseFloat)j;
      for (int32 k = 0;k < n_points;k++) points.push_back(new ScalarClusterable(clust_center + RandUniform()*0.01));
    }
    std::vector<Clusterable*> clusters_ext;
    std::vector<int32> assignments;
    std::vector<int32> clust_assignments;
    TreeClusterOptions tcfg;
    tcfg.thresh = 0.01;  // should prevent us splitting things in same  bucket.
    int32 num_leaves = 0;
    BaseFloat ans = TreeCluster(points, n_clust, &clusters_ext, &assignments, &clust_assignments, &num_leaves, tcfg);

    if (n < 3) TreeCluster(points, n_clust, NULL, NULL, NULL, NULL, tcfg);  // make sure no crash

    KALDI_ASSERT(num_leaves == n_clust);
    KALDI_ASSERT(clusters_ext.size() >= static_cast<size_t>(n_clust));
    std::vector<Clusterable*> clusters(clusters_ext);
    clusters.resize(n_clust);  // ignore non-leaves.
    BaseFloat clust_objf = SumClusterableObjf(clusters);

    KALDI_LOG << "TreeCluster: objf after clustering is: "<<clust_objf<<", impr is: "<<ans<<'\n';

    if (n < 2) // avoid generating too much output.
      KALDI_LOG << "Num nodes is "<<clusters_ext.size() <<", leaves "<<num_leaves;
    for (int32 i = 0;i<static_cast<int32>(clusters_ext.size());i++) {
      if (n < 2) // avoid generating too much output.
        KALDI_LOG << "Cluster "<<i<<": "<<((ScalarClusterable*)clusters_ext[i])->Info()<<", parent is: "<< clust_assignments[i]<<"";
      KALDI_ASSERT(clust_assignments[i]>i || (i+1 == static_cast<int32>(clusters_ext.size()) && clust_assignments[i] == i));
      if (i == static_cast<int32>(clusters_ext.size())-1)
        KALDI_ASSERT(clust_assignments[i] == i);  // top node.
    }
    DeletePointers(&clusters_ext);
    DeletePointers(&points);
  }
  if (n_wrong_tot*4 > n_points_tot) {
    KALDI_LOG << "Got too many wrong in k-means test [may not be fatal, but check it out.";
    KALDI_ASSERT(0);
  }
}

TestTrim()

void kaldi::TestTrim

(

)

Definition at line 256 of file text-utils-test.cc.

References KALDI_ASSERT, and TrimTmp().

Referenced by main().

                {
  KALDI_ASSERT(TrimTmp(" a ") == "a");
  KALDI_ASSERT(TrimTmp(" a b  c") == "a b  c");
  KALDI_ASSERT(TrimTmp("") == "");
  KALDI_ASSERT(TrimTmp("X\n") == "X");
  KALDI_ASSERT(TrimTmp("X\n\t") == "X");
  KALDI_ASSERT(TrimTmp("\n\tX") == "X");
}  // end namespace kaldi

TestTrivialTree()

void kaldi::TestTrivialTree

(

)

Definition at line 28 of file build-tree-utils-test.cc.

References KALDI_ASSERT, EventMap::Map(), and TrivialTree().

Referenced by main().

                       {
  int32 nleaves = 0;
  EventMap *tree = TrivialTree(&nleaves);
  EventType empty; EventAnswerType ans;
  bool b = tree->Map(empty, &ans);
  KALDI_ASSERT(b);
  KALDI_ASSERT(nleaves == 1);
  delete tree;
}

TestUniq()

static void kaldi::TestUniq ( )

static

Definition at line 58 of file stl-utils-test.cc.

References count, rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and Uniq().

Referenced by main().

                       {
  for (int i = 0;i < 100;i++) {
    std::vector<int>  vec;

    int cur = 1;  //  sorted order.
    int len = Rand()%5;
    for (int i = 0;i < len;i++) {
      cur += 1 + (Rand() % 100);
      vec.push_back(cur);
    }
    std::vector<int> vec2;
    for (int i = 0;i < len;i++) {
      int count = 1 + Rand()%5;
      for (int j = 0;j < count;j++) vec2.push_back(vec[i]);
    }
    Uniq(&vec2);
    KALDI_ASSERT(vec2 == vec);
  }
}

TestVectorToPosteriorEntry()

void kaldi::TestVectorToPosteriorEntry

(

)

Definition at line 26 of file posterior-test.cc.

References rnnlm::i, KALDI_ASSERT, VectorBase< Real >::Max(), rnnlm::n, RandUniform(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), and VectorToPosteriorEntry().

Referenced by main().

                                  {
  int32 n = 10 + rand () % 50, gselect = 1 + rand() % 5;
  BaseFloat min_post = 0.1 + 0.8 * RandUniform();

  Vector<BaseFloat> loglikes(n);
  loglikes.SetRandn();
  loglikes.Scale(10.0);

  std::vector<std::pair<int32, BaseFloat> > post_entry;

  VectorToPosteriorEntry(loglikes, gselect, min_post, &post_entry);

  KALDI_ASSERT(post_entry.size() <= gselect);

  int32 max_elem;
  loglikes.Max(&max_elem);
  KALDI_ASSERT(post_entry[0].first == max_elem);

  KALDI_ASSERT(post_entry.back().second >= min_post);
  KALDI_ASSERT(post_entry.back().second <= post_entry.front().second);

  BaseFloat sum = 0.0;
  for (size_t i = 0; i < post_entry.size(); i++)
    sum += post_entry[i].second;
  KALDI_ASSERT(fabs(sum - 1.0) < 0.01);
}

TestWordAlignedLattice() [1/2]

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.

This function is designed to crash if something went wrong with the word-alignment of the lattice.

it succeeded and it wasn't a forced-out lattice); otherwise the test will most likely fail.

It verifies that arcs are of 4 types: properly-aligned word arcs, with a word label. partial-word arcs, with the partial-word label. silence arcs, with the silence label.

Definition at line 918 of file word-align-lattice.cc.

References WordAlignedLatticeTester::Test().

                                                               {
  WordAlignedLatticeTester t(lat, tmodel, info, aligned_lat);
  t.Test();
}

TestWordAlignedLattice() [2/2]

static bool kaldi::TestWordAlignedLattice ( const WordAlignLatticeLexiconInfo &  lexicon_info, const TransitionModel &  tmodel, CompactLattice  clat, CompactLattice  aligned_clat, bool  allow_duplicate_paths  )

static

Check equivalence.

Definition at line 927 of file word-align-lattice-lexicon.cc.

References fst::ConvertLattice(), GetVerboseLevel(), IsPlausibleWord(), KALDI_ASSERT, KALDI_WARN, LatticeForwardBackward(), MapSymbols(), and Rand().

Referenced by main(), and WordAlignLatticeLexicon().

                                                               {
  int32 max_err = 5, num_err = 0;
  { // We test whether the forward-backward likelihoods differ; this is intended
    // to detect when we have duplicate paths in the aligned lattice, for some path
    // in the input lattice (e.g. due to epsilon-sequencing problems).
    Posterior post;
    Lattice lat, aligned_lat;
    ConvertLattice(clat, &lat);
    ConvertLattice(aligned_clat, &aligned_lat);
    TopSort(&lat);
    TopSort(&aligned_lat);
    BaseFloat like_before = LatticeForwardBackward(lat, &post),
        like_after = LatticeForwardBackward(aligned_lat, &post);
    if (fabs(like_before - like_after) >
        1.0e-04 * (fabs(like_before) + fabs(like_after))) {
      KALDI_WARN << "Forward-backward likelihoods differ in word-aligned lattice "
                 << "testing, " << like_before << " != " << like_after;
      if (!allow_duplicate_paths)
        num_err++;
    }
  }

  // Do a check on the arcs of the aligned lattice, that each arc corresponds
  // to an entry in the lexicon.
  for (CompactLattice::StateId s = 0; s < aligned_clat.NumStates(); s++) {
    for (fst::ArcIterator<CompactLattice> aiter(aligned_clat, s);
         !aiter.Done(); aiter.Next()) {
      const CompactLatticeArc &arc (aiter.Value());
      KALDI_ASSERT(arc.ilabel == arc.olabel);
      int32 word_id = arc.ilabel;
      const std::vector<int32> &tids = arc.weight.String();
      if (word_id == 0 && tids.empty()) continue; // We allow epsilon arcs.

      if (num_err < max_err)
        if (!IsPlausibleWord(lexicon_info, tmodel, word_id, tids))
          num_err++;
      // Note: IsPlausibleWord will warn if there is an error.
    }
    if (!aligned_clat.Final(s).String().empty()) {
      KALDI_WARN << "Aligned lattice has nonempty string on its final-prob.";
      return false;
    }
  }

  // Next we'll do an equivalence test.
  // First map symbols into equivalence classes, so that we don't wrongly fail
  // due to the capability of the framework to map words to other words.
  // (e.g. mapping <eps> on silence arcs to SIL).

  MapSymbols(lexicon_info, &clat);
  MapSymbols(lexicon_info, &aligned_clat);

  int32 num_paths = 5, seed = Rand(), max_path_length = -1;
  BaseFloat delta = 0.2; // some lattices have large costs -> use large delta.

  FLAGS_v = GetVerboseLevel(); // set the OpenFst verbose level to the Kaldi
                               // verbose level.
  if (!RandEquivalent(clat, aligned_clat, num_paths, delta, seed, max_path_length)) {
    KALDI_WARN << "Equivalence test failed during lattice alignment.";
    return false;
  }
  FLAGS_v = 0;

  return (num_err == 0);
}

TestWordAlignedLatticeLexicon()

void kaldi::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.

If was_ok==true (was_ok is the return status of WordAlignLattice), it tests that, after removing any silence and partial-word labels that may have been inserted by WordAlignLattice, the word-aligned lattice is equivalent to the input. It also verifies that arcs are of 4 types: properly-aligned word arcs, with a word label. partial-word arcs, with the partial-word label. silence arcs, with the silence label.

Referenced by WordAlignLatticeLexiconOpts::Register().

TestWordAlignLatticeLexicon()

void kaldi::TestWordAlignLatticeLexicon

(

)

Definition at line 173 of file word-align-lattice-lexicon-test.cc.

References WordAlignLatticeLexiconOpts::allow_duplicate_paths, fst::ConvertLattice(), fst::ConvertNbestToVector(), GenerateCompactLatticeRandomly(), GenerateLexicon(), GenerateRandomAlignment(), GenerateWordAndPhoneSequence(), GenRandTransitionModel(), TransitionModel::GetPhones(), KALDI_ASSERT, KALDI_LOG, rnnlm::n, PrintLexicon(), PrintWordsAndPhones(), RandInt(), WordAlignLatticeLexiconOpts::reorder, WordAlignLatticeLexiconOpts::test, WordAlignLatticeLexicon(), and WriteCompactLattice().

Referenced by main().

                                   {
  ContextDependency *ctx_dep;
  TransitionModel *trans_model = GenRandTransitionModel(&ctx_dep);
  bool allow_zero_words = true;
  bool allow_empty_word = true;
  bool allow_multiple_prons = true;

  const std::vector<int32> &phones = trans_model->GetPhones();
  std::vector<std::vector<int32> > lexicon;
  GenerateLexicon(phones, allow_zero_words, allow_empty_word,
                  allow_multiple_prons, &lexicon);

  std::vector<int32> phone_seq;
  std::vector<int32> word_seq;
  while (phone_seq.empty())
    GenerateWordAndPhoneSequence(lexicon, &phone_seq, &word_seq);

  PrintLexicon(lexicon);
  PrintWordsAndPhones(word_seq, phone_seq);

  std::vector<int32> alignment;
  bool reorder = (RandInt(0, 1) == 0);
  GenerateRandomAlignment(*ctx_dep, *trans_model, reorder,
                          phone_seq, &alignment);

  CompactLattice clat;
  GenerateCompactLatticeRandomly(alignment, word_seq, &clat);

  KALDI_LOG << "clat is ";
  WriteCompactLattice(std::cerr, false, clat);

  WordAlignLatticeLexiconOpts opts;
  WordAlignLatticeLexiconInfo lexicon_info(lexicon);
  opts.test = true;  // we rely on the self-test code that's activated when we
                     // do this.
  opts.allow_duplicate_paths = true;
  opts.reorder = reorder;
  CompactLattice aligned_clat;
  bool ans = WordAlignLatticeLexicon(clat, *trans_model, lexicon_info, opts,
                                     &aligned_clat);
  KALDI_LOG << "Aligned clat is ";
  WriteCompactLattice(std::cerr, false, aligned_clat);
  KALDI_ASSERT(ans);

  Lattice lat;
  ConvertLattice(clat, &lat);
  int32 n = 1000;  // a maximum.
  Lattice nbest_lat;
  std::vector<Lattice> nbest_lats;
  fst::ShortestPath(lat, &nbest_lat, n);
  fst::ConvertNbestToVector(nbest_lat, &nbest_lats);
  KALDI_LOG << "Word-aligned lattice has " << nbest_lats.size() << " paths.";

  delete ctx_dep;
  delete trans_model;
}

ThrowsExceptionTest()

bool kaldi::ThrowsExceptionTest	(	bool	seps,
		const std::string &	infile
	)

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

References Compile().

Referenced by RunAllTests().

                                                             {
  try {
    // Make memory cleanup easy in both cases of try-catch block.
    std::unique_ptr<ArpaLmCompiler> compiler(Compile(seps, infile));
    return false;
  } catch (const KaldiFatalError&) {
    return true;
  }
}

TimerTest()

void kaldi::TimerTest

(

)

Definition at line 28 of file timer-test.cc.

References Timer::Elapsed(), KALDI_ERR, and Sleep().

Referenced by main().

                 {
  float time_secs = 0.025 * (rand() % 10);
  std::cout << "target is " << time_secs << "\n";
  Timer timer;
  Sleep(time_secs);
  BaseFloat f = timer.Elapsed();
  std::cout << "time is " << f << std::endl;
  if (fabs(time_secs - f) > 0.05)
    KALDI_ERR << "Timer fail: waited " << f << " seconds instead of "
              <<  time_secs << " secs.";
}

TimeToTimecode()

std::string TimeToTimecode

(

float

time

)

Definition at line 402 of file online-audio-client.cc.

Referenced by main().

                                     {

  char buf[64];

  int32 h, m, s, ms;
  s = (int32) time;
  ms = (int32)((time - (float) s) * 1000.0f);
  m = s / 60;
  s %= 60;
  h = m / 60;
  m %= 60;

#if !defined(_MSC_VER)
  snprintf(buf, 64, "%02d:%02d:%02d.%03d", h, m, s, ms);
#endif

  return buf;
}

TopSortCompactLatticeIfNeeded()

void TopSortCompactLatticeIfNeeded

(

CompactLattice *

clat

)

Topologically sort the compact lattice if not already topologically sorted.

Will crash if the lattice cannot be topologically sorted.

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

References KALDI_ERR.

Referenced by LatticeIncrementalDeterminizer::AcceptRawLatticeChunk(), CompactLatticeLimitDepth(), PrunedCompactLatticeComposer::Compose(), and main().

                                                         {
  if (clat->Properties(fst::kTopSorted, true) == 0) {
    if (fst::TopSort(clat) == false) {
      KALDI_ERR << "Topological sorting failed";
    }
  }
}

TopSortLatticeIfNeeded()

void TopSortLatticeIfNeeded

(

Lattice *

clat

)

Topologically sort the lattice if not already topologically sorted.

Will crash if lattice cannot be topologically sorted.

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

References KALDI_ERR.

Referenced by SingleUtteranceGmmDecoder::GetGaussianPosteriors(), LatticeBoost(), and ReplaceAcousticScoresFromMap().

                                          {
  if (lat->Properties(fst::kTopSorted, true) == 0) {
    if (fst::TopSort(lat) == false) {
      KALDI_ERR << "Topological sorting failed";
    }
  }
}

ToString()

std::string kaldi::ToString

(

const T &

t

)

Definition at line 42 of file cu-rand-speed-test.cc.

Referenced by MeanVariance().

                               {
  std::ostringstream os;
  os << t;
  return os.str();
}

TotalNumArcs()

static int32 kaldi::TotalNumArcs ( const CompactLattice &  clat )

static

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

Referenced by PrunedCompactLatticeComposer::Compose().

                                                      {
  int32 num_states = clat.NumStates(),
      num_arcs = 0;
  for (int32 s = 0; s < num_states; s++)
    num_arcs += clat.NumArcs(s);
  return num_arcs;
}

TraceMatMat() [1/6]

Real TraceMatMat	(	const CuMatrixBase< Real > &	A,
		const CuMatrixBase< Real > &	B,
		MatrixTransposeType	trans
	)

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

References CU1DBLOCK, CuVectorBase< Real >::Data(), CuMatrixBase< Real >::Data(), CuMatrixBase< Real >::Dim(), KALDI_ASSERT, kNoTrans, kUndefined, CuMatrixBase< Real >::Mat(), CuMatrixBase< Real >::num_rows_, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), CuMatrixBase< Real >::Stride(), VectorBase< Real >::Sum(), and TraceMatMat().

                                            {
  if (A.num_rows_ == 0) {
    KALDI_ASSERT(B.num_rows_ == 0);
    return 0.0;
  }
  Real result = 0;
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    if (trans == kNoTrans) {
      KALDI_ASSERT(A.NumRows() == B.NumCols() && A.NumCols() == B.NumRows());
    } else {
      KALDI_ASSERT(A.NumRows() == B.NumRows() && A.NumCols() == B.NumCols());
    }
    CuTimer tim;
    // 2D blocks: each (8x32) block sums up (32x32) elements.
    // 2D grid: try to cover all the matrix A unless it is too big.
    // Kernel will reduce to ~256 elements with good performance,
    // if the matrix is not in a very bad shape.
    // (wider or taller than 32x8192)
    // CPU will then reduce to 1 element.
    const int kWarpSize = 32;
    dim3 dimBlock(kWarpSize, CU1DBLOCK / kWarpSize);
    dim3 dimGrid(n_blocks(A.NumCols(), kWarpSize),
        n_blocks(A.NumRows(), kWarpSize));
    if (dimGrid.x * dimGrid.y > 256) {
      dimGrid.y = 256 / dimGrid.x;
      if (dimGrid.y == 0) {
        dimGrid.y = 1;
      }
    }
    CuVector<Real> result_vec(dimGrid.x * dimGrid.y, kUndefined);
    if (trans == kNoTrans) {
      cuda_trace_mat_mat(dimGrid, dimBlock, A.Data(), B.Data(), A.Dim(),
          B.Stride(), result_vec.Data());
    } else {
      cuda_trace_mat_mat_trans(dimGrid, dimBlock, A.Data(), B.Data(), A.Dim(),
          B.Stride(), result_vec.Data());
    }
    CU_SAFE_CALL(cudaGetLastError());
    Vector<Real> result_cpu(result_vec); // copying from CUDA faster than summing in CUDA.
    result = result_cpu.Sum();
    CuDevice::Instantiate().AccuProfile(__func__, tim);
  } else
#endif
  {
    result = TraceMatMat(A.Mat(), B.Mat(), trans);
  }
  return result;
}

TraceMatMat() [2/6]

template float kaldi::TraceMatMat	(	const CuMatrixBase< float > &	A,
		const CuMatrixBase< float > &	B,
		MatrixTransposeType	trans
	)

TraceMatMat() [3/6]

template double kaldi::TraceMatMat	(	const CuMatrixBase< double > &	A,
		const CuMatrixBase< double > &	B,
		MatrixTransposeType	trans
	)

Referenced by CuMatrixBase< float >::IsUnit(), and TraceMatMat().

TraceMatMat() [4/6]

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.

tr(A B), or tr(A B^T).

Definition at line 2692 of file kaldi-matrix.cc.

References cblas_Xdot(), MatrixBase< Real >::data_, KALDI_ASSERT, kNoTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::stride_, and TraceMatMat().

Referenced by CalBasisFmllrStepSize(), CalcFmllrStepSize(), DiscriminativeComputation::Compute(), kaldi::nnet3::ComputeObjectiveFunction(), BasisFmllrEstimate::ComputeTransform(), LstmNonlinearityComponent::ConsolidateMemory(), kaldi::nnet3::ConstrainOrthonormalInternal(), ConvolutionComponent::DotProduct(), TimeHeightConvolutionComponent::DotProduct(), LstmNonlinearityComponent::DotProduct(), TdnnComponent::DotProduct(), RepeatedAffineComponent::DotProduct(), AffineComponent::DotProduct(), LinearComponent::DotProduct(), BlockAffineComponent::DotProduct(), Convolutional1dComponent::DotProduct(), FmllrAuxfGradient(), FmllrAuxFuncDiagGmm(), FmllrSgmm2Accs::FmllrObjGradient(), MatrixBase< float >::FrobeniusNorm(), LogisticRegression::GetObjfAndGrad(), AffineComponent::Info(), AffineComponentPreconditioned::Info(), AffineComponentPreconditionedOnline::Info(), FixedLinearComponent::Info(), FixedAffineComponent::Info(), Convolutional1dComponent::Info(), main(), NnetComputer::MatrixStddev(), MllrAuxFunction(), MlObjective(), OnlineNaturalGradient::PreconditionDirections(), kaldi::nnet2::PreconditionDirectionsAlpha(), kaldi::nnet2::PreconditionDirectionsAlphaRescaled(), OnlinePreconditionerSimple::PreconditionDirectionsCpu(), OnlineNaturalGradientSimple::PreconditionDirectionsCpu(), OnlinePreconditioner::PreconditionDirectionsInternal(), kaldi::nnet3::PrintParameterStats(), NnetDiscriminativeComputeObjf::ProcessOutputs(), NnetChainTrainer::ProcessOutputs(), NnetChainComputeProb::ProcessOutputs(), NnetDiscriminativeTrainer::ProcessOutputs(), NnetUpdater::Propagate(), SolveQuadraticMatrixProblem(), kaldi::nnet3::attention::TestAttentionForwardBackward(), TestCuMatrixCompObjfAndDeriv(), TestCuMatrixTraceMatMat(), kaldi::nnet3::time_height_convolution::TestDataBackprop(), TestFmpe(), kaldi::nnet3::time_height_convolution::TestParamsBackprop(), kaldi::nnet3::TestSimpleComponentDataDerivative(), kaldi::nnet3::TestSimpleComponentModelDerivative(), TraceMatSpMatSp(), UnitTestCuMatrixObjfDeriv(), UnitTestCuMatrixTraceMatMat(), UnitTestCuSparseMatrixTraceMatSmat(), UnitTestDeterminant(), kaldi::nnet2::UnitTestGenericComponentInternal(), UnitTestLstmNonlinearity(), UnitTestMatrixAddMatSmat(), UnitTestMatrixAddSmatMat(), kaldi::nnet3::UnitTestNnetInputDerivatives(), kaldi::nnet3::UnitTestNnetModelDerivatives(), kaldi::nnet2::UnitTestPreconditionDirectionsOnline(), kaldi::nnet3::UnitTestPreconditionDirectionsOnline(), UnitTestSolve(), UnitTestSparseMatrixTraceMatSmat(), UnitTestTrace(), UnitTestTraceProduct(), FmllrSgmm2Accs::Update(), and MleAmSgmm2Updater::UpdateW().

                                             {  // tr(A B), equivalent to sum of each element of A times same element in B'
  MatrixIndexT aStride = A.stride_, bStride = B.stride_;
  if (trans == kNoTrans) {
    KALDI_ASSERT(A.NumRows() == B.NumCols() && A.NumCols() == B.NumRows());
    Real ans = 0.0;
    Real *adata = A.data_, *bdata = B.data_;
    MatrixIndexT arows = A.NumRows(), acols = A.NumCols();
    for (MatrixIndexT row = 0;row < arows;row++, adata+=aStride, bdata++)
      ans += cblas_Xdot(acols, adata, 1, bdata, bStride);
    return ans;
  } else {
    KALDI_ASSERT(A.NumRows() == B.NumRows() && A.NumCols() == B.NumCols());
    Real ans = 0.0;
    Real *adata = A.data_, *bdata = B.data_;
    MatrixIndexT arows = A.NumRows(), acols = A.NumCols();
    for (MatrixIndexT row = 0;row < arows;row++, adata+=aStride, bdata+=bStride)
      ans += cblas_Xdot(acols, adata, 1, bdata, 1);
    return ans;
  }
}

TraceMatMat() [5/6]

template float kaldi::TraceMatMat	(	const MatrixBase< float > &	A,
		const MatrixBase< float > &	B,
		MatrixTransposeType	trans
	)

TraceMatMat() [6/6]

template double kaldi::TraceMatMat	(	const MatrixBase< double > &	A,
		const MatrixBase< double > &	B,
		MatrixTransposeType	trans
	)

Referenced by TraceMatMat(), and TraceMatMatMat().

TraceMatMatMat() [1/2]

template float kaldi::TraceMatMatMat	(	const MatrixBase< float > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< float > &	B,
		MatrixTransposeType	transB,
		const MatrixBase< float > &	C,
		MatrixTransposeType	transC
	)

TraceMatMatMat() [2/2]

template double kaldi::TraceMatMatMat	(	const MatrixBase< double > &	A,
		MatrixTransposeType	transA,
		const MatrixBase< double > &	B,
		MatrixTransposeType	transB,
		const MatrixBase< double > &	C,
		MatrixTransposeType	transC
	)

Referenced by TraceMatMatMat(), and TraceMatMatMatMat().

TraceMatMatMatMat() [1/2]

template float kaldi::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
	)

TraceMatMatMatMat() [2/2]

template double kaldi::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
	)

Referenced by TraceMatMatMatMat().

TraceMatSmat() [1/5]

Real TraceMatSmat	(	const CuMatrixBase< Real > &	A,
		const CuSparseMatrix< Real > &	B,
		MatrixTransposeType	trans
	)

Definition at line 524 of file cu-sparse-matrix.cc.

References CuSparseMatrix< Real >::CsrColIdx(), CuSparseMatrix< Real >::CsrRowPtr(), CuSparseMatrix< Real >::CsrVal(), CU1DBLOCK, CuMatrixBase< Real >::Data(), CuMatrixBase< Real >::Dim(), KALDI_ASSERT, kNoTrans, kTrans, CuMatrixBase< Real >::Mat(), CuSparseMatrix< Real >::NumCols(), CuMatrixBase< Real >::NumCols(), CuSparseMatrix< Real >::NumElements(), CuSparseMatrix< Real >::NumRows(), CuMatrixBase< Real >::NumRows(), CuSparseMatrix< Real >::Smat(), and CuSparseMatrix< Real >::TraceMatSmat.

                                             {
  if (A.NumCols() == 0) {
    KALDI_ASSERT(B.NumCols() == 0);
    return 0.0;
  }
  if (B.NumElements() == 0) {
    return 0.0;
  }
  Real result = 0;
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    if (trans == kTrans) {
      KALDI_ASSERT(A.NumRows() == B.NumRows() && A.NumCols() == B.NumCols());
    } else {
      KALDI_ASSERT(A.NumCols() == B.NumRows() && A.NumRows() == B.NumCols());
    }

    // The Sum() method in CuVector handles a bunch of logic, we use that to
    // comptue the trace.
    CuVector<Real> sum_vec(B.NumElements());
    CuTimer tim;

    // We use warpSize threads per row to access only the nnz elements.
    // Every CU1DBLOCK/warpSize rows share one thread block.
    // 1D grid to cover all rows of B.
    const int warpSize = 32;
    dim3 dimBlock(warpSize, CU1DBLOCK / warpSize);
    dim3 dimGrid(n_blocks(B.NumRows(), dimBlock.y));

    if (trans == kNoTrans) {
      cuda_trace_mat_smat(dimGrid, dimBlock, A.Data(), A.Dim(), B.CsrRowPtr(),
                          B.CsrColIdx(), B.CsrVal(), sum_vec.Data());
    } else {
      cuda_trace_mat_smat_trans(dimGrid, dimBlock, A.Data(), A.Dim(),
                                B.CsrRowPtr(), B.CsrColIdx(), B.CsrVal(),
                                sum_vec.Data());
    }
    result = sum_vec.Sum();
    CuDevice::Instantiate().AccuProfile(__func__, tim);
  } else
#endif
  {
    result = TraceMatSmat(A.Mat(), B.Smat(), trans);
  }
  return result;
}

TraceMatSmat() [2/5]

template float kaldi::TraceMatSmat	(	const CuMatrixBase< float > &	A,
		const CuSparseMatrix< float > &	B,
		MatrixTransposeType	trans
	)

TraceMatSmat() [3/5]

template double kaldi::TraceMatSmat	(	const CuMatrixBase< double > &	A,
		const CuSparseMatrix< double > &	B,
		MatrixTransposeType	trans
	)

TraceMatSmat() [4/5]

template float kaldi::TraceMatSmat	(	const MatrixBase< float > &	A,
		const SparseMatrix< float > &	B,
		MatrixTransposeType	trans
	)

TraceMatSmat() [5/5]

template double kaldi::TraceMatSmat	(	const MatrixBase< double > &	A,
		const SparseMatrix< double > &	B,
		MatrixTransposeType	trans
	)

Referenced by TraceMatSmat().

TraceMatSpMat() [1/2]

template float kaldi::TraceMatSpMat	(	const MatrixBase< float > &	A,
		MatrixTransposeType	transA,
		const SpMatrix< float > &	B,
		const MatrixBase< float > &	C,
		MatrixTransposeType	transC
	)

TraceMatSpMat() [2/2]

template double kaldi::TraceMatSpMat	(	const MatrixBase< double > &	A,
		MatrixTransposeType	transA,
		const SpMatrix< double > &	B,
		const MatrixBase< double > &	C,
		MatrixTransposeType	transC
	)

TraceMatSpMatSp() [1/2]

template float kaldi::TraceMatSpMatSp	(	const MatrixBase< float > &	A,
		MatrixTransposeType	transA,
		const SpMatrix< float > &	B,
		const MatrixBase< float > &	C,
		MatrixTransposeType	transC,
		const SpMatrix< float > &	D
	)

TraceMatSpMatSp() [2/2]

template double kaldi::TraceMatSpMatSp	(	const MatrixBase< double > &	A,
		MatrixTransposeType	transA,
		const SpMatrix< double > &	B,
		const MatrixBase< double > &	C,
		MatrixTransposeType	transC,
		const SpMatrix< double > &	D
	)

TraceSpMat() [1/2]

template float kaldi::TraceSpMat	(	const SpMatrix< float > &	A,
		const MatrixBase< float > &	B
	)

TraceSpMat() [2/2]

template double kaldi::TraceSpMat	(	const SpMatrix< double > &	A,
		const MatrixBase< double > &	B
	)

TraceSpSp() [1/5]

Real TraceSpSp	(	const CuSpMatrix< Real > &	A,
		const CuSpMatrix< OtherReal > &	B
	)

C++ templatd wrapper of ANSI-C CUBLAS function GEMM (matrix multiply)

TraceSpSp returns tr(A B)

Definition at line 168 of file cu-sp-matrix.cc.

References CuVectorBase< Real >::CopyDiagFromPacked(), CuPackedMatrix< Real >::Data(), KALDI_ASSERT, kUndefined, CuSpMatrix< Real >::Mat(), CuPackedMatrix< Real >::NumRows(), TraceSpSp(), and VecVec().

                                                                          {
  KALDI_ASSERT(A.NumRows() == B.NumRows());
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    if (A.NumRows() == 0) return 0.0;
    MatrixIndexT nr = A.NumRows(), size = nr * (nr+1) / 2;
    CuVector<Real> Adiag(nr, kUndefined);
    CuVector<OtherReal> Bdiag(nr, kUndefined);
    Adiag.CopyDiagFromPacked(A);
    Bdiag.CopyDiagFromPacked(B);
    CuSubVector<Real> Aall(A.Data(), size);
    CuSubVector<OtherReal> Ball(B.Data(), size);
    // Below, we subtrace VecVec(Adiag, Bdiag) to remove double-counting
    // on the diagonal.
    return 2.0 * VecVec(Aall, Ball) - VecVec(Adiag, Bdiag);
  } else
#endif
  {
    return TraceSpSp(A.Mat(), B.Mat());
  }
}

TraceSpSp() [2/5]

template float kaldi::TraceSpSp	(	const CuSpMatrix< float > &	A,
		const CuSpMatrix< float > &	B
	)

TraceSpSp() [3/5]

template float kaldi::TraceSpSp	(	const CuSpMatrix< float > &	A,
		const CuSpMatrix< double > &	B
	)

TraceSpSp() [4/5]

template double kaldi::TraceSpSp	(	const CuSpMatrix< double > &	A,
		const CuSpMatrix< float > &	B
	)

TraceSpSp() [5/5]

template double kaldi::TraceSpSp	(	const CuSpMatrix< double > &	A,
		const CuSpMatrix< double > &	B
	)

TraceSpSp< double, float >()

template double kaldi::TraceSpSp< double, float >	(	const SpMatrix< double > &	A,
		const SpMatrix< float > &	B
	)

Referenced by TraceSpSp().

TraceSpSp< float, double >()

template float kaldi::TraceSpSp< float, double >	(	const SpMatrix< float > &	A,
		const SpMatrix< double > &	B
	)

Referenced by TraceSpSp().

TraceSpSpLower() [1/2]

template double kaldi::TraceSpSpLower	(	const SpMatrix< double > &	A,
		const SpMatrix< double > &	B
	)

TraceSpSpLower() [2/2]

template float kaldi::TraceSpSpLower	(	const SpMatrix< float > &	A,
		const SpMatrix< float > &	B
	)

TrainOneIter()

void kaldi::TrainOneIter	(	const Matrix< BaseFloat > &	feats,
		const MleDiagGmmOptions &	gmm_opts,
		int32	iter,
		int32	num_threads,
		DiagGmm *	gmm
	)

Definition at line 61 of file gmm-global-init-from-feats.cc.

References AccumDiagGmm::AccumulateFromDiagMultiThreaded(), count, KALDI_LOG, kGmmAll, kUndefined, MleDiagGmmUpdate(), MatrixBase< Real >::NumRows(), and VectorBase< Real >::Set().

Referenced by main().

                                {
  AccumDiagGmm gmm_acc(*gmm, kGmmAll);

  Vector<BaseFloat> frame_weights(feats.NumRows(), kUndefined);
  frame_weights.Set(1.0);

  double tot_like;
  tot_like = gmm_acc.AccumulateFromDiagMultiThreaded(*gmm, feats, frame_weights,
                                                     num_threads);

  KALDI_LOG << "Likelihood per frame on iteration " << iter
            << " was " << (tot_like / feats.NumRows()) << " over "
            << feats.NumRows() << " frames.";
  
  BaseFloat objf_change, count;
  MleDiagGmmUpdate(gmm_opts, gmm_acc, kGmmAll, gmm, &objf_change, &count);

  KALDI_LOG << "Objective-function change on iteration " << iter << " was "
            << (objf_change / count) << " over " << count << " frames.";
}

TransformIvectors()

void kaldi::TransformIvectors	(	const Matrix< BaseFloat > &	ivectors_in,
		const PldaConfig &	plda_config,
		const Plda &	plda,
		Matrix< BaseFloat > *	ivectors_out
	)

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

References Plda::Dim(), rnnlm::i, MatrixBase< Real >::NumRows(), Matrix< Real >::Resize(), MatrixBase< Real >::Row(), and Plda::TransformIvector().

Referenced by main().

                                   {
  int32 dim = plda.Dim();
  ivectors_out->Resize(ivectors_in.NumRows(), dim);
  for (int32 i = 0; i < ivectors_in.NumRows(); i++) {
    Vector<BaseFloat> transformed_ivector(dim);
    plda.TransformIvector(plda_config, ivectors_in.Row(i), 1.0,
      &transformed_ivector);
    ivectors_out->Row(i).CopyFromVec(transformed_ivector);
  }
}

Trim()

void Trim

(

std::string *

str

)

Removes the beginning and trailing whitespaces from a string.

Definition at line 92 of file text-utils.cc.

Referenced by ConvertStringToInteger(), ParseOptions::Read(), ParseOptions::ReadConfigFile(), TrimTmp(), and UnitTestRangesMatrix().

                          {
  const char *white_chars = " \t\n\r\f\v";

  std::string::size_type pos = str->find_last_not_of(white_chars);
  if (pos != std::string::npos)  {
    str->erase(pos + 1);
    pos = str->find_first_not_of(white_chars);
    if (pos != std::string::npos) str->erase(0, pos);
  } else {
    str->erase(str->begin(), str->end());
  }
}

TrimTmp()

std::string kaldi::TrimTmp

(

std::string

s

)

Definition at line 251 of file text-utils-test.cc.

References Trim().

Referenced by TestTrim().

                               {
  Trim(&s);
  return s;
}

TrimTrailingWhitespace()

void kaldi::TrimTrailingWhitespace

(

std::string *

str

)

Definition at line 41 of file arpa-file-parser.cc.

Referenced by ArpaFileParser::Read().

                                            {
  str->erase(str->find_last_not_of(" \n\r\t") + 1);
}

TypeOneUsage() [1/2]

int32 kaldi::TypeOneUsage	(	const ParseOptions &	po,
		BaseFloat	scale1,
		BaseFloat	scale2
	)

Definition at line 30 of file matrix-sum.cc.

References MatrixBase< Real >::AddMat(), DeletePointers(), SequentialTableReader< Holder >::Done(), SequentialTableReader< Holder >::FreeCurrent(), ParseOptions::GetArg(), rnnlm::i, KALDI_LOG, KALDI_WARN, SequentialTableReader< Holder >::Key(), kNoTrans, SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), SameDim(), MatrixBase< Real >::Scale(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                     {
  int32 num_args = po.NumArgs();
  std::string matrix_in_fn1 = po.GetArg(1),
      matrix_out_fn = po.GetArg(num_args);

  // Output matrix
  BaseFloatMatrixWriter matrix_writer(matrix_out_fn);

  // Input matrices
  SequentialBaseFloatMatrixReader matrix_reader1(matrix_in_fn1);
  std::vector<RandomAccessBaseFloatMatrixReader*>
      matrix_readers(num_args-2,
                     static_cast<RandomAccessBaseFloatMatrixReader*>(NULL));
  std::vector<std::string> matrix_in_fns(num_args-2);
  for (int32 i = 2; i < num_args; ++i) {
    matrix_readers[i-2] = new RandomAccessBaseFloatMatrixReader(po.GetArg(i));
    matrix_in_fns[i-2] = po.GetArg(i);
  }

  int32 n_utts = 0, n_total_matrices = 0,
      n_success = 0, n_missing = 0, n_other_errors = 0;

  for (; !matrix_reader1.Done(); matrix_reader1.Next()) {
    std::string key = matrix_reader1.Key();
    Matrix<BaseFloat> matrix1 = matrix_reader1.Value();
    matrix_reader1.FreeCurrent();
    n_utts++;
    n_total_matrices++;

    matrix1.Scale(scale1);

    Matrix<BaseFloat> matrix_out(matrix1);

    for (int32 i = 0; i < num_args-2; ++i) {
      if (matrix_readers[i]->HasKey(key)) {
        Matrix<BaseFloat> matrix2 = matrix_readers[i]->Value(key);
        n_total_matrices++;
        if (SameDim(matrix2, matrix_out)) {
          BaseFloat scale = (i == 0 ? scale2 : 1.0);
          // note: i == 0 corresponds to the 2nd input archive.
          matrix_out.AddMat(scale, matrix2, kNoTrans);
        } else {
          KALDI_WARN << "Dimension mismatch for utterance " << key
                     << " : " << matrix2.NumRows() << " by "
                     << matrix2.NumCols() << " for "
                     << "system " << (i + 2) << ", rspecifier: "
                     << matrix_in_fns[i] << " vs " << matrix_out.NumRows()
                     << " by " << matrix_out.NumCols()
                     << " primary matrix, rspecifier:" << matrix_in_fn1;
          n_other_errors++;
        }
      } else {
        KALDI_WARN << "No matrix found for utterance " << key << " for "
                   << "system " << (i + 2) << ", rspecifier: "
                   << matrix_in_fns[i];
        n_missing++;
      }
    }

    matrix_writer.Write(key, matrix_out);
    n_success++;
  }

  KALDI_LOG << "Processed " << n_utts << " utterances: with a total of "
            << n_total_matrices << " matrices across " << (num_args-1)
            << " different systems";
  KALDI_LOG << "Produced output for " << n_success << " utterances; "
            << n_missing << " total missing matrices";

  DeletePointers(&matrix_readers);

  return (n_success != 0 && n_missing < (n_success - n_missing)) ? 0 : 1;
}

TypeOneUsage() [2/2]

int32 kaldi::TypeOneUsage

(

const ParseOptions &

po

)

Definition at line 36 of file vector-sum.cc.

References VectorBase< Real >::AddVec(), DeletePointers(), VectorBase< Real >::Dim(), SequentialTableReader< Holder >::Done(), SequentialTableReader< Holder >::FreeCurrent(), ParseOptions::GetArg(), rnnlm::i, KALDI_LOG, KALDI_WARN, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

                                           {
  int32 num_args = po.NumArgs();
  std::string vector_in_fn1 = po.GetArg(1),
      vector_out_fn = po.GetArg(num_args);

  // Output vector
  BaseFloatVectorWriter vector_writer(vector_out_fn);

  // Input vectors
  SequentialBaseFloatVectorReader vector_reader1(vector_in_fn1);
  std::vector<RandomAccessBaseFloatVectorReader*> vector_readers(num_args-2,
                                                                 static_cast<RandomAccessBaseFloatVectorReader*>(NULL));
  std::vector<std::string> vector_in_fns(num_args-2);
  for (int32 i = 2; i < num_args; ++i) {
    vector_readers[i-2] = new RandomAccessBaseFloatVectorReader(po.GetArg(i));
    vector_in_fns[i-2] = po.GetArg(i);
  }

  int32 n_utts = 0, n_total_vectors = 0,
      n_success = 0, n_missing = 0, n_other_errors = 0;

  for (; !vector_reader1.Done(); vector_reader1.Next()) {
    std::string key = vector_reader1.Key();
    Vector<BaseFloat> vector1 = vector_reader1.Value();
    vector_reader1.FreeCurrent();
    n_utts++;
    n_total_vectors++;

    Vector<BaseFloat> vector_out(vector1);

    for (int32 i = 0; i < num_args-2; ++i) {
      if (vector_readers[i]->HasKey(key)) {
        Vector<BaseFloat> vector2 = vector_readers[i]->Value(key);
        n_total_vectors++;
        if (vector2.Dim() == vector_out.Dim()) {
          vector_out.AddVec(1.0, vector2);
        } else {
          KALDI_WARN << "Dimension mismatch for utterance " << key
                     << " : " << vector2.Dim() << " for "
                     << "system " << (i + 2) << ", rspecifier: "
                     << vector_in_fns[i] << " vs " << vector_out.Dim()
                     << " primary vector, rspecifier:" << vector_in_fn1;
          n_other_errors++;
        }
      } else {
        KALDI_WARN << "No vector found for utterance " << key << " for "
                   << "system " << (i + 2) << ", rspecifier: "
                   << vector_in_fns[i];
        n_missing++;
      }
    }

    vector_writer.Write(key, vector_out);
    n_success++;
  }

  KALDI_LOG << "Processed " << n_utts << " utterances: with a total of "
            << n_total_vectors << " vectors across " << (num_args-1)
            << " different systems";
  KALDI_LOG << "Produced output for " << n_success << " utterances; "
            << n_missing << " total missing vectors";

  DeletePointers(&vector_readers);

  return (n_success != 0 && n_missing < (n_success - n_missing)) ? 0 : 1;
}

TypeOneUsageAverage()

int32 kaldi::TypeOneUsageAverage

(

const ParseOptions &

po

)

Definition at line 106 of file matrix-sum.cc.

References MatrixBase< Real >::AddMat(), DeletePointers(), SequentialTableReader< Holder >::Done(), SequentialTableReader< Holder >::FreeCurrent(), ParseOptions::GetArg(), rnnlm::i, KALDI_LOG, KALDI_WARN, SequentialTableReader< Holder >::Key(), kNoTrans, SequentialTableReader< Holder >::Next(), ParseOptions::NumArgs(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), SameDim(), MatrixBase< Real >::Scale(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                  {
  int32 num_args = po.NumArgs();
  std::string matrix_in_fn1 = po.GetArg(1),
      matrix_out_fn = po.GetArg(num_args);
  BaseFloat scale = 1.0 / (num_args - 1);

  // Output matrix
  BaseFloatMatrixWriter matrix_writer(matrix_out_fn);

  // Input matrices
  SequentialBaseFloatMatrixReader matrix_reader1(matrix_in_fn1);
  std::vector<RandomAccessBaseFloatMatrixReader*>
      matrix_readers(num_args-2,
                     static_cast<RandomAccessBaseFloatMatrixReader*>(NULL));
  std::vector<std::string> matrix_in_fns(num_args-2);
  for (int32 i = 2; i < num_args; ++i) {
    matrix_readers[i-2] = new RandomAccessBaseFloatMatrixReader(po.GetArg(i));
    matrix_in_fns[i-2] = po.GetArg(i);
  }

  int32 n_utts = 0, n_total_matrices = 0,
      n_success = 0, n_missing = 0, n_other_errors = 0;

  for (; !matrix_reader1.Done(); matrix_reader1.Next()) {
    std::string key = matrix_reader1.Key();
    Matrix<BaseFloat> matrix1 = matrix_reader1.Value();
    matrix_reader1.FreeCurrent();
    n_utts++;
    n_total_matrices++;

    matrix1.Scale(scale);

    Matrix<BaseFloat> matrix_out(matrix1);

    for (int32 i = 0; i < num_args-2; ++i) {
      if (matrix_readers[i]->HasKey(key)) {
        Matrix<BaseFloat> matrix2 = matrix_readers[i]->Value(key);
        n_total_matrices++;
        if (SameDim(matrix2, matrix_out)) {
          matrix_out.AddMat(scale, matrix2, kNoTrans);
        } else {
          KALDI_WARN << "Dimension mismatch for utterance " << key
                     << " : " << matrix2.NumRows() << " by "
                     << matrix2.NumCols() << " for "
                     << "system " << (i + 2) << ", rspecifier: "
                     << matrix_in_fns[i] << " vs " << matrix_out.NumRows()
                     << " by " << matrix_out.NumCols()
                     << " primary matrix, rspecifier:" << matrix_in_fn1;
          n_other_errors++;
        }
      } else {
        KALDI_WARN << "No matrix found for utterance " << key << " for "
                   << "system " << (i + 2) << ", rspecifier: "
                   << matrix_in_fns[i];
        n_missing++;
      }
    }

    matrix_writer.Write(key, matrix_out);
    n_success++;
  }

  KALDI_LOG << "Processed " << n_utts << " utterances: with a total of "
            << n_total_matrices << " matrices across " << (num_args-1)
            << " different systems";
  KALDI_LOG << "Produced output for " << n_success << " utterances; "
            << n_missing << " total missing matrices";

  DeletePointers(&matrix_readers);

  return (n_success != 0 && n_missing < (n_success - n_missing)) ? 0 : 1;
}

TypeThreeUsage() [1/2]

int32 kaldi::TypeThreeUsage	(	const ParseOptions &	po,
		bool	binary
	)

Definition at line 151 of file vector-sum.cc.

References VectorBase< Real >::AddVec(), ClassifyRspecifier(), ClassifyWspecifier(), VectorBase< Real >::Dim(), ParseOptions::GetArg(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kCopyData, kNoRspecifier, kNoWspecifier, ParseOptions::NumArgs(), PrintableWxfilename(), ReadKaldiObject(), Vector< Real >::Resize(), and WriteKaldiObject().

                                  {
  KALDI_ASSERT(po.NumArgs() >= 2);
  for (int32 i = 1; i < po.NumArgs(); i++) {
    if (ClassifyRspecifier(po.GetArg(i), NULL, NULL) != kNoRspecifier) {
      KALDI_ERR << "Wrong usage (type 3): if first and last arguments are not "
                << "tables, the intermediate arguments must not be tables.";
    }
  }
  if (ClassifyWspecifier(po.GetArg(po.NumArgs()), NULL, NULL, NULL) !=
      kNoWspecifier) {
    KALDI_ERR << "Wrong usage (type 3): if first and last arguments are not "
              << "tables, the intermediate arguments must not be tables.";
  }

  Vector<BaseFloat> sum;
  for (int32 i = 1; i < po.NumArgs(); i++) {
    Vector<BaseFloat> this_vec;
    ReadKaldiObject(po.GetArg(i), &this_vec);
    if (sum.Dim() < this_vec.Dim())
      sum.Resize(this_vec.Dim(), kCopyData);;
    sum.AddVec(1.0, this_vec);
  }
  WriteKaldiObject(sum, po.GetArg(po.NumArgs()), binary);
  KALDI_LOG << "Summed " << (po.NumArgs() - 1) << " vectors; "
            << "wrote sum to " << PrintableWxfilename(po.GetArg(po.NumArgs()));
  return 0;
}

TypeThreeUsage() [2/2]

int32 kaldi::TypeThreeUsage	(	const ParseOptions &	po,
		bool	binary,
		bool	average
	)

Definition at line 226 of file matrix-sum.cc.

References MatrixBase< Real >::AddMat(), ClassifyRspecifier(), ClassifyWspecifier(), ParseOptions::GetArg(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kCopyData, kNoRspecifier, kNoWspecifier, ParseOptions::NumArgs(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), PrintableWxfilename(), ReadKaldiObject(), Matrix< Real >::Resize(), MatrixBase< Real >::Scale(), and WriteKaldiObject().

Referenced by main().

                                                {
  KALDI_ASSERT(po.NumArgs() >= 2);
  for (int32 i = 1; i < po.NumArgs(); i++) {
    if (ClassifyRspecifier(po.GetArg(i), NULL, NULL) != kNoRspecifier) {
      KALDI_ERR << "Wrong usage (type 3): if first and last arguments are not "
                << "tables, the intermediate arguments must not be tables.";
    }
  }
  if (ClassifyWspecifier(po.GetArg(po.NumArgs()), NULL, NULL, NULL) !=
      kNoWspecifier) {
    KALDI_ERR << "Wrong usage (type 3): if first and last arguments are not "
              << "tables, the intermediate arguments must not be tables.";
  }

  Matrix<BaseFloat> sum;
  for (int32 i = 1; i < po.NumArgs(); i++) {
    Matrix<BaseFloat> this_mat;
    ReadKaldiObject(po.GetArg(i), &this_mat);
    if (sum.NumRows() < this_mat.NumRows() ||
        sum.NumCols() < this_mat.NumCols())
      sum.Resize(std::max(sum.NumRows(), this_mat.NumRows()),
                 std::max(sum.NumCols(), this_mat.NumCols()),
                 kCopyData);
    sum.AddMat(1.0, this_mat);
  }
  if (average)
    sum.Scale(1.0 / (po.NumArgs() - 1));
  WriteKaldiObject(sum, po.GetArg(po.NumArgs()), binary);
  KALDI_LOG << "Summed " << (po.NumArgs() - 1) << " matrices; "
            << "wrote sum to " << PrintableWxfilename(po.GetArg(po.NumArgs()));
  return 0;
}

TypeTwoUsage() [1/2]

int32 kaldi::TypeTwoUsage	(	const ParseOptions &	po,
		bool	binary,
		bool	average = false
	)

Definition at line 103 of file vector-sum.cc.

References ClassifyRspecifier(), ClassifyWspecifier(), VectorBase< Real >::Dim(), ParseOptions::GetArg(), KALDI_ASSERT, KALDI_LOG, KALDI_WARN, kNoRspecifier, kNoWspecifier, ParseOptions::NumArgs(), PrintableWxfilename(), and WriteKaldiObject().

                                         {
  KALDI_ASSERT(po.NumArgs() == 2);
  KALDI_ASSERT(ClassifyRspecifier(po.GetArg(1), NULL, NULL) != kNoRspecifier &&
               "vector-sum: first argument must be an rspecifier");
  // if next assert fails it would be bug in the code as otherwise we shouldn't
  // be called.
  KALDI_ASSERT(ClassifyWspecifier(po.GetArg(2), NULL, NULL, NULL) ==
               kNoWspecifier);

  SequentialBaseFloatVectorReader vec_reader(po.GetArg(1));

  Vector<double> sum;

  int32 num_done = 0, num_err = 0;

  for (; !vec_reader.Done(); vec_reader.Next()) {
    const Vector<BaseFloat> &vec = vec_reader.Value();
    if (vec.Dim() == 0) {
      KALDI_WARN << "Zero vector input for key " << vec_reader.Key();
      num_err++;
    } else {
      if (sum.Dim() == 0) sum.Resize(vec.Dim());
      if (sum.Dim() != vec.Dim()) {
        KALDI_WARN << "Dimension mismatch for key " << vec_reader.Key()
                   << ": " << vec.Dim() << " vs. " << sum.Dim();
        num_err++;
      } else {
        sum.AddVec(1.0, vec);
        num_done++;
      }
    }
  }

  if (num_done > 0 && average) sum.Scale(1.0 / num_done);

  Vector<BaseFloat> sum_float(sum);
  WriteKaldiObject(sum_float, po.GetArg(2), binary);

  KALDI_LOG << "Summed " << num_done << " vectors, "
            << num_err << " with errors; wrote sum to "
            << PrintableWxfilename(po.GetArg(2));
  return (num_done > 0 && num_err < num_done) ? 0 : 1;
}

TypeTwoUsage() [2/2]

int32 kaldi::TypeTwoUsage	(	const ParseOptions &	po,
		bool	binary
	)

Definition at line 179 of file matrix-sum.cc.

References ClassifyRspecifier(), ClassifyWspecifier(), ParseOptions::GetArg(), KALDI_ASSERT, KALDI_LOG, KALDI_WARN, kNoRspecifier, kNoTrans, kNoWspecifier, ParseOptions::NumArgs(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), PrintableWxfilename(), and WriteKaldiObject().

Referenced by main().

                                {
  KALDI_ASSERT(po.NumArgs() == 2);
  KALDI_ASSERT(ClassifyRspecifier(po.GetArg(1), NULL, NULL) != kNoRspecifier &&
               "matrix-sum: first argument must be an rspecifier");
  // if next assert fails it would be bug in the code as otherwise we shouldn't
  // be called.
  KALDI_ASSERT(ClassifyWspecifier(po.GetArg(2), NULL, NULL, NULL) ==
               kNoWspecifier);

  SequentialBaseFloatMatrixReader mat_reader(po.GetArg(1));

  Matrix<double> sum;

  int32 num_done = 0, num_err = 0;

  for (; !mat_reader.Done(); mat_reader.Next()) {
    const Matrix<BaseFloat> &mat = mat_reader.Value();
    if (mat.NumRows() == 0) {
      KALDI_WARN << "Zero matrix input for key " << mat_reader.Key();
      num_err++;
    } else {
      if (sum.NumRows() == 0) sum.Resize(mat.NumRows(), mat.NumCols());
      if (sum.NumRows() != mat.NumRows() || sum.NumCols() != mat.NumCols()) {
        KALDI_WARN << "Dimension mismatch for key " << mat_reader.Key()
                   << ": " << mat.NumRows() << " by " << mat.NumCols() << " vs. "
                   << sum.NumRows() << " by " << sum.NumCols();
        num_err++;
      } else {
        Matrix<double> dmat(mat);
        sum.AddMat(1.0, dmat, kNoTrans);
        num_done++;
      }
    }
  }

  Matrix<BaseFloat> sum_float(sum);
  WriteKaldiObject(sum_float, po.GetArg(2), binary);

  KALDI_LOG << "Summed " << num_done << " matrices, "
            << num_err << " with errors; wrote sum to "
            << PrintableWxfilename(po.GetArg(2));
  return (num_done > 0 && num_err < num_done) ? 0 : 1;
}

Uniq()

void kaldi::Uniq ( std::vector< T > *  vec )

inline

Removes duplicate elements from a sorted list.

Definition at line 78 of file stl-utils.h.

References IsSorted(), KALDI_ASSERT, and KALDI_PARANOID_ASSERT.

Referenced by TestUniq(), UnitTestTableRandomBothDouble(), and UnitTestTableRandomBothDoubleMatrix().

                                    {  // must be already sorted.
  KALDI_PARANOID_ASSERT(IsSorted(*vec));
  KALDI_ASSERT(vec);
  vec->erase(std::unique(vec->begin(), vec->end()), vec->end());
}

UnitInvert()

static void kaldi::UnitInvert ( )

static

Definition at line 151 of file cu-test.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddVecVec(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, KALDI_LOG, kNoTrans, and CuMatrixBase< Real >::SymInvertPosDef().

                                                 {
  //MatrixIndexT dim = 15 + Rand() %  40;;
  MatrixIndexT dim = 8;
  CuMatrix<Real> A(dim,dim);
  Matrix<Real> B(dim,dim);
  Vector<Real> C(dim);
  for (MatrixIndexT i = 0; i < dim; i++) {
    B(i,i) = 1;
    C(i) = i + 1;
  }
  B.AddVecVec(1.0,C,C);
  CuMatrix<Real> tmp(dim,dim);
  A.CopyFromMat(B);
  //A.Cholesky();
  A.CopyToMat(&B);
  KALDI_LOG << "B is : ";
  KALDI_LOG << B;
  A.SymInvertPosDef();
  Matrix<Real> D(dim,dim);
  A.CopyToMat(&D);
  KALDI_LOG << "D is : ";
  KALDI_LOG << D;
  Matrix<Real> X(dim,dim);
  X.AddMatMat(1,B,kNoTrans,D,kNoTrans,0);
  KALDI_LOG << X;
  //for (MatrixIndexT i = 0; i < dim; i++) {
  //  for (MatrixIndexT j = i+1; j < dim; j++)
  //    D(i,j) = 0;
  //}
  //Matrix<Real> E(dim,dim);
  //E.AddMatMat(1,D,kNoTrans,D,kTrans,0);
  //AssertEqual(B,E);
}

UnitTestAddColSumMatSpeed()

static void kaldi::UnitTestAddColSumMatSpeed ( )

static

Definition at line 166 of file matrix-lib-speed-test.cc.

References VectorBase< Real >::AddColSumMat(), Timer::Elapsed(), rnnlm::i, and MatrixBase< Real >::SetRandn().

                                        {
  Timer t;
  std::vector<MatrixIndexT> sizes;
  int32 size = 4, num = 5;
  for(int32 i = 0; i < num; i++) {
    sizes.push_back(size);
    size *= 4;
  }

  for(size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];
    Matrix<Real> M(size, size);
    M.SetRandn();
    Vector<Real> Vc(size);
    
    int32 iter = 0;
    BaseFloat time_in_secs = 0.02;
    Timer t1;
    for (;t1.Elapsed() < time_in_secs; iter++) {
      Vc.AddColSumMat(0.4, M, 0.5);
    }  
 
    BaseFloat fdim = size;
    BaseFloat gflops = (fdim * fdim * iter) / (t1.Elapsed() * 1.0e+09);
    CsvResult<Real>("AddColSumMat", size, gflops, "gigaflops");
  }
  CsvResult<Real>(__func__, sizes.size(), t.Elapsed(), "seconds");
}

UnitTestAddDiagMat2()

static void kaldi::UnitTestAddDiagMat2 ( )

static

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

References VectorBase< Real >::AddDiagMat2(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddVec(), AssertEqual(), VectorBase< Real >::CopyDiagFromMat(), diag, kNoTrans, kTrans, Rand(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                  {
  for (MatrixIndexT iter = 0; iter < 4; iter++) {
    MatrixIndexT dimM = 10 + Rand() % 3,
                 dimN = 1 + Rand() % 4;
    Vector<Real> v(dimM);
    v.SetRandn();
    Vector<Real> w(v);
    if (iter % 2 == 1) {
      Matrix<Real> M(dimM, dimN);
      M.SetRandn();
      v.AddDiagMat2(0.5, M, kNoTrans, 0.3);
      Matrix<Real> M2(dimM, dimM);
      M2.AddMatMat(1.0, M, kNoTrans, M, kTrans, 0.0);
      Vector<Real> diag(dimM);
      diag.CopyDiagFromMat(M2);
      w.Scale(0.3);
      w.AddVec(0.5, diag);
      AssertEqual(w, v);
    } else {
      Matrix<Real> M(dimN, dimM);
      M.SetRandn();
      v.AddDiagMat2(0.5, M, kTrans, 0.3);
      Matrix<Real> M2(dimM, dimM);
      M2.AddMatMat(1.0, M, kTrans, M, kNoTrans, 0.0);
      Vector<Real> diag(dimM);
      diag.CopyDiagFromMat(M2);
      w.Scale(0.3);
      w.AddVec(0.5, diag);
      AssertEqual(w, v);
    }
  }
}

UnitTestAddDiagMatMat()

static void kaldi::UnitTestAddDiagMatMat ( )

static

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

References VectorBase< Real >::AddDiagMatMat(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddVec(), AssertEqual(), VectorBase< Real >::CopyDiagFromMat(), rnnlm::d, kNoTrans, kTrans, Rand(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                    {
  for (MatrixIndexT iter = 0; iter < 4; iter++) {
    BaseFloat alpha = 0.432 + Rand() % 5, beta = 0.043 + Rand() % 2;
    MatrixIndexT dimM = 10 + Rand() % 3,
                 dimN = 5 + Rand() % 4;
    Vector<Real> v(dimM);
    Matrix<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);
    Matrix<Real> M(M_orig, transM), N(N_orig, transN);

    v.SetRandn();
    Vector<Real> w(v);

    w.AddDiagMatMat(alpha, M, transM, N, transN, beta);

    {
      Vector<Real> w2(v);
      Matrix<Real> MN(dimM, dimM);
      MN.AddMatMat(1.0, M, transM, N, transN, 0.0);
      Vector<Real> d(dimM);
      d.CopyDiagFromMat(MN);
      w2.Scale(beta);
      w2.AddVec(alpha, d);
      AssertEqual(w, w2);
    }
  }
}

UnitTestAddDiagVecMat()

static void kaldi::UnitTestAddDiagVecMat ( )

static

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

References VectorBase< Real >::AddVec(), AssertEqual(), VectorBase< Real >::CopyColFromMat(), VectorBase< Real >::CopyFromVec(), KALDI_ASSERT, kNoTrans, kTrans, Rand(), MatrixBase< Real >::Row(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and Matrix< Real >::Transpose().

                                                            {
  for (int p = 0; p < 2; p++) {
    MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
    Real alpha = 0.43243, beta = 1.423;
    Matrix<Real> M(dimM, dimN), N(dimM, dimN);
    M.SetRandn();
    N.SetRandn();
    MatrixTransposeType trans = (p % 2 == 0 ? kNoTrans : kTrans);
    if (trans == kTrans)
      N.Transpose();

    Vector<Real> V(dimM);
    V.SetRandn();

    Matrix<Real> Mcheck(M);
    for (int32 r = 0; r < dimM; r++) {
      SubVector<Real> Mcheckrow(Mcheck, r);
      Vector<Real> Nrow(dimN);
      if (trans == kTrans) Nrow.CopyColFromMat(N, r);
      else Nrow.CopyFromVec(N.Row(r));
      Mcheckrow.Scale(beta);
      Mcheckrow.AddVec(alpha * V(r), Nrow);
    }

    M.AddDiagVecMat(alpha, V, N, trans, beta);
    AssertEqual(M, Mcheck);
    KALDI_ASSERT(M.Sum() != 0.0);
  }
}

UnitTestAddMat2()

static void kaldi::UnitTestAddMat2 ( )

static

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

References SpMatrix< Real >::AddMat2(), AssertEqual(), MatrixBase< Real >::CopyFromSp(), rnnlm::i, kNoTrans, kTakeLower, kTrans, Rand(), Matrix< Real >::Resize(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::SymAddMat2().

                                                      {
  MatrixIndexT extra = 1;
  // Test AddMat2 function of SpMatrix.
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = (Rand()%10) + extra,
        dimN = (Rand() % 10) + extra;
    Real alpha = 0.2 * (Rand() % 6),
        beta = 0.2 * (Rand() % 6);
    SpMatrix<Real> S(dimM);
    S.SetRandn();
    MatrixTransposeType trans = (i % 2 == 1 ? kTrans: kNoTrans),
        other_trans = (trans == kTrans ? kNoTrans : kTrans);
    Matrix<Real> M;
    if (trans == kNoTrans) M.Resize(dimM, dimN);
    else M.Resize(dimN, dimM);
    M.SetRandn();

    Matrix<Real> Sfull(S), Sfull2(S);

    S.AddMat2(alpha, M, trans, beta);

    Sfull.AddMatMat(alpha, M, trans, M, other_trans, beta);

    Sfull2.SymAddMat2(alpha, M, trans, beta);

    // now symmetrize.
    SpMatrix<Real> Sfull2_copy(Sfull2, kTakeLower);
    Sfull2.CopyFromSp(Sfull2_copy);

    Matrix<Real> Sfull3(S);
    AssertEqual(Sfull, Sfull3);
    AssertEqual(Sfull2, Sfull3);
  }
}

UnitTestAddMat2Sp()

static void kaldi::UnitTestAddMat2Sp ( )

static

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

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddMatSp(), SpMatrix< Real >::AddSmat2Sp(), AssertEqual(), rnnlm::i, kNoTrans, kTrans, Rand(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and Matrix< Real >::Transpose().

                                                        {
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = (Rand()%10) + 1,
        dimN = (Rand()%10 + 1);
    BaseFloat alpha = 0.8, beta = 0.9;
    SpMatrix<Real> S(dimM), T(dimN);
    S.SetRandn();
    T.SetRandn();
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    MatrixTransposeType trans = (i % 2 == 1 ? kTrans: kNoTrans);
    if (trans == kTrans) M.Transpose();
    SpMatrix<Real> S2(S), S3(S);
    S.AddMat2Sp(alpha, M, trans, T, beta);
    S3.AddSmat2Sp(alpha, M, trans, T, beta);

    // M[trans?] * T.
    Matrix<Real> A(dimM, dimN);
    A.AddMatSp(1.0, M, trans, T, 0.0);
    Matrix<Real> B(dimM, dimM); // M[trans] * T * M[trans]'
    B.AddMatMat(1.0, A, kNoTrans, M, trans == kTrans ? kNoTrans : kTrans, 0.0);
    SpMatrix<Real> tmp(B);
    S2.Scale(beta);
    S2.AddSp(alpha, tmp);
    AssertEqual(S, S2);
    AssertEqual(S, S3);
  }
}

UnitTestAddMatDiagVec()

static void kaldi::UnitTestAddMatDiagVec ( )

static

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

References MatrixBase< Real >::AddMat(), AssertEqual(), MatrixBase< Real >::CopyFromMat(), KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::MulColsVec(), Rand(), MatrixBase< Real >::Scale(), and VectorBase< Real >::SetRandn().

                                                            {
  // M <- alpha * N[^T] * diag(v) + beta * M
  for (int p = 0; p < 2; p++) {
    MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
    Real alpha = 0.43243, beta = 1.423;

    Matrix<Real> M(dimM, dimN), N(dimM, dimN), buf(dimM, dimN);
    M.SetRandn();
    N.SetRandn();
    buf.CopyFromMat(N);
    MatrixTransposeType trans = (p % 2 == 0 ? kNoTrans : kTrans);
    if (trans == kTrans)
      N.Transpose();

    Vector<Real> V(dimN);
    V.SetRandn();

    Matrix<Real> Mcheck(M);
    Mcheck.Scale(beta);
    buf.MulColsVec(V);
    Mcheck.AddMat(alpha, buf, kNoTrans);

    M.AddMatDiagVec(alpha, N, trans, V, beta);
    AssertEqual(M, Mcheck);
    KALDI_ASSERT(M.Sum() != 0.0);
  }
}

UnitTestAddMatMatElements()

static void kaldi::UnitTestAddMatMatElements ( )

static

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

References MatrixBase< Real >::AddMat(), AssertEqual(), MatrixBase< Real >::CopyFromMat(), KALDI_ASSERT, kNoTrans, MatrixBase< Real >::MulElements(), Rand(), and MatrixBase< Real >::Scale().

                                                                {
  // M <- alpha *(A .* B) + beta * M
  MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
  Real alpha = 0.43243, beta = 1.423;
  Matrix<Real> M(dimM, dimN), A(dimM, dimN), B(dimM, dimN), buf(dimM, dimN);
  M.SetRandn();
  A.SetRandn();
  B.SetRandn();

  Matrix<Real> Mcheck(M);
  buf.CopyFromMat(A); buf.MulElements(B);
  Mcheck.Scale(beta); Mcheck.AddMat(alpha, buf, kNoTrans);

  M.AddMatMatElements(alpha, A, B, beta);
  AssertEqual(M, Mcheck);
  KALDI_ASSERT(M.Sum() != 0.0);
}

UnitTestAddMatMatNans()

static void kaldi::UnitTestAddMatMatNans ( )

static

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

References MatrixBase< Real >::AddMatMat(), rnnlm::i, KALDI_ASSERT, kNoTrans, PlaceNansInGaps(), RandInt(), and MatrixBase< Real >::Sum().

                                    {
  for (int32 i = 0; i < 200; i++) {
    int32 num_rows = RandInt(1, 256), mid = RandInt(1, 256), num_cols = RandInt(1, 256);
    Matrix<Real> mat1(num_rows, mid), mat2(mid, num_cols), prod(num_rows, num_cols);
    PlaceNansInGaps(&mat1);
    PlaceNansInGaps(&mat2);
    prod.AddMatMat(1.0, mat1, kNoTrans, mat2, kNoTrans, 0.0);
    // make sure the nan's don't propagate.
    KALDI_ASSERT(prod.Sum() == 0.0 &&
                 "The BLAS library that you are linking against has an issue that might "
                 "cause problems later on.");
  }
}

UnitTestAddMatMatSpeed()

static void kaldi::UnitTestAddMatMatSpeed ( )

static

Definition at line 112 of file matrix-lib-speed-test.cc.

References MatrixBase< Real >::AddMatMat(), Timer::Elapsed(), rnnlm::i, rnnlm::j, kNoTrans, and kTrans.

                                     {
  Timer t;
  std::vector<MatrixIndexT> sizes;
  sizes.push_back(512);
  sizes.push_back(1024);
  for (size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];
    {
      Timer t1;
      for (int32 j=0; j<2; j++) {
        Matrix<Real> A(size,size), B(size,size), C(size,size);
        A.SetRandn(); B.SetRandn();
        C.AddMatMat(1.0, A, kNoTrans, B, kNoTrans, 0.0); 
        C.AddMatMat(1.0, A, kNoTrans, B, kTrans, 0.0); 
        C.AddMatMat(1.0, A, kTrans, B, kNoTrans, 0.0); 
        C.AddMatMat(1.0, A, kTrans, B, kTrans, 0.0); 
      }
      CsvResult<Real>("AddMatMat", size, t1.Elapsed(), "seconds");
    }
  }
  CsvResult<Real>(__func__, sizes.size(), t.Elapsed(), "seconds");
}

UnitTestAddMatSelf()

static void kaldi::UnitTestAddMatSelf ( )

static

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

References MatrixBase< Real >::AddMat(), AssertEqual(), kTrans, and Rand().

                                                         {
  MatrixIndexT dimM = (Rand() % 10) + 1;
  Matrix<Real> M(dimM, dimM), N(dimM, dimM);
  M.SetRandn();
  N.AddMat(1.5, M);
  M.AddMat(0.5, M);
  AssertEqual(M, N);
  N.AddMat(0.5, M, kTrans);
  M.AddMat(0.5, M, kTrans);
  AssertEqual(M, N);
}

UnitTestAddMatSmat()

static void kaldi::UnitTestAddMatSmat ( )

static

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

References MatrixBase< Real >::AddSmatMat(), AssertEqual(), rnnlm::i, kNoTrans, kTrans, Rand(), MatrixBase< Real >::SetRandn(), and Matrix< Real >::Transpose().

                                                         {
  for (MatrixIndexT i = 0; i < 6; i++) {
    MatrixIndexT dimM = (Rand()%10) + 1,
        dimN = (Rand()%10 + 1),
        dimO = (Rand()%10 + 1);
    MatrixTransposeType transB = (i % 2 == 0 ? kTrans : kNoTrans),
        transC = (i % 3 == 0 ? kTrans : kNoTrans);
    Matrix<Real> A(dimM, dimN),
        B(dimM, dimO), C(dimO, dimN);
    A.SetRandn(); B.SetRandn(); C.SetRandn();
    if (transB == kTrans) B.Transpose();
    if (transC == kTrans) C.Transpose();
    Matrix<Real> A2(A), A3(A);
    BaseFloat beta = 0.333, alpha = 0.5;
    A.AddMatMat(alpha, B, transB, C, transC, beta);
    A2.AddMatSmat(alpha, B, transB, C, transC, beta);
    A3.AddSmatMat(alpha, B, transB, C, transC, beta);
    AssertEqual(A, A2);
    AssertEqual(A, A3);
  }
}

UnitTestAddOuterProductPlusMinus()

static void kaldi::UnitTestAddOuterProductPlusMinus ( )

static

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

References MatrixBase< Real >::AddMat(), AddOuterProductPlusMinus(), AssertEqual(), rnnlm::i, KALDI_ASSERT, fst::Plus(), Rand(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetZero().

                                                                       {
  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    MatrixIndexT dimM = 10 + Rand() % 10;
    MatrixIndexT dimN = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), Plus(dimM, dimN), Minus(dimM, dimN),
        M2(dimM, dimN);
    Vector<Real> v1(dimM), v2(dimN);

    for (MatrixIndexT i = 0; i < 5; i++) {
      v1.SetRandn();
      v2.SetRandn();
      Real alpha = 0.333 * ((Rand() % 10) - 5);
      M.AddVecVec(alpha, v1, v2);

      AddOuterProductPlusMinus(alpha, v1, v2, &Plus, &Minus);
      M2.SetZero();
      M2.AddMat(-1.0, Minus);
      M2.AddMat(1.0, Plus);
      AssertEqual(M, M2);
      KALDI_ASSERT(Minus.Min() >= 0);
      KALDI_ASSERT(Plus.Min() >= 0);
    }
  }
}

UnitTestAddRows()

static void kaldi::UnitTestAddRows ( )

static

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

References AssertEqual(), rnnlm::i, rnnlm::j, Rand(), MatrixBase< Real >::RowData(), and MatrixBase< Real >::SetRandn().

                              {
  for (MatrixIndexT p = 0; p < 10; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    Matrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    Matrix<Real> N1(num_rows2, num_cols),
        N2(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<int32> reorder(num_rows2);
    std::vector<const Real*> reorder_src(num_rows2,
                                         static_cast<const Real*>(NULL));
    for (int32 i = 0; i < num_rows2; i++) {
      reorder[i] = -1 + (Rand() % (num_rows1 + 1));
      if (reorder[i] != -1)
        reorder_src[i] = M.RowData(reorder[i]);
    }

    Real alpha =
        static_cast<Real>((Rand() % num_rows2)) / static_cast<Real>(num_rows1);

    N1.AddRows(alpha, M, &(reorder[0]));
    N2.AddRows(alpha, &(reorder_src[0]));

    for (int32 i = 0; i < num_rows2; i++) {
      if (reorder[i] != -1) {
        for (int32 j = 0; j < num_cols; j++) {
          O(i, j) += alpha * M(reorder[i], j);
        }
      }
    }

    AssertEqual(N1, O);
    AssertEqual(N2, O);
  }
}

UnitTestAddRowSumMatSpeed()

static void kaldi::UnitTestAddRowSumMatSpeed ( )

static

Definition at line 136 of file matrix-lib-speed-test.cc.

References VectorBase< Real >::AddRowSumMat(), Timer::Elapsed(), rnnlm::i, and MatrixBase< Real >::SetRandn().

                                        {
  Timer t;
  std::vector<MatrixIndexT> sizes;
  int32 size = 4, num = 5; 
  for(int32 i = 0; i < num; i++) {
    sizes.push_back(size);
    size *= 4;
  }

  for(size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];
    Matrix<Real> M(size, size);
    M.SetRandn();
    Vector<Real> Vr(size);

    int32 iter = 0; 
    BaseFloat time_in_secs = 0.02;
    Timer t1;
    for (;t1.Elapsed() < time_in_secs; iter++) {
      Vr.AddRowSumMat(0.4, M, 0.5);
    }

    BaseFloat fdim = size;
    BaseFloat gflops = (fdim * fdim * iter) / (t1.Elapsed() * 1.0e+09);
    CsvResult<Real>("AddRowSumMat", size, gflops, "gigaflops");
  }
  CsvResult<Real>(__func__, sizes.size(), t.Elapsed(), "seconds");
}

UnitTestAddSp()

static void kaldi::UnitTestAddSp ( )

static

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

References MatrixBase< Real >::AddSp(), AssertEqual(), rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                                    {
  for (MatrixIndexT i = 0;i< 10;i++) {
    MatrixIndexT dimM = 10+Rand()%10;
    SpMatrix<Real> S(dimM);
    S.SetRandn();
    Matrix<Real> M(S), N(S);
    N.AddSp(2.0, S);
    M.Scale(3.0);
    AssertEqual(M, N);
  }
}

UnitTestAddToDiag()

static void kaldi::UnitTestAddToDiag ( )

static

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

References PackedMatrix< Real >::AddToDiag(), AssertEqual(), rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                                        {
  MatrixIndexT N = 1 + Rand() % 10;
  SpMatrix<Real> S(N);
  S.SetRandn();
  SpMatrix<Real> S2(S);
  Real x = 0.5;
  S.AddToDiag(x);
  for (MatrixIndexT i = 0; i  < N; i++) S2(i, i) += x;
  AssertEqual(S, S2);
}

UnitTestAddToDiagMatrix()

static void kaldi::UnitTestAddToDiagMatrix ( )

static

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

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

                                                              {
  for (int p = 0; p < 2; p++) {
    MatrixIndexT dimM = 10 + Rand() % 2, dimN = 1 + Rand() % 5;
    Matrix<Real> M(dimM, dimN), Mcopy(M);
    BaseFloat alpha = 0.35;
    M.AddToDiag(alpha);
    for (MatrixIndexT i = 0; i < dimM && i < dimN; i++)
      Mcopy(i, i) += alpha;
    AssertEqual(M, Mcopy);
  }
}

UnitTestAddToRows()

static void kaldi::UnitTestAddToRows ( )

static

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

References MatrixBase< Real >::AddToRows(), AssertEqual(), rnnlm::i, rnnlm::j, Rand(), and MatrixBase< Real >::SetRandn().

                                {
  for (MatrixIndexT p = 0; p < 10; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    Matrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    Real alpha =
        static_cast<Real>((Rand() % num_rows2)) / static_cast<Real>(num_rows1);

    Matrix<Real> N(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<Real*> reorder_dst(num_rows1, static_cast<Real*>(NULL));
    unordered_map<MatrixIndexT, bool> used_index;
    for (int32 i = 0; i < num_rows1; i++) {
      MatrixIndexT index = -1 + (Rand() % (num_rows2 + 1));
      if (used_index.find(index) == used_index.end()) {
        used_index[index] = true;
      } else {
        index = -1;
      }
      if (index != -1) {
        reorder_dst[i] = N.RowData(index);
        for (int32 j = 0; j < num_cols; j++)
          O(index, j) += alpha * M(i, j);
      }
    }

    M.AddToRows(alpha, &(reorder_dst[0]));

    AssertEqual(N, O);
  }
}

UnitTestAddVec2Sp()

static void kaldi::UnitTestAddVec2Sp ( )

static

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

References SpMatrix< Real >::AddMat2Sp(), SpMatrix< Real >::AddVec2Sp(), AssertEqual(), MatrixBase< Real >::CopyDiagFromVec(), rnnlm::i, kNoTrans, Rand(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                                        {
  for (int32 i = 0; i < 10; i++) {
    int32 dim = Rand() % 5;
    SpMatrix<Real> S(dim);
    S.SetRandn();
    Vector<Real> v(dim);
    v.SetRandn();
    Matrix<Real> M(dim, dim);
    M.CopyDiagFromVec(v);

    SpMatrix<Real> T1(dim);
    T1.SetRandn();
    SpMatrix<Real> T2(T1);
    Real alpha = 0.33, beta = 4.5;
    T1.AddVec2Sp(alpha, v, S, beta);
    T2.AddMat2Sp(alpha, M, kNoTrans, S, beta);
    AssertEqual(T1, T2);
  }
}

UnitTestAddVecCross()

void kaldi::UnitTestAddVecCross

(

)

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

References VectorBase< Real >::AddVec(), VectorBase< Real >::AddVec2(), AssertEqual(), rnnlm::i, and VectorBase< Real >::SetRandn().

Referenced by MatrixUnitTest().

                           {

  Vector<float> v(5);
  v.SetRandn();
  Vector<double> w(5);
  w.SetRandn();

  Vector<float> wf(w);

  for (MatrixIndexT i = 0; i < 2; i++) {
    float f = 1.0;
    if (i == 0) f = 2.0;

    {
      Vector<float> sum1(5);
      Vector<double> sum2(5);
      Vector<float> sum3(5);
      sum1.AddVec(f, v); sum1.AddVec(f, w);
      sum2.AddVec(f, v); sum2.AddVec(f, w);
      sum3.AddVec(f, v); sum3.AddVec(f, wf);
      Vector<float> sum2b(sum2);
      AssertEqual(sum1, sum2b);
      AssertEqual(sum1, sum3);
    }

    {
      Vector<float> sum1(5);
      Vector<double> sum2(5);
      Vector<float> sum3(5);
      sum1.AddVec2(f, v); sum1.AddVec2(f, w);
      sum2.AddVec2(f, v); sum2.AddVec2(f, w);
      sum3.AddVec2(f, v); sum3.AddVec2(f, wf);
      Vector<float> sum2b(sum2);
      AssertEqual(sum1, sum2b);
      AssertEqual(sum1, sum3);
    }
  }
}

UnitTestAddVecToCols()

static void kaldi::UnitTestAddVecToCols ( )

static

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

References MatrixBase< Real >::AddVecToCols(), MatrixBase< Real >::AddVecVec(), AssertEqual(), rnnlm::i, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), VectorBase< Real >::Set(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                                           {
  std::vector<Real> sizes;
  sizes.push_back(16);
  sizes.push_back(128);
  for (int i = 0; i < 2; i++) {
    MatrixIndexT dimM = sizes[i] + Rand() % 10, dimN = sizes[i] + Rand() % 10;
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    Vector<float> v(M.NumRows());
    v.SetRandn();
    Matrix<Real> N(M);
    Vector<float> ones(M.NumCols());
    ones.Set(1.0);
    M.AddVecToCols(0.5, v);
    N.AddVecVec(0.5, v, ones);
    AssertEqual(M, N);
  }
}

UnitTestAddVecToColsSpeed()

static void kaldi::UnitTestAddVecToColsSpeed ( )

static

Definition at line 227 of file matrix-lib-speed-test.cc.

References MatrixBase< Real >::AddVecToCols(), Timer::Elapsed(), rnnlm::i, VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                        {
  Timer t;
  std::vector<MatrixIndexT> sizes;
  int32 size = 4, num = 5;
  for(int32 i = 0; i < num; i++) {
    sizes.push_back(size);
    size *= 4;
  }
  
  for(size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];
    Matrix<Real> M(size, size);
    M.SetRandn();
    Vector<Real> Vr(size);
    Vr.SetRandn();

    int32 iter = 0;  
    BaseFloat time_in_secs = 0.02;
    Timer t1;
    for (;t1.Elapsed() < time_in_secs; iter++) {
      M.AddVecToCols(0.5, Vr);    
    }

    BaseFloat fdim = size;
    BaseFloat gflops = (fdim * fdim * iter) / (t1.Elapsed() * 1.0e+09);
    CsvResult<Real>("AddVecToCols", size, gflops, "gigaflops");
  }
  CsvResult<Real>(__func__, sizes.size(), t.Elapsed(), "seconds");
}

UnitTestAddVecToRows()

static void kaldi::UnitTestAddVecToRows ( )

static

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

References MatrixBase< Real >::AddVecToRows(), MatrixBase< Real >::AddVecVec(), AssertEqual(), rnnlm::i, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), VectorBase< Real >::Set(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                                           {
  std::vector<Real> sizes;
  sizes.push_back(16);
  sizes.push_back(128);
  for (int i = 0; i < 2; i++) {
    MatrixIndexT dimM = sizes[i] + Rand() % 10, dimN = sizes[i] + Rand() % 10;
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    Vector<float> v(M.NumCols());
    v.SetRandn();
    Matrix<Real> N(M);
    Vector<float> ones(M.NumRows());
    ones.Set(1.0);
    M.AddVecToRows(0.5, v);
    N.AddVecVec(0.5, ones, v);
    AssertEqual(M, N);
  }
}

UnitTestAddVecToRowsSpeed()

static void kaldi::UnitTestAddVecToRowsSpeed ( )

static

Definition at line 196 of file matrix-lib-speed-test.cc.

References MatrixBase< Real >::AddVecToRows(), Timer::Elapsed(), rnnlm::i, VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                        {
  Timer t;
  std::vector<MatrixIndexT> sizes;
  int32 size = 4, num = 5;
  for(int32 i = 0; i < num; i++) {
    sizes.push_back(size);
    size *= 4;
  } 

  for(size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];    
    Matrix<Real> M(size, size);
    M.SetRandn();
    Vector<Real> Vc(size);
    Vc.SetRandn();
    
    int32 iter = 0;
    BaseFloat time_in_secs = 0.02;
    Timer t1; 
    for (;t1.Elapsed() < time_in_secs; iter++) {
      M.AddVecToRows(0.5, Vc); 
    }  

    BaseFloat fdim = size;
    BaseFloat gflops = (fdim * fdim * iter) / (t1.Elapsed() * 1.0e+09);
    CsvResult<Real>("AddVecToRows", size, gflops, "gigaflops");
  }
  CsvResult<Real>(__func__, sizes.size(), t.Elapsed(), "seconds");
}

UnitTestAddVecVec()

static void kaldi::UnitTestAddVecVec ( )

static

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

References MatrixBase< Real >::AddVecVec(), AssertEqual(), rnnlm::i, rnnlm::j, Rand(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                                        {
  for (int32 i = 0; i < 20; i++) {
    int32 dimM = 5 + Rand() % 10, dimN = 5 + Rand() % 10;

    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    Matrix<Real> N(M);
    Vector<float> v(dimM), w(dimN);
    v.SetRandn();
    w.SetRandn();
    float alpha = 0.2 * (Rand() % 10);
    M.AddVecVec(alpha, v, w);
    for (int32 j = 0; j < 20; j++) {
      int32 dimX = Rand() % dimM, dimY = Rand() % dimN;
      AssertEqual(M(dimX, dimY),
                  N(dimX, dimY) + alpha * v(dimX) * w(dimY));
    }
  }
}

UnitTestApplyExpSpecial()

static void kaldi::UnitTestApplyExpSpecial ( )

static

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

References MatrixBase< Real >::Add(), MatrixBase< Real >::ApplyExpSpecial(), MatrixBase< Real >::ApplyFloor(), AssertEqual(), KALDI_LOG, RandInt(), and MatrixBase< Real >::SetRandn().

                                                              {
  int32 rows = RandInt(1, 10), cols = RandInt(1, 10);
  Matrix<Real> mat(rows, cols);
  mat.SetRandn();
  Matrix<Real> A(mat), B(mat);
  A.ApplyExp();
  B.Add(1.0);
  B.ApplyFloor(1.0);
  A.Min(B); // min of exp(x) and max(1.0, x + 1).
  mat.ApplyExpSpecial();
  KALDI_LOG << "A is: " << A;
  AssertEqual(mat, A);
}

UnitTestApproxEqual()

void kaldi::UnitTestApproxEqual

(

)

Definition at line 255 of file kaldi-math-test.cc.

References ApproxEqual(), and KALDI_ASSERT.

Referenced by main().

                           {
  KALDI_ASSERT(ApproxEqual(1.0, 1.00001));
  KALDI_ASSERT(ApproxEqual(1.0, 1.00001, 0.001));
  KALDI_ASSERT(!ApproxEqual(1.0, 1.1));
  KALDI_ASSERT(!ApproxEqual(1.0, 1.01, 0.001));
  KALDI_ASSERT(!ApproxEqual(1.0, 0.0));
  KALDI_ASSERT(ApproxEqual(0.0, 0.0));
  KALDI_ASSERT(!ApproxEqual(0.0, 0.00001));
  KALDI_ASSERT(!ApproxEqual(std::numeric_limits<float>::infinity(),
                            -std::numeric_limits<float>::infinity()));
  KALDI_ASSERT(ApproxEqual(std::numeric_limits<float>::infinity(),
                           std::numeric_limits<float>::infinity()));
  KALDI_ASSERT(ApproxEqual(-std::numeric_limits<float>::infinity(),
                           -std::numeric_limits<float>::infinity()));
  KALDI_ASSERT(!ApproxEqual(-std::numeric_limits<float>::infinity(),
                            0));
  KALDI_ASSERT(!ApproxEqual(-std::numeric_limits<float>::infinity(),
                            1));
}

UnitTestAssertFunc()

void kaldi::UnitTestAssertFunc

(

)

Definition at line 220 of file kaldi-math-test.cc.

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

Referenced by main().

                          {  // Testing Assert** *functions
  for (int i = 1; i < 100; i++) {
    float f1 = Rand() % 10000 + 1, f2 = Rand() % 20 + 1;
    float tmp1 = f1 * f2;
    float tmp2 = (1/f1 + 1/f2);
    float add = f1 + f2;
    float addeql = tmp1 * tmp2;
    float thresh = 0.00001;
    AssertEqual(add, addeql, thresh);  // test AssertEqual()
  }
}

UnitTestAxpy()

static void kaldi::UnitTestAxpy ( )

static

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

References MatrixBase< Real >::AddMat(), AssertEqual(), rnnlm::i, InitRandNonsingular(), rnnlm::j, KALDI_ASSERT, kTrans, and Rand().

                                                   {

  for (MatrixIndexT i = 0;i< 10;i++) {
    MatrixIndexT dimM = 10+Rand()%10, dimN = 10+Rand()%10;
    Matrix<Real> M(dimM, dimN), N(dimM, dimN), O(dimN, dimM);

    InitRandNonsingular(&M); InitRandNonsingular(&N); InitRandNonsingular(&O);
    Matrix<Real> Morig(M);
    M.AddMat(0.5, N);
    for (MatrixIndexT i = 0;i < dimM;i++)
      for (MatrixIndexT j = 0;j < dimN;j++)
        KALDI_ASSERT(std::abs(M(i, j) - (Morig(i, j)+0.5*N(i, j))) < 0.1);
    M.CopyFromMat(Morig);
    M.AddMat(0.5, O, kTrans);
    for (MatrixIndexT i = 0;i < dimM;i++)
      for (MatrixIndexT j = 0;j < dimN;j++)
        KALDI_ASSERT(std::abs(M(i, j) - (Morig(i, j)+0.5*O(j, i))) < 0.1);
    {
      float f = 0.5 * (float) (Rand() % 3);
      Matrix<Real> N(dimM, dimM);
      InitRandNonsingular(&N);

      Matrix<Real> N2(N);
      Matrix<Real> N3(N);
      N2.AddMat(f, N2, kTrans);
      N3.AddMat(f, N, kTrans);
      AssertEqual(N2, N3);  // check works same with self as arg.
    }
  }
}

UnitTestBackpropLstmNonlinearity()

static void kaldi::UnitTestBackpropLstmNonlinearity ( )

static

Definition at line 321 of file cu-math-test.cc.

References AssertEqual(), kaldi::cu::BackpropLstmNonlinearity(), kaldi::cu::CpuBackpropLstmNonlinearity(), Timer::Elapsed(), rnnlm::i, KALDI_LOG, Rand(), RandInt(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                               {
  for (int i = 0; i < 3; i++) {
    int32 num_rows = 1 + Rand() % 200;
    int32 cell_dim = 1 + Rand() % 2000,
       dropout_dim = (RandInt(0, 1) == 0 ? 0 : 3);
//    KALDI_LOG << num_rows << ", " << cell_dim;

    Matrix<Real> hinput(num_rows, 5 * cell_dim + dropout_dim);
    Matrix<Real> hparams(3, cell_dim);
    Matrix<Real> houtput_deriv(num_rows, 2 * cell_dim);
    Matrix<double> hderiv_sum_in(5, cell_dim);
    Vector<Real> hself_repair_config(10);
    double count_in;
    Matrix<Real> hinput_deriv(num_rows, 5 * cell_dim + dropout_dim);
    Matrix<Real> hparams_deriv(3, cell_dim);
    Matrix<double> hvalue_sum_out(5, cell_dim);
    Matrix<double> hderiv_sum_out(5, cell_dim);
    Matrix<Real> hself_repair_sum_out(5, cell_dim);

    hinput.SetRandn();
    hparams.SetRandn();
    houtput_deriv.SetRandn();
    hderiv_sum_in.SetRandn();
    hself_repair_config.SetRandn();
    count_in = Rand() % num_rows;

    hinput_deriv.SetRandn();
    hparams_deriv.SetRandn();
    hvalue_sum_out.SetRandn();
    hderiv_sum_out.SetRandn();
    hself_repair_sum_out.SetRandn();

    CuMatrix<Real> dinput(hinput);
    CuMatrix<Real> dparams(hparams);
    CuMatrix<Real> doutput_deriv(houtput_deriv);
    CuMatrix<double> dderiv_sum_in(hderiv_sum_in);
    CuVector<Real> dself_repair_config(hself_repair_config);

    CuMatrix<Real> dinput_deriv(hinput_deriv);
    CuMatrix<Real> dparams_deriv(hparams_deriv);
    CuMatrix<double> dvalue_sum_out(hvalue_sum_out);
    CuMatrix<double> dderiv_sum_out(hderiv_sum_out);
    CuMatrix<Real> dself_repair_sum_out(hself_repair_sum_out);

    cu::CpuBackpropLstmNonlinearity(hinput, hparams, houtput_deriv,
                                    hderiv_sum_in, hself_repair_config,
                                    count_in, (MatrixBase<Real>*) NULL,
                                    (MatrixBase<Real>*) NULL,
                                    (MatrixBase<double>*) NULL,
                                    (MatrixBase<double>*) NULL,
                                    (MatrixBase<Real>*) NULL);
    cu::BackpropLstmNonlinearity(dinput, dparams, doutput_deriv, dderiv_sum_in,
                                 dself_repair_config, count_in,
                                 (CuMatrixBase<Real>*) NULL,
                                 (CuMatrixBase<Real>*) NULL,
                                 (CuMatrixBase<double>*) NULL,
                                 (CuMatrixBase<double>*) NULL,
                                 (CuMatrixBase<Real>*) NULL);

    cu::CpuBackpropLstmNonlinearity(hinput, hparams, houtput_deriv,
                                    hderiv_sum_in, hself_repair_config,
                                    count_in, (MatrixBase<Real>*) NULL,
                                    &hparams_deriv, &hvalue_sum_out,
                                    &hderiv_sum_out, &hself_repair_sum_out);
    cu::BackpropLstmNonlinearity(dinput, dparams, doutput_deriv, dderiv_sum_in,
                                 dself_repair_config, count_in,
                                 (CuMatrixBase<Real>*) NULL, &dparams_deriv,
                                 &dvalue_sum_out, &dderiv_sum_out,
                                 &dself_repair_sum_out);

    cu::CpuBackpropLstmNonlinearity(hinput, hparams, houtput_deriv,
                                    hderiv_sum_in, hself_repair_config,
                                    count_in, &hinput_deriv,
                                    (MatrixBase<Real>*) NULL,
                                    (MatrixBase<double>*) NULL,
                                    (MatrixBase<double>*) NULL,
                                    (MatrixBase<Real>*) NULL);
    cu::BackpropLstmNonlinearity(dinput, dparams, doutput_deriv, dderiv_sum_in,
                                 dself_repair_config, count_in, &dinput_deriv,
                                 (CuMatrixBase<Real>*) NULL,
                                 (CuMatrixBase<double>*) NULL,
                                 (CuMatrixBase<double>*) NULL,
                                 (CuMatrixBase<Real>*) NULL);

    cu::CpuBackpropLstmNonlinearity(hinput, hparams, houtput_deriv,
                                    hderiv_sum_in, hself_repair_config,
                                    count_in, &hinput_deriv, &hparams_deriv,
                                    &hvalue_sum_out, &hderiv_sum_out,
                                    &hself_repair_sum_out);
    cu::BackpropLstmNonlinearity(dinput, dparams, doutput_deriv, dderiv_sum_in,
                                 dself_repair_config, count_in, &dinput_deriv,
                                 &dparams_deriv, &dvalue_sum_out,
                                 &dderiv_sum_out, &dself_repair_sum_out);

    Matrix<Real> hdinput_deriv(dinput_deriv);
    Matrix<Real> hdparams_deriv(dparams_deriv);
    Matrix<double> hdvalue_sum_out(dvalue_sum_out);
    Matrix<double> hdderiv_sum_out(dderiv_sum_out);
    Matrix<Real> hdself_repair_sum_out(dself_repair_sum_out);

//    KALDI_LOG<< "input_deriv" << hinput_deriv << "d" << hdinput_deriv;
//    KALDI_LOG<< "hparams_deriv" << hparams_deriv << "d" << hdparams_deriv;
//    KALDI_LOG<< "hvalue_sum_out" << hvalue_sum_out << "d" << hdvalue_sum_out;
//    KALDI_LOG<< "hderiv_sum_out" << hderiv_sum_out << "d" << hdderiv_sum_out;
//    KALDI_LOG<< "hself_repair_sum_out" << hself_repair_sum_out << "d" << hdself_repair_sum_out;

    AssertEqual(hinput_deriv, hdinput_deriv);
    AssertEqual(hparams_deriv, hdparams_deriv);
    AssertEqual(hvalue_sum_out, hdvalue_sum_out);
    AssertEqual(hderiv_sum_out, hdderiv_sum_out);
    AssertEqual(hself_repair_sum_out, hdself_repair_sum_out);
  }

  for (int i = 16; i <= 2048; i *= 2) {
    BaseFloat time_in_secs = 0.025;
    int32 num_rows = i;
    int32 cell_dim = i;
    int32 dropout_dim = (RandInt(0, 1) == 0 ? 0 : 3);

    CuMatrix<Real> input(num_rows, 5 * cell_dim + dropout_dim);
    CuMatrix<Real> params(3, cell_dim);
    CuMatrix<Real> output_deriv(num_rows, 2 * cell_dim);
    CuMatrix<double> deriv_sum_in(5, cell_dim);
    CuVector<Real> self_repair_config(10);
    double count_in;

    CuMatrix<Real> input_deriv(num_rows, 5 * cell_dim + dropout_dim);
    CuMatrix<Real> params_deriv(3, cell_dim);
    CuMatrix<double> value_sum_out(5, cell_dim);
    CuMatrix<double> deriv_sum_out(5, cell_dim);
    CuMatrix<Real> self_repair_sum_out(5, cell_dim);

    input.SetRandn();
    params.SetRandn();
    output_deriv.SetRandn();
    deriv_sum_in.SetRandn();
    self_repair_config.SetRandn();
    count_in = Rand() % num_rows;

    Timer tim;
    int32 iter = 0;
    for (; tim.Elapsed() < time_in_secs; iter++)
      cu::BackpropLstmNonlinearity(input, params, output_deriv, deriv_sum_in,
                                   self_repair_config, count_in, &input_deriv,
                                   &params_deriv, &value_sum_out,
                                   &deriv_sum_out, &self_repair_sum_out);


    BaseFloat gflops = ((BaseFloat) i * i * iter) / (tim.Elapsed() * 1.0e+09);
    KALDI_LOG << "For BackpropLstmNonlinearity"
              << (sizeof(Real) == 8 ? "<double>" : "<float>") << ", for dim = "
              << i << ", speed was " << gflops << " gigaflops";
    if (tim.Elapsed() > 0.05)
      break;
  }
}

UnitTestCheck()

void kaldi::UnitTestCheck

(

)

Definition at line 2519 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), KALDI_LOG, CuMatrixBase< Real >::NumRows(), and MatrixBase< Real >::SetRandn().

                                             {
  Matrix<Real> Hi(100,111);
  Hi.SetRandn();

  CuMatrix<Real> Di(100,111);
  Di.CopyFromMat(Hi);

  CuMatrix<Real> Dj(Di);
  KALDI_LOG << Dj.NumRows();


}

UnitTestCholesky()

static void kaldi::UnitTestCholesky ( )

static

Definition at line 87 of file cu-test.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddVecVec(), AssertEqual(), CuMatrixBase< Real >::Cholesky(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, kNoTrans, kTrans, and Rand().

                                                       {
  for (MatrixIndexT iter = 0; iter < 3; iter++) {
    MatrixIndexT dim = 300 + Rand() %  200;
    // set dimension
    // computing the matrix for cholesky input
    // CuMatrix is cuda matrix class while Matrix is cpu matrix class
    CuMatrix<Real> A(dim, dim);
    Matrix<Real> B(dim, dim);
    Vector<Real> C(dim);
    for (MatrixIndexT i = 0; i < dim; i++) {
      B(i, i) = 1;
      C(i) = 1 + Rand() % 4;
    }
    B.AddVecVec(1.0, C, C);
    // copy the matrix to cudamatrix object
    A.CopyFromMat(B);
    A.CopyToMat(&B);
    //KALDI_LOG << B;
    // doing cholesky
    A.Cholesky();

    Matrix<Real> D(dim,dim);
    A.CopyToMat(&D);

    //KALDI_LOG << "D is: " << D;
    Matrix<Real> E(dim,dim);
    E.AddMatMat(1.0, D, kNoTrans, D, kTrans, 0.0);
    // check if the D'D is equal to B or not!
    AssertEqual(B, E);
  }
}

UnitTestClassifyRspecifier()

void kaldi::UnitTestClassifyRspecifier

(

)

Definition at line 177 of file kaldi-table-test.cc.

References ClassifyRspecifier(), KALDI_ASSERT, kArchiveRspecifier, kNoRspecifier, kScriptRspecifier, RspecifierOptions::once, and RspecifierOptions::sorted.

Referenced by main().

                                  {
  {
    std::string a = "ark:foo|";
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kArchiveRspecifier && fname == "foo|");
  }


  {
    std::string a = "b,ark:foo|";  // b, is ignored.
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kArchiveRspecifier && fname == "foo|");
  }

  {
    std::string a = "ark,b:foo|";  // , b is ignored.
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kArchiveRspecifier && fname == "foo|");
  }


  {
    std::string a = "scp,b:foo|";
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kScriptRspecifier && fname == "foo|");
  }

  {
    std::string a = "scp,scp,b:foo|";  // invalid as repeated.
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kNoRspecifier && fname == "");
  }

  {
    std::string a = "ark,scp,b:foo|";  // invalid as combined.
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kNoRspecifier && fname == "");
  }

  {
    std::string a = "scp,o:foo|";
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kScriptRspecifier && fname == "foo|");
    KALDI_ASSERT(opts.once);
  }

  {
    std::string a = "scp,no:foo|";
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kScriptRspecifier && fname == "foo|");
    KALDI_ASSERT(!opts.once);
  }

  {
    std::string a = "s,scp,no:foo|";
    std::string fname = "x";
    RspecifierOptions opts;
    RspecifierType ans = ClassifyRspecifier(a, &fname, &opts);
    KALDI_ASSERT(ans == kScriptRspecifier && fname == "foo|");
    KALDI_ASSERT(!opts.once && opts.sorted);
  }


  {
    std::string a = "scp:foo|";
    std::string fname = "x";
    RspecifierType ans = ClassifyRspecifier(a, &fname, NULL);
    KALDI_ASSERT(ans == kScriptRspecifier && fname == "foo|");
  }

  {
    std::string a = "scp:";  // empty fname valid.
    std::string fname = "x";
    RspecifierType ans = ClassifyRspecifier(a, &fname, NULL);
    KALDI_ASSERT(ans == kScriptRspecifier && fname == "");
  }

  {
    std::string a = "scp:";  // empty fname valid.
    RspecifierType ans = ClassifyRspecifier(a, NULL, NULL);
    KALDI_ASSERT(ans == kScriptRspecifier);
  }

  {
    std::string a = "";
    RspecifierType ans = ClassifyRspecifier(a, NULL, NULL);
    KALDI_ASSERT(ans == kNoRspecifier);
  }

  {
    std::string a = "scp";
    RspecifierType ans = ClassifyRspecifier(a, NULL, NULL);
    KALDI_ASSERT(ans == kNoRspecifier);
  }

  {
    std::string a = "ark";
    RspecifierType ans = ClassifyRspecifier(a, NULL, NULL);
    KALDI_ASSERT(ans == kNoRspecifier);
  }

  {
    std::string a = "ark:foo ";  // trailing space not allowed.
    RspecifierType ans = ClassifyRspecifier(a, NULL, NULL);
    KALDI_ASSERT(ans == kNoRspecifier);
  }

  // Testing it accepts the meaningless t, and b, prefixes.
  {
    std::string a = "b,scp:a", b;
    RspecifierType ans = ClassifyRspecifier(a, &b, NULL);
    KALDI_ASSERT(ans == kScriptRspecifier && b == "a");
  }
  {
    std::string a = "t,scp:a", b;
    RspecifierType ans = ClassifyRspecifier(a, &b, NULL);
    KALDI_ASSERT(ans == kScriptRspecifier && b == "a");
  }
  {
    std::string a = "b,ark:a", b;
    RspecifierType ans = ClassifyRspecifier(a, &b, NULL);
    KALDI_ASSERT(ans == kArchiveRspecifier && b == "a");
  }
  {
    std::string a = "t,ark:a", b;
    RspecifierType ans = ClassifyRspecifier(a, &b, NULL);
    KALDI_ASSERT(ans == kArchiveRspecifier && b == "a");
  }
}

UnitTestClassifyRxfilename()

void kaldi::UnitTestClassifyRxfilename

(

)

Definition at line 31 of file kaldi-io-test.cc.

References ClassifyRxfilename(), KALDI_ASSERT, kFileInput, kNoInput, kOffsetFileInput, kPipeInput, and kStandardInput.

Referenced by main().

                                  {
  KALDI_ASSERT(ClassifyRxfilename("") == kStandardInput);
  KALDI_ASSERT(ClassifyRxfilename(" ") == kNoInput);
  KALDI_ASSERT(ClassifyRxfilename(" a ") == kNoInput);
  KALDI_ASSERT(ClassifyRxfilename("a ") == kNoInput);
  KALDI_ASSERT(ClassifyRxfilename("a") == kFileInput);
  KALDI_ASSERT(ClassifyRxfilename("-") == kStandardInput);
  KALDI_ASSERT(ClassifyRxfilename("b|") == kPipeInput);
  KALDI_ASSERT(ClassifyRxfilename("|b") == kNoInput);
  KALDI_ASSERT(ClassifyRxfilename("b c|") == kPipeInput);
  KALDI_ASSERT(ClassifyRxfilename(" b c|") == kPipeInput);
  KALDI_ASSERT(ClassifyRxfilename("a b c:123") == kOffsetFileInput);
  KALDI_ASSERT(ClassifyRxfilename("a b c:3") == kOffsetFileInput);
  KALDI_ASSERT(ClassifyRxfilename("a b c:") == kFileInput);
  KALDI_ASSERT(ClassifyRxfilename("a b c/3") == kFileInput);
  KALDI_ASSERT(ClassifyRxfilename("ark,s,cs:a b c") == kNoInput);
  KALDI_ASSERT(ClassifyRxfilename("scp:a b c") == kNoInput);

}

UnitTestClassifyWspecifier()

void kaldi::UnitTestClassifyWspecifier

(

)

Definition at line 91 of file kaldi-table-test.cc.

References WspecifierOptions::binary, ClassifyWspecifier(), WspecifierOptions::flush, KALDI_ASSERT, kArchiveWspecifier, kBothWspecifier, kNoWspecifier, and kScriptWspecifier.

Referenced by main().

                                  {
  {
    std::string a = "b,ark:|foo";
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kArchiveWspecifier && ark == "|foo" && scp == "" &&
                 opts.binary == true);
  }

  {
    std::string a = "t,ark:|foo";
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kArchiveWspecifier && ark == "|foo" && scp == "" &&
                 opts.binary == false);
  }

  {
    std::string a = "t,scp:a b c d";
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kScriptWspecifier && ark == "" && scp == "a b c d" &&
                 opts.binary == false);
  }

  {
    std::string a = "t,ark,scp:a b,c,d";
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kBothWspecifier && ark == "a b" && scp == "c,d" &&
                 opts.binary == false);
  }

  {
    std::string a = "";
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kNoWspecifier);
  }

  {
    std::string a = " t,ark:boo";  // leading space not allowed.
    WspecifierType ans = ClassifyWspecifier(a, NULL, NULL, NULL);
    KALDI_ASSERT(ans == kNoWspecifier);
  }

  {
    std::string a = "t,ark:boo ";  // trailing space not allowed.
    WspecifierType ans = ClassifyWspecifier(a, NULL, NULL, NULL);
    KALDI_ASSERT(ans == kNoWspecifier);
  }

  {
    std::string a = "b,ark,scp:,";  // empty ark, scp fnames valid.
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kBothWspecifier && ark == "" && scp == "" &&
                 opts.binary == true);
  }

  {
    std::string a = "f,b,ark,scp:,";  // empty ark, scp fnames valid.
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kBothWspecifier && ark == "" && scp == "" &&
                 opts.binary == true && opts.flush == true);
  }

  {
    std::string a = "nf,b,ark,scp:,";  // empty ark, scp fnames valid.
    std::string ark = "x", scp = "y";
    WspecifierOptions opts;
    WspecifierType ans = ClassifyWspecifier(a, &ark, &scp, &opts);
    KALDI_ASSERT(ans == kBothWspecifier && ark == "" && scp == "" &&
                 opts.binary == true && opts.flush == false);
  }
}

UnitTestClassifyWxfilename()

void kaldi::UnitTestClassifyWxfilename

(

)

Definition at line 52 of file kaldi-io-test.cc.

References ClassifyWxfilename(), KALDI_ASSERT, kFileOutput, kNoOutput, kPipeOutput, and kStandardOutput.

Referenced by main().

                                  {
  KALDI_ASSERT(ClassifyWxfilename("") == kStandardOutput);
  KALDI_ASSERT(ClassifyWxfilename(" ") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename(" a ") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("a ") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("a") == kFileOutput);
  KALDI_ASSERT(ClassifyWxfilename("-") == kStandardOutput);
  KALDI_ASSERT(ClassifyWxfilename("b|") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("|b") == kPipeOutput);
  KALDI_ASSERT(ClassifyWxfilename("| b ") == kPipeOutput);
  KALDI_ASSERT(ClassifyWxfilename("b c|") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("a b c:123") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("ark,s,cs:a b c") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("scp:a b c") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("a b c:3") == kNoOutput);
  KALDI_ASSERT(ClassifyWxfilename("a b c:") == kFileOutput);
  KALDI_ASSERT(ClassifyWxfilename("a b c/3") == kFileOutput);
}

UnitTestComplexFft()

static void kaldi::UnitTestComplexFft ( )

static

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

References AssertEqual(), ComplexFft(), ComplexFt(), VectorBase< Real >::CopyFromVec(), Rand(), and VectorBase< Real >::Scale().

                                                         {

  // Make sure it inverts properly.
  for (MatrixIndexT N_ = 0; N_ < 100; N_+=3) {
    MatrixIndexT N = N_;
    if (N>=95) {
      N = ( Rand() % 150);
      N = N*N;  // big number.
    }

    MatrixIndexT twoN = 2*N;
    Vector<Real> v(twoN), w_base(twoN), w_alg(twoN), x_base(twoN), x_alg(twoN);

    v.SetRandn();

    if (N< 100) ComplexFt(v, &w_base, true);
    w_alg.CopyFromVec(v);
    ComplexFft(&w_alg, true);
    if (N< 100) AssertEqual(w_base, w_alg, 0.01*N);

    if (N< 100) ComplexFt(w_base, &x_base, false);
    x_alg.CopyFromVec(w_alg);
    ComplexFft(&x_alg, false);

    if (N< 100) AssertEqual(x_base, x_alg, 0.01*N);
    x_alg.Scale(1.0/N);
    AssertEqual(v, x_alg, 0.001*N);
  }
}

UnitTestComplexFft2()

static void kaldi::UnitTestComplexFft2 ( )

static

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

References ApproxEqual(), ComplexFft(), ComplexFt(), and KALDI_ASSERT.

                                                          {

  // Make sure it inverts properly.
  for (MatrixIndexT pos = 0; pos < 10; pos++) {
    for (MatrixIndexT N_ = 2; N_ < 15; N_+=2) {
      if ( pos < N_) {
        MatrixIndexT N = N_;
        Vector<Real> v(N), vorig(N), v2(N);
        v(pos)  = 1.0;
        vorig.CopyFromVec(v);
        // KALDI_LOG << "Original v:\n" << v;
        ComplexFft(&v, true);
        // KALDI_LOG << "one fft:\n" << v;
        ComplexFt(vorig, &v2, true);
        // KALDI_LOG << "one fft[baseline]:\n" << v2;
        if (!ApproxEqual(v, v2) ) {
          ComplexFft(&vorig, true);
          KALDI_ASSERT(0);
        }
        ComplexFft(&v, false);
        // KALDI_LOG << "one more:\n" << v;
        v.Scale(1.0/(N/2));
        if (!ApproxEqual(v, vorig)) {
          ComplexFft(&vorig, true);
          KALDI_ASSERT(0);
        }// AssertEqual(v, vorig);
      }
    }
  }
}

UnitTestComplexFt()

static void kaldi::UnitTestComplexFt ( )

static

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

References AssertEqual(), ComplexFt(), rnnlm::d, Rand(), and VectorBase< Real >::Scale().

                                                        {

  // Make sure it inverts properly.
  for (MatrixIndexT d = 0; d < 10; d++) {
    MatrixIndexT N = Rand() % 100, twoN = 2*N;
    Vector<Real> v(twoN), w(twoN), x(twoN);
    v.SetRandn();
    ComplexFt(v, &w, true);
    ComplexFt(w, &x, false);
    if (N>0) x.Scale(1.0/static_cast<Real>(N));
    AssertEqual(v, x);
  }
}

UnitTestComplexPower()

void kaldi::UnitTestComplexPower

(

)

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

References AssertEqual(), AttemptComplexPower(), rnnlm::i, KALDI_ASSERT, and RandGauss().

                            {
  // This tests a not-really-public function that's used in Matrix::Power().

  for (MatrixIndexT i = 0; i < 10; i++) {
    Real power = RandGauss();
    Real x = 2.0, y = 0.0;
    bool ans = AttemptComplexPower(&x, &y, power);
    KALDI_ASSERT(ans);
    AssertEqual(std::pow(static_cast<Real>(2.0), power), x);
    AssertEqual(y, 0.0);
  }
  {
    Real x, y;
    x = 0.5; y = -0.3;
    bool ans = AttemptComplexPower(&x, &y, static_cast<Real>(2.21));
    KALDI_ASSERT(ans);
    ans = AttemptComplexPower(&x, &y, static_cast<Real>(1.0/2.21));
    KALDI_ASSERT(ans);
    AssertEqual(x, 0.5);
    AssertEqual(y, -0.3);
  }
  {
    Real x, y;
    x = 0.5; y = -0.3;
    bool ans = AttemptComplexPower(&x, &y, static_cast<Real>(2.0));
    KALDI_ASSERT(ans);
    AssertEqual(x, 0.5*0.5 - 0.3*0.3);
    AssertEqual(y, -0.3*0.5*2.0);
  }

  {
    Real x, y;
    x = 1.0/std::sqrt(2.0); y = -1.0/std::sqrt(2.0);
    bool ans = AttemptComplexPower(&x, &y, static_cast<Real>(-1.0));
    KALDI_ASSERT(ans);
    AssertEqual(x, 1.0/std::sqrt(2.0));
    AssertEqual(y, 1.0/std::sqrt(2.0));
  }

  {
    Real x, y;
    x = 0.0; y = 0.0;
    bool ans = AttemptComplexPower(&x, &y, static_cast<Real>(-2.0));
    KALDI_ASSERT(!ans);  // zero; negative pow.
  }
  {
    Real x, y;
    x = -2.0; y = 0.0;
    bool ans = AttemptComplexPower(&x, &y, static_cast<Real>(1.5));
    KALDI_ASSERT(!ans);  // negative real case
  }
}

UnitTestCompressedMatrix()

static void kaldi::UnitTestCompressedMatrix ( )

static

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

References MatrixBase< Real >::Add(), MatrixBase< Real >::AddMat(), AssertEqual(), CompressedMatrix::CopyColToVec(), CompressedMatrix::CopyRowToVec(), CompressedMatrix::CopyToMat(), MatrixBase< Real >::FrobeniusNorm(), rnnlm::i, InitKaldiInputStream(), InitKaldiOutputStream(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, KALDI_WARN, kAutomaticMethod, kOneByteAuto, kSpeechFeature, kTwoByteAuto, rnnlm::n, CompressedMatrix::NumCols(), CompressedMatrix::NumRows(), Rand(), RandGauss(), RandInt(), CompressedMatrix::Read(), Matrix< Real >::Read(), MatrixBase< Real >::Row(), CompressedMatrix::Scale(), MatrixBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), CompressedMatrix::Write(), and MatrixBase< Real >::Write().

                                                               {
  // This is the basic test.

  CompressedMatrix empty_cmat;  // some tests on empty matrix
  KALDI_ASSERT(empty_cmat.NumRows() == 0);
  KALDI_ASSERT(empty_cmat.NumCols() == 0);

  // could set num_tot to 10000 for more thorough testing.
  MatrixIndexT num_failure = 0, num_tot = 1000, max_failure = 1;
  for (MatrixIndexT n = 0; n < num_tot; n++) {
    MatrixIndexT num_rows = Rand() % 20, num_cols = Rand() % 15;
    if (num_rows * num_cols == 0) {
      num_rows = 0;
      num_cols = 0;
    }
    if (rand() % 2 == 0 && num_cols != 0) {
      // smaller matrices are more likely to have problems.
      num_cols = 1 + Rand() % 3;
    }
    Matrix<Real> M(num_rows, num_cols);
    if (Rand() % 3 != 0) M.SetRandn();
    else {
      M.Add(RandGauss());
    }
    if (Rand() % 2 == 0 && num_rows != 0) {  // set one row to all the same value,
      // which is one possible pathology.
      // Give it large dynamic range to increase chance that it
      // is the largest or smallest value in the matrix.
      M.Row(Rand() % num_rows).Set(RandGauss() * 4.0);
    }
    double rand_val = RandGauss() * 4.0;
    // set a bunch of elements to all one value: increases
    // chance of pathologies.
    MatrixIndexT modulus = 1 + Rand() % 5;
    for (MatrixIndexT r = 0; r < num_rows; r++)
      for (MatrixIndexT c = 0; c < num_cols; c++)
        if (Rand() % modulus != 0) M(r, c) = rand_val;


    CompressionMethod method;
    switch(RandInt(0, 3)) {
      case 0: method = kAutomaticMethod; break;
      case 1: method = kSpeechFeature; break;
      case 2: method = kTwoByteAuto; break;
      default: method = kOneByteAuto; break;
    }

    CompressedMatrix cmat(M, method);
    KALDI_ASSERT(cmat.NumRows() == num_rows);
    KALDI_ASSERT(cmat.NumCols() == num_cols);

    Matrix<Real> M2(cmat.NumRows(), cmat.NumCols());
    cmat.CopyToMat(&M2);

    Matrix<Real> diff(M2);
    diff.AddMat(-1.0, M);

    { // Check that when compressing a matrix that has already been compressed,
      // and uncompressing, we get the same answer if using the same compression
      // method.
      // ok, actually, we can't guarantee this, so just limit the number of
      // failures.
      CompressedMatrix cmat2(M2, method);
      Matrix<Real> M3(cmat.NumRows(), cmat.NumCols());
      cmat2.CopyToMat(&M3);
      if (!M2.ApproxEqual(M3, 1.0e-04)) {
        KALDI_LOG << "cmat is: ";
        cmat.Write(std::cout, false);
        KALDI_LOG << "cmat2 is: ";
        cmat2.Write(std::cout, false);
        KALDI_WARN << "Matrices differ " << M2 << " vs. " << M3 << ", M2 range is "
                   << M2.Min() << " to " << M2.Max() << ", M3 range is "
                   << M3.Min() << " to " << M3.Max();
        num_failure++;
      }
    }

    if (num_rows > 0) {  // Check that the constructor accepting row and column offsets
                         // etc., works.
      if (RandInt(0, 1) == 0) {
        // test the ability of the self-constructor to do row-padding.  (used in
        // getting nnet3 examples without un-compressing and re-compressing the
        // data_.
        bool allow_row_padding = true;
        int32 row_offset = RandInt(-4, num_rows - 1),
            col_offset = RandInt(0, num_cols - 1),
            num_rows_sub = RandInt(1, 4 + num_rows - row_offset),
            num_cols_sub = RandInt(1, num_cols - col_offset);
        CompressedMatrix cmat_sub(cmat, row_offset, num_rows_sub,
                                  col_offset, num_cols_sub, allow_row_padding);
        Matrix<Real> M2_sub(num_rows_sub, num_cols_sub);
        for (int32 row = 0; row < num_rows_sub; row++) {
          int32 old_row = row + row_offset;
          if (old_row < 0) old_row = 0;
          else if (old_row >= num_rows) { old_row = num_rows - 1; }
          SubVector<Real> M2_sub_row(M2_sub, row),
              M2_row(M2, old_row),
              M2_row_part(M2_row, col_offset, num_cols_sub);
          M2_sub_row.CopyFromVec(M2_row_part);
        }
        Matrix<Real> M3_sub(cmat_sub);
        M3_sub.AddMat(-1.0, M2_sub);
        KALDI_ASSERT(M3_sub.FrobeniusNorm() / (num_rows_sub * num_cols_sub) <
                     1.0e-03);
      } else {
        int32 row_offset = RandInt(0, num_rows - 1),
            col_offset = RandInt(0, num_cols - 1),
            num_rows_sub = RandInt(1, num_rows - row_offset),
            num_cols_sub = RandInt(1, num_cols - col_offset);
        CompressedMatrix cmat_sub(cmat, row_offset, num_rows_sub,
                                  col_offset, num_cols_sub);
        SubMatrix<Real> M2_sub(M2, row_offset, num_rows_sub,
                               col_offset, num_cols_sub);
        Matrix<Real> M3_sub(cmat_sub);
        M3_sub.AddMat(-1.0, M2_sub);
        KALDI_ASSERT(M3_sub.FrobeniusNorm() / (num_rows_sub * num_cols_sub) <
                     1.0e-03);
      }
    } else {
      CompressedMatrix cmat_sub(cmat, 0, 0, 0, 0);
    }

    // test CopyRowToVec
    for (MatrixIndexT i = 0; i < num_rows; i++) {
      Vector<Real> V(num_cols);
      cmat.CopyRowToVec(i, &V);  // get row.
      for (MatrixIndexT k = 0; k < num_cols; k++) {
        AssertEqual(M2(i, k), V(k));
      }
    }

    // test CopyColToVec
    for (MatrixIndexT i = 0; i < num_cols; i++) {
      Vector<Real> V(num_rows);
      cmat.CopyColToVec(i, &V);  // get col.
      for (MatrixIndexT k = 0;k < num_rows;k++) {
        AssertEqual(M2(k, i), V(k));
      }
    }

    //test of getting a submatrix
    if(num_rows != 0 && num_cols != 0){
      MatrixIndexT sub_row_offset = Rand() % num_rows,
          sub_col_offset = Rand() % num_cols;
      // to make sure we don't mod by zero
      MatrixIndexT num_subrows = Rand() % (num_rows-sub_row_offset),
          num_subcols = Rand() % (num_cols-sub_col_offset);
      if(num_subrows == 0 || num_subcols == 0){  // in case we randomized to
        // empty matrix, at least make it correct
        num_subrows = 0;
        num_subcols = 0;
      }
      Matrix<Real> Msub(num_subrows, num_subcols);
      cmat.CopyToMat(sub_row_offset, sub_col_offset, &Msub);
      for (MatrixIndexT i = 0; i < num_subrows; i++) {
        for (MatrixIndexT k = 0;k < num_subcols;k++) {
          AssertEqual(M2(i+sub_row_offset, k+sub_col_offset), Msub(i, k));
        }
      }
    }

    { // Check Scale() method for compressedMatrix.
      for (int32 t = 0; t < 10; t++) {
        float alpha = 0.1;
        MatrixIndexT num_rows = 4 + Rand() % 20,
          num_cols = 10 + Rand() % 50;
        Matrix<Real> M(num_rows, num_cols);
        M.SetRandn();
        CompressedMatrix cmat(M);
        Matrix<Real> scaled_comp_mat(num_rows, num_cols),
          scaled_mat(M);
        scaled_mat.Scale(alpha);
        cmat.Scale(alpha);
        cmat.CopyToMat(&scaled_comp_mat);
        AssertEqual(scaled_comp_mat, scaled_mat);
      }
    }
    if (n < 5) {  // test I/O.
      bool binary = (n % 2 == 1);
      {
        std::ofstream outs("tmpf", std::ios_base::out |std::ios_base::binary);
        InitKaldiOutputStream(outs, binary);
        cmat.Write(outs, binary);
      }
      CompressedMatrix cmat2;
      {
        bool binary_in;
        std::ifstream ins("tmpf", std::ios_base::in | std::ios_base::binary);
        InitKaldiInputStream(ins, &binary_in);
        cmat2.Read(ins, binary_in);
      }
#if 1
      { // check that compressed-matrix can be read as matrix.
        bool binary_in;
        std::ifstream ins("tmpf", std::ios_base::in | std::ios_base::binary);
        InitKaldiInputStream(ins, &binary_in);
        Matrix<Real> mat1;
        mat1.Read(ins, binary_in);
        Matrix<Real> mat2(cmat2);
        AssertEqual(mat1, mat2);
      }
#endif


      { // check that matrix can be read as compressed-matrix.
        Matrix<Real> mat1(cmat);
        {
          std::ofstream outs("tmpf", std::ios_base::out |std::ios_base::binary);
          InitKaldiOutputStream(outs, binary);
          mat1.Write(outs, binary);
        }
        bool binary_in;
        std::ifstream ins("tmpf", std::ios_base::in | std::ios_base::binary);
        InitKaldiInputStream(ins, &binary_in);
        CompressedMatrix cmat2;
        cmat2.Read(ins, binary_in);
        Matrix<Real> mat2(cmat2);
        AssertEqual(mat1, mat2);
      }


      Matrix<Real> M3(cmat2.NumRows(), cmat2.NumCols());
      cmat2.CopyToMat(&M3);
      AssertEqual(M2, M3); // tests I/O of CompressedMatrix.

      CompressedMatrix cmat3(cmat2); // testing self-constructor, which
      // tests assignment operator.
      Matrix<Real> M4(cmat3.NumRows(), cmat3.NumCols());
      cmat3.CopyToMat(&M4);
      AssertEqual(M2, M4);
    }
    KALDI_LOG << "M = " << M;
    KALDI_LOG << "M2 = " << M2;
    double tot = M.FrobeniusNorm(), err = diff.FrobeniusNorm();
    KALDI_LOG << "Compressed matrix, tot = " << tot << ", diff = "
              << err;
    if (err > 0.015 * tot) {
      KALDI_WARN << "Failure in compressed-matrix test.";
      num_failure++;
    }
  }
  if (num_failure > max_failure)
    KALDI_ERR << "Too many failures in compressed matrix test " << num_failure
              << " > " << max_failure;

  unlink("tmpf");
}

UnitTestCompressedMatrix2()

static void kaldi::UnitTestCompressedMatrix2 ( )

static

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

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kOneByteZeroOne, kTwoByteSignedInteger, and RandInt().

                                                                {
  // These are some new tests added after we add the capability to
  // specify the compression type.

  for (int32 i = 0; i < 10; i++) {
    // test that the kTwoByteSignedInteger  method works.
    int32 num_rows = RandInt(1, 5), num_cols = RandInt(1, 10);
    Matrix<Real> mat(num_rows, num_cols);
    for (int32 j = 0; j < num_rows; j++) {
      for (int32 k = 0; k < num_cols; k++) {
        mat(j, k) = RandInt(-32768, 32767);
      }
    }
    CompressedMatrix cmat(mat, kTwoByteSignedInteger);

    Matrix<Real> mat2(cmat);

    // Check that they are exactly equal.  These integers should all be
    // exactly representable, and exactly reconstructed after compression.
    KALDI_ASSERT(ApproxEqual(mat, mat2, Real(0.0)));
  }


  for (int32 i = 0; i < 10; i++) {
    // test that the kOneByteZeroOne compression method works.
    int32 num_rows = RandInt(1, 5), num_cols = RandInt(1, 10);
    Matrix<Real> mat(num_rows, num_cols);
    for (int32 j = 0; j < num_rows; j++) {
      for (int32 k = 0; k < num_cols; k++) {
        mat(j, k) = RandInt(0, 255) / 255.0;
      }
    }
    CompressedMatrix cmat(mat, kOneByteZeroOne);

    Matrix<Real> mat2(cmat);

    // Check that they are almost exactly equal.  (It's not 100% exact because
    // 1.0 / 255.0 is not exactly representable.
    KALDI_ASSERT(ApproxEqual(mat, mat2, Real(1.00001)));
  }

}

UnitTestComputeGPE()

static void kaldi::UnitTestComputeGPE ( )

static

Definition at line 327 of file pitch-functions-test.cc.

References ConvertIntToString(), rnnlm::i, rnnlm::j, KALDI_LOG, MatrixBase< Real >::NumRows(), and Matrix< Real >::Read().

Referenced by UnitTestFeatWithKeele().

                                 {
  KALDI_LOG << "=== UnitTestComputeGPE ===\n";
  int32 wrong_pitch = 0, tot_voiced = 0, tot_unvoiced = 0, num_frames = 0;
  BaseFloat tol = 0.1, avg_d_kpitch = 0, real_pitch = 0;
  for (int32 i = 1; i < 11; i++) {
    std::string wavefile;
    std::string num;
    if (i < 6) {
      num = "f" + ConvertIntToString(i) + "nw0000";
    } else {
      num = "m" + ConvertIntToString(i-5) + "nw0000";
    }
    Matrix<BaseFloat> gross_pitch;
    std::string pitchfile = "keele/keele-true-lags/"+num+".txt";
    std::ifstream pitch(pitchfile.c_str());
    gross_pitch.Read(pitch, false);
    Matrix<BaseFloat> kaldi_pitch;
    std::string kfile = "keele/tmp/+"+num+"-kaldi.txt";
    std::ifstream kpitch(kfile.c_str());
    kaldi_pitch.Read(kpitch, false);
    num_frames = std::min(kaldi_pitch.NumRows(),gross_pitch.NumRows());
    for (int32 j = 1; j < num_frames; j++) {
      if (gross_pitch(j,0) > 0.0) {
        tot_voiced++;
        real_pitch = 20000.0/gross_pitch(j,0);
        if (fabs((real_pitch - kaldi_pitch(j,1))/real_pitch) > tol)
          wrong_pitch++;
      } else if (gross_pitch(j,0) == 0.0 && gross_pitch(j-1,0) == 0.0) {
        tot_unvoiced++;
        avg_d_kpitch += fabs(kaldi_pitch(j,1) - kaldi_pitch(j-1,1));
      }
    }
  }
  BaseFloat GPE = 1.0 * wrong_pitch / tot_voiced;
  KALDI_LOG << " Gross Pitch Error with Rel.Error " << tol << " is " << GPE;
  KALDI_LOG << "Average Kaldi delta_pitch for unvoiced regions " << avg_d_kpitch/tot_unvoiced;
}

UnitTestConfigLineParse()

void kaldi::UnitTestConfigLineParse

(

)

Definition at line 328 of file text-utils-test.cc.

References ConfigLine::FirstToken(), ConfigLine::GetValue(), ConfigLine::HasUnusedValues(), KALDI_ASSERT, ConfigLine::ParseLine(), and ConfigLine::UnusedValues().

Referenced by main().

                               {
  std::string str;
  {
    ConfigLine cfl;
    str = "a-b xx=yyy foo=bar  baz=123 ba=1:2";
    bool status = cfl.ParseLine(str);
    KALDI_ASSERT(status && cfl.FirstToken() == "a-b");

    KALDI_ASSERT(cfl.HasUnusedValues());
    std::string str_value;
    KALDI_ASSERT(cfl.GetValue("xx", &str_value));
    KALDI_ASSERT(str_value == "yyy");
    KALDI_ASSERT(cfl.HasUnusedValues());
    KALDI_ASSERT(cfl.GetValue("foo", &str_value));
    KALDI_ASSERT(str_value == "bar");
    KALDI_ASSERT(cfl.HasUnusedValues());
    KALDI_ASSERT(!cfl.GetValue("xy", &str_value));
    KALDI_ASSERT(cfl.GetValue("baz", &str_value));
    KALDI_ASSERT(str_value == "123");

    std::vector<int32> int_values;
    KALDI_ASSERT(!cfl.GetValue("xx", &int_values));
    KALDI_ASSERT(cfl.GetValue("baz", &int_values));
    KALDI_ASSERT(cfl.HasUnusedValues());
    KALDI_ASSERT(int_values.size() == 1 && int_values[0] == 123);
    KALDI_ASSERT(cfl.GetValue("ba", &int_values));
    KALDI_ASSERT(int_values.size() == 2 && int_values[0] == 1 && int_values[1] == 2);
    KALDI_ASSERT(!cfl.HasUnusedValues());
  }

  {
    ConfigLine cfl;
    str = "a-b baz=x y z pp = qq ab =cd ac= bd";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "a-b baz=x y z pp = qq ab=cd ac=bd";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "foo-bar";
    KALDI_ASSERT(cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "foo-bar a=b c d f=g";
    std::string value;
    KALDI_ASSERT(cfl.ParseLine(str) && cfl.FirstToken() == "foo-bar" &&
                 cfl.GetValue("a", &value)  && value == "b c d" &&
                 cfl.GetValue("f", &value) && value == "g" &&
                 !cfl.HasUnusedValues());
  }
  {
    ConfigLine cfl;
    str = "zzz a=b baz";
    KALDI_ASSERT(cfl.ParseLine(str) && cfl.FirstToken() == "zzz" &&
                 cfl.UnusedValues() == "a=b baz");
  }
  {
    ConfigLine cfl;
    str = "xxx a=b baz ";
    KALDI_ASSERT(cfl.ParseLine(str) && cfl.UnusedValues() == "a=b baz");
  }
  {
    ConfigLine cfl;
    str = "xxx a=b =c";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "xxx baz='x y z' pp=qq ab=cd ac=bd";
    KALDI_ASSERT(cfl.ParseLine(str) && cfl.FirstToken() == "xxx");
    std::string str_value;
    KALDI_ASSERT(cfl.GetValue("baz", &str_value));
    KALDI_ASSERT(str_value == "x y z");
    KALDI_ASSERT(cfl.GetValue("pp", &str_value));
    KALDI_ASSERT(str_value == "qq");
    KALDI_ASSERT(cfl.UnusedValues() == "ab=cd ac=bd");
    KALDI_ASSERT(cfl.GetValue("ab", &str_value));
    KALDI_ASSERT(str_value == "cd");
    KALDI_ASSERT(cfl.UnusedValues() == "ac=bd");
    KALDI_ASSERT(cfl.HasUnusedValues());
    KALDI_ASSERT(cfl.GetValue("ac", &str_value));
    KALDI_ASSERT(str_value == "bd");
    KALDI_ASSERT(!cfl.HasUnusedValues());
  }

  {
    ConfigLine cfl;
    str = "x baz= pp = qq flag=t ";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = " x baz= pp=qq flag=t  ";
    KALDI_ASSERT(cfl.ParseLine(str) && cfl.FirstToken() == "x");

    std::string str_value;
    KALDI_ASSERT(cfl.GetValue("baz", &str_value));
    KALDI_ASSERT(str_value == "");
    KALDI_ASSERT(cfl.GetValue("pp", &str_value));
    KALDI_ASSERT(str_value == "qq");
    KALDI_ASSERT(cfl.HasUnusedValues());
    KALDI_ASSERT(cfl.GetValue("flag", &str_value));
    KALDI_ASSERT(str_value == "t");
    KALDI_ASSERT(!cfl.HasUnusedValues());

    bool bool_value = false;
    KALDI_ASSERT(cfl.GetValue("flag", &bool_value));
    KALDI_ASSERT(bool_value);
  }

  {
    ConfigLine cfl;
    str = "xx _baz=a -pp=qq";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "xx 0baz=a pp=qq";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "xx -baz=a pp=qq";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = "xx _baz'=a pp=qq";
    KALDI_ASSERT(!cfl.ParseLine(str));
  }
  {
    ConfigLine cfl;
    str = " baz=g";
    KALDI_ASSERT(cfl.ParseLine(str) && cfl.FirstToken() == "");
    bool flag;
    KALDI_ASSERT(!cfl.GetValue("baz", &flag));
  }
  {
    ConfigLine cfl;
    str = "xx _baz1=a pp=qq";
    KALDI_ASSERT(cfl.ParseLine(str));

    std::string str_value;
    KALDI_ASSERT(cfl.GetValue("_baz1", &str_value));
  }
}

UnitTestConstructor()

static void kaldi::UnitTestConstructor ( )

static

Definition at line 216 of file cu-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, rnnlm::j, KALDI_LOG, and kTakeLower.

                                                          {
  MatrixIndexT dim = 8;
  CuMatrix<Real> A(dim,dim);
  Matrix<Real> B(dim,dim);
  for (MatrixIndexT i = 0; i < dim; i++) {
    for (MatrixIndexT j = 0; j <=i; j++)
      B(i,j) = i+j;
    for (MatrixIndexT j = i+1; j < dim; j++)
      B(i,j) = i+j+4;
  }
  KALDI_LOG << "A is : ";
  KALDI_LOG << B;
  A.CopyFromMat(B);
  //CuSpMatrix<Real> C(dim);
  //C.CopyFromMat(A,kTakeLower);
  CuSpMatrix<Real> C(A, kTakeLower);
  SpMatrix<Real> D(dim);
  C.CopyToSp(&D);
  KALDI_LOG << "C is : ";
  for (MatrixIndexT i = 0; i < dim; i++) {
    for (MatrixIndexT j = 0; j <= i; j++)
      std::cout << D(i,j) << " ";
    std::cout << '\n';
  }
}

UnitTestCopyCols()

static void kaldi::UnitTestCopyCols ( )

static

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

References AssertEqual(), rnnlm::i, rnnlm::j, Rand(), and MatrixBase< Real >::SetRandn().

                               {
  for (MatrixIndexT p = 0; p < 10; p++) {
    MatrixIndexT num_cols1 = 10 + Rand() % 10,
        num_cols2 = 10 + Rand() % 10,
        num_rows = 10 + Rand() % 10;
    Matrix<Real> M(num_rows, num_cols1);
    M.SetRandn();

    Matrix<Real> N(num_rows, num_cols2), O(num_rows, num_cols2);
    std::vector<int32> reorder(num_cols2);
    for (int32 i = 0; i < num_cols2; i++)
      reorder[i] = -1 + (Rand() % (num_cols1 + 1));

    N.CopyCols(M, &(reorder[0]));

    for (int32 i = 0; i < num_rows; i++)
      for (int32 j = 0; j < num_cols2; j++)
        if (reorder[j] < 0) O(i, j) = 0;
        else O(i, j) = M(i, reorder[j]);
    AssertEqual(N, O);
  }
}

UnitTestCopyFromMat()

static void kaldi::UnitTestCopyFromMat ( )

static

Definition at line 294 of file cu-test.cc.

References CuSpMatrix< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, rnnlm::j, KALDI_LOG, kTakeLower, kTakeMean, and kTakeUpper.

                                                          {
  MatrixIndexT dim = 8;
  CuMatrix<Real> A(dim,dim);
  Matrix<Real> B(dim,dim);
  for (MatrixIndexT i = 0; i < dim; i++) {
    for (MatrixIndexT j = 0; j <=i; j++)
      B(i,j) = i+j;
    for (MatrixIndexT j = i+1; j < dim; j++)
      B(i,j) = i+j+4;
  }
  KALDI_LOG << "A is : ";
  KALDI_LOG << B;
  A.CopyFromMat(B);
  CuSpMatrix<Real> C(dim);
  C.CopyFromMat(A,kTakeLower);
  SpMatrix<Real> D(dim);
  C.CopyToSp(&D);
  KALDI_LOG << "C is : ";
  for (MatrixIndexT i = 0; i < dim; i++) {
    for (MatrixIndexT j = 0; j <= i; j++)
      std::cout << D(i,j) << " ";
    std::cout << '\n';
  }
  C.CopyFromMat(A,kTakeUpper);
  C.CopyToSp(&D);
  KALDI_LOG << "C is : ";
  for (MatrixIndexT i = 0; i < dim; i++) {
    for (MatrixIndexT j = 0; j <= i; j++)
      std::cout << D(i,j) << " ";
    std::cout << '\n';
  }

  C.CopyFromMat(A,kTakeMean);
  C.CopyToSp(&D);
  KALDI_LOG << "C is : ";
  for (MatrixIndexT i = 0; i < dim; i++) {
    for (MatrixIndexT j = 0; j <= i; j++)
      std::cout << D(i,j) << " ";
    std::cout << '\n';
  }

  //KALDI_LOG << D;
}

UnitTestCopyRows()

static void kaldi::UnitTestCopyRows ( )

static

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

References AssertEqual(), rnnlm::i, rnnlm::j, Rand(), MatrixBase< Real >::RowData(), and MatrixBase< Real >::SetRandn().

                               {
  for (MatrixIndexT p = 0; p < 10; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    Matrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    Matrix<Real> N1(num_rows2, num_cols),
        N2(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<int32> reorder(num_rows2);
    std::vector<const Real*> reorder_src(num_rows2,
                                         static_cast<const Real*>(NULL));
    for (int32 i = 0; i < num_rows2; i++) {
      reorder[i] = -1 + (Rand() % (num_rows1 + 1));
      if (reorder[i] != -1)
        reorder_src[i] = M.RowData(reorder[i]);
    }

    N1.CopyRows(M, &(reorder[0]));
    N2.CopyRows(&(reorder_src[0]));

    for (int32 i = 0; i < num_rows2; i++)
      for (int32 j = 0; j < num_cols; j++)
        if (reorder[i] < 0) O(i, j) = 0;
        else O(i, j) = M(reorder[i], j);

    AssertEqual(N1, O);
    AssertEqual(N2, O);
  }
}

UnitTestCopyRowsAndCols()

static void kaldi::UnitTestCopyRowsAndCols ( )

static

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

References MatrixBase< Real >::CopyRowsFromVec(), rnnlm::i, KALDI_ASSERT, Rand(), and VectorBase< Real >::SetRandn().

                                                              {
  // Test other mode of CopyRowsFromVec, and CopyColsFromVec,
  // where vector is duplicated.
  for (MatrixIndexT i = 0; i < 30; i++) {
    MatrixIndexT dimM = 1 + Rand() % 5, dimN = 1 + Rand() % 5;
    Vector<float> w(dimN); // test cross-type version of
    // CopyRowsFromVec.
    Vector<Real> v(dimM);
    Matrix<Real> M(dimM, dimN), N(dimM, dimN);
    v.SetRandn();
    w.SetRandn();
    M.CopyColsFromVec(v);
    N.CopyRowsFromVec(w);
    for (MatrixIndexT r = 0; r < dimM; r++) {
      for (MatrixIndexT c = 0; c < dimN; c++) {
        KALDI_ASSERT(M(r, c) == v(r));
        KALDI_ASSERT(N(r, c) == w(c));
      }
    }
  }
}

UnitTestCopySp() [1/2]

static void kaldi::UnitTestCopySp ( )

static

CuSpMatrix<Real> E(dim);

Definition at line 242 of file cu-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), KALDI_LOG, kTakeLower, kUndefined, Rand(), and CuMatrixBase< Real >::Stride().

                                                     {
  // Checking that the various versions of copying
  // matrix to SpMatrix work the same in the symmetric case.
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    int32 dim = 5 + Rand() %  10;
    SpMatrix<Real> A(dim), B(dim);
    A.SetRandn();
    Matrix<Real> C(A);
    //CuMatrix<Real> D(C);

    {
      CuMatrix<Real> D2(dim,dim);
      D2.CopyFromMat(C);
      KALDI_LOG << "D2 is " << D2;
      CuSpMatrix<Real> E(D2.NumRows(), kUndefined);
      KALDI_LOG << "D2 is " << D2;
      E.CopyFromMat(D2, kTakeLower);
      KALDI_LOG << "D2 is " << D2;
    }

    CuMatrix<Real> D(dim,dim);
    D.CopyFromMat(C);
    KALDI_LOG << "D stride is : " << D.Stride() <<'\n';

    CuSpMatrix<Real> E(D,kTakeLower);
    //E.CopyFromMat(D,kTakeLower);
    /*
    KALDI_LOG << D.NumRows();
    //E.CopyFromMat(D, kTakeMean);
    //E(D, kTakeMean);
    //KALDI_LOG << E.NumRows();

    E.CopyToMat(&B);
    AssertEqual(A, B);
    B.SetZero();
    //E.CopyFromMat(D, kTakeLower);
    CuSpMatrix<Real> F(D,kTakeLower);
    //F(D, kTakeLower);
    F.CopyToMat(&B);
    AssertEqual(A, B);
    B.SetZero();
    //E.CopyFromMat(D, kTakeUpper);
    //E(D, kTakeUpper);
    CuSpMatrix<Real> G(D, kTakeUpper);
    G.CopyToMat(&B);
    AssertEqual(A, B);
    */
  }

}

UnitTestCopySp() [2/2]

static void kaldi::UnitTestCopySp ( )

static

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

References AssertEqual(), SpMatrix< Real >::CopyFromMat(), kTakeLower, kTakeMean, kTakeMeanAndCheck, kTakeUpper, Rand(), and PackedMatrix< Real >::SetZero().

                                                     {
  // Checking that the various versions of copying
  // matrix to SpMatrix work the same in the symmetric case.
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    int32 dim = 5 + Rand() %  10;
    SpMatrix<Real> S(dim), T(dim);
    S.SetRandn();
    Matrix<Real> M(S);
    T.CopyFromMat(M, kTakeMeanAndCheck);
    AssertEqual(S, T);
    T.SetZero();
    T.CopyFromMat(M, kTakeMean);
    AssertEqual(S, T);
    T.SetZero();
    T.CopyFromMat(M, kTakeLower);
    AssertEqual(S, T);
    T.SetZero();
    T.CopyFromMat(M, kTakeUpper);
    AssertEqual(S, T);
  }
}

UnitTestCopyToRows()

static void kaldi::UnitTestCopyToRows ( )

static

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

References AssertEqual(), MatrixBase< Real >::CopyToRows(), rnnlm::i, rnnlm::j, Rand(), and MatrixBase< Real >::SetRandn().

                                 {
  for (MatrixIndexT p = 0; p < 10; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    Matrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    Matrix<Real> N(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<Real*> reorder_dst(num_rows1,
                                   static_cast<Real*>(NULL));
    unordered_map<MatrixIndexT, bool> used_index;
    for (int32 i = 0; i < num_rows1; i++) {
      MatrixIndexT index = -1 + (Rand() % (num_rows2 + 1));
      if (used_index.find(index) == used_index.end()) {
        used_index[index] = true;
      } else {
        index = -1;
      }
      if (index != -1) {
        reorder_dst[i] = N.RowData(index);
        for (int32 j = 0; j < num_cols; j++)
          O(index, j) = M(i, j);
      }
    }

    M.CopyToRows(&(reorder_dst[0]));

    AssertEqual(N, O);
  }
}

UnitTestCuApproxEqual()

static void kaldi::UnitTestCuApproxEqual ( )

static

Definition at line 2157 of file cu-matrix-test.cc.

References rnnlm::i, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                    {
  Real tol = 0.1;
  for (int32 i = 0; i < 2; i++) {
    int32 M = 1 + Rand() % 10, N = 1 + Rand() % 10;
    CuMatrix<Real> A(M, N), B(M, N);
    A.SetRandn();
    B.SetRandn();
    Matrix<Real> diff(A), Bm(B);
    diff.AddMat(-1.0, Bm);
    Real norm = diff.FrobeniusNorm();
    KALDI_ASSERT((norm <= tol * A.FrobeniusNorm()) == (A.ApproxEqual(B, tol)));
    tol *= 2.0;
  }
}

UnitTestCuArray()

static void kaldi::UnitTestCuArray ( )

static

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

References AssertEqual(), CuArrayBase< T >::CopyToHost(), CuArrayBase< T >::CopyToVec(), CuArrayBase< T >::Dim(), rnnlm::i, KALDI_ASSERT, kSetZero, Rand(), CuArray< T >::Resize(), and CuArrayBase< T >::Set().

                              {
  for (int32 i = 0; i < 30; i++) {
    int32 size = Rand() % 5;
    size = size * size * size; // Have a good distribution of sizes, including >256.
    int32 size2 = Rand() % 4;
    std::vector<T> vec(size);
    std::vector<T> garbage_vec(size2); // We just use garbage_vec to make sure
                                       // we sometimes resize from empty,
                                       // sometimes not.

    int32 byte_size = size * sizeof(T);
    std::vector<char> rand_c(byte_size);
    for (size_t i = 0; i < byte_size; i++)
      rand_c[i] = Rand() % 256;
    if (!vec.empty()) {
      std::memcpy((void*)&(vec[0]), (void*)&(rand_c[0]),
                  byte_size);
    }

    { // test constructor from vector and CopyToVec.
      CuArray<T> cu_vec(vec);
      std::vector<T> vec2;
      cu_vec.CopyToVec(&vec2);
      T *vec22 = new T[vec.size()];
      cu_vec.CopyToHost(vec22);
      delete[] vec22;
    }

    { // test assignment operator from CuArray.
      CuArray<T> cu_vec(vec);
      CuArray<T> cu_vec2(garbage_vec);
      cu_vec2 = cu_vec;
      std::vector<T> vec2;
      cu_vec2.CopyToVec(&vec2);
      AssertEqual(vec, vec2);
      KALDI_ASSERT(cu_vec2.Dim() == int32(vec2.size())); // test Dim()
    }

    { // test resize with resize_type = kSetZero.
      CuArray<T> cu_vec(vec);
      cu_vec.Resize(size, kSetZero);
      std::vector<T> vec2(vec);

      if (!vec2.empty())
        std::memset(&(vec2[0]), 0, vec2.size() * sizeof(T));
      std::vector<T> vec3;
      cu_vec.CopyToVec(&vec3);
      AssertEqual(vec2, vec3); // testing equality of zero arrays.
    }

    if (sizeof(T) == sizeof(int32) && size > 0) { // test Set for type int32, or same size.
      CuArray<T> cu_vec(vec);
      cu_vec.Set(vec[0]);
      for (size_t i = 1; i < vec.size(); i++) vec[i] = vec[0];
      std::vector<T> vec2;
      cu_vec.CopyToVec(&vec2);
      AssertEqual(vec, vec2);
    }
  }
}

UnitTestCuBlockMatrixAddMatBlock()

static void kaldi::UnitTestCuBlockMatrixAddMatBlock ( )

static

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

References CuMatrixBase< Real >::AddMatBlock(), AssertEqual(), rnnlm::i, kNoTrans, kTrans, CuBlockMatrix< Real >::NumCols(), CuBlockMatrix< Real >::NumRows(), Rand(), CuMatrixBase< Real >::SetRandn(), and swap().

                                               {
  for (int32 i = 0; i < 20; i++) {
    int32 num_blocks = Rand() % 5;
    std::vector<CuMatrix<Real> > data(num_blocks);
    for (int32 b = 0; b < num_blocks; b++) {
      int32 dimM = 100 + Rand() % 255, dimN = 10 + Rand() % 20;
      // early failures will have small dim for easier eyeballing.
      if (b % 2 == 0) std::swap(dimM, dimN);
      data[b].Resize(dimM, dimN);
      data[b].SetRandn();
    }
    CuBlockMatrix<Real> B(data);
    int32 B_num_rows = B.NumRows(), B_num_cols = B.NumCols();
    // will do X += A B

    MatrixTransposeType transB = (i % 2 == 1 ? kTrans : kNoTrans),
        transA = (i % 3 == 1 ? kTrans : kNoTrans);
    if (transB == kTrans) std::swap(B_num_rows, B_num_cols);

    int32 X_num_rows = 100 + Rand() % 255, X_num_cols = B_num_cols,
        A_num_rows = X_num_rows, A_num_cols = B_num_rows;
    if (data.size() == 0) { X_num_rows = 0; A_num_rows = 0; }
    if (transA == kTrans) std::swap(A_num_rows, A_num_cols);

    Real alpha = 2.0, beta = -1.0;
    CuMatrix<Real> X(X_num_rows, X_num_cols);
    X.SetRandn();
    CuMatrix<Real> A(A_num_rows, A_num_cols);
    A.SetRandn();

    CuMatrix<Real> Xcopy(X), Bcopy(B), Xorig(X), Aorig(A);
    Xcopy.AddMatMat(alpha, A, transA, Bcopy, transB, beta);
    X.AddMatBlock(alpha, A, transA, B, transB, beta);

    AssertEqual(X, Xcopy);
  }
}

UnitTestCuBlockMatrixAddMatMat()

static void kaldi::UnitTestCuBlockMatrixAddMatMat ( )

static

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

References CuBlockMatrix< Real >::AddMatMat(), CuMatrixBase< Real >::AddMatMat(), ApproxEqual(), CuBlockMatrix< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_LOG, KALDI_WARN, kNoTrans, kTrans, CuBlockMatrix< Real >::NumCols(), CuBlockMatrix< Real >::NumRows(), Rand(), CuMatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::Sum(), and swap().

                                             {
  for (int32 i = 0; i < 20; i++) {
    int32 num_blocks = Rand() % 5 + 1;
    std::vector<CuMatrix<Real> > data(num_blocks);
    for (int32 b = 0; b < num_blocks; b++) {
      int32 dimM = 100 + Rand() % 255, dimN = 10 + Rand() % 20;
      if (i == 0) { dimM = 1; dimN = 1; }
      // early failures will have small dim for easier eyeballing.
      if (b % 2 == 0) std::swap(dimM, dimN);
      data[b].Resize(dimM, dimN);
      KALDI_LOG << "dimM " << dimM << ", dimN " << dimN << ", stride " << data[b].Stride();
      data[b].SetRandn();
    }

    CuBlockMatrix<Real> B(data);
    int32 B_num_rows = B.NumRows(), B_num_cols = B.NumCols();
    // will do B += C D

    int32 C_num_rows = B_num_rows, C_num_cols = 100 + Rand() % 255;
    if (C_num_rows == 0) C_num_cols = 0;
    int32 D_num_rows = C_num_cols, D_num_cols = B_num_cols;

    MatrixTransposeType transC = (i % 2 == 1 ? kTrans : kNoTrans),
        transD = (i % 3 == 1 ? kTrans : kNoTrans);
    if (transC == kTrans) std::swap(C_num_rows, C_num_cols);
    if (transD == kTrans) std::swap(D_num_rows, D_num_cols);

    CuMatrix<Real> C(C_num_rows, C_num_cols), D(D_num_rows, D_num_cols);
    C.SetRandn();
    D.SetRandn();

    CuMatrix<Real> Bmat(B);

    Real alpha = 2.0, beta = -1.0;

    CuBlockMatrix<Real> Bcopy(B);

    B.AddMatMat(alpha, C, transC, D, transD, beta);

    Bmat.AddMatMat(alpha, C, transC, D, transD, beta);

    // Now check that the block-structured part of Bmat is the
    // same as B.
    Bcopy.CopyFromMat(Bmat); // copy block-structured part from Bmat to Bcopy.

    if (!ApproxEqual(B, Bcopy)) {
      KALDI_WARN << "CuBlockMatrixTest failure, please report to maintainers: Bcopy = "
                 << Bcopy << ", B = " << B << ", C = " << C << ", D = " << D
                 << ", Bmat = " << B << " transD = " << transD << ", transC = "
                 << transC;
      KALDI_ERR << "Please give this log to the maintainers.";
    }
    KALDI_ASSERT(Bmat.Sum() != 0 || B_num_rows == 0);
  }
}

UnitTestCuBlockMatrixIO()

static void kaldi::UnitTestCuBlockMatrixIO ( )

static

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

References AssertEqual(), rnnlm::i, KALDI_ASSERT, Rand(), CuBlockMatrix< Real >::Read(), swap(), and CuBlockMatrix< Real >::Write().

                                      {
  for (int32 i = 0; i < 10; i++) {
    int32 num_blocks = Rand() % 5;
    std::vector<CuMatrix<Real> > data(num_blocks);
    for (int32 b = 0; b < num_blocks; b++) {
      int32 dimM = 100 + Rand() % 255, dimN = 10 + Rand() % 20;
      if (b % 2 == 0) std::swap(dimM, dimN);
      data[b].Resize(dimM, dimN);
      data[b].SetRandn();
    }
    CuBlockMatrix<Real> B(data);

    std::ostringstream os;
    bool binary = (i % 4 < 2);
    B.Write(os, binary);

    CuBlockMatrix<Real> B2;
    std::istringstream is(os.str());
    B2.Read(is, binary);

    CuMatrix<Real> mat(B), mat2(B2);
    AssertEqual(mat, mat2);
    if (!data.empty())
      KALDI_ASSERT(mat.Sum() != 0.0);
  }
}

UnitTestCuCholesky()

static void kaldi::UnitTestCuCholesky ( )

static

Definition at line 112 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatMat(), CuMatrixBase< Real >::ApproxEqual(), CuMatrixBase< Real >::Cholesky(), CuMatrixBase< Real >::CopyLowerToUpper(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, Rand(), CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SymAddMat2().

                                 {
  for (int32 i = 0; i < 2; i++) {
    int32 M = 1 + Rand() % 10, N = M + 5;

    CuMatrix<Real> A(M, N);
    A.SetRandn();
    CuMatrix<Real> S(M, M);
    // SymAddMat2 only copies lower triangle.
    // it's OK- Cholesky only reads the lower triangle.
    S.SymAddMat2(1.0, A, kNoTrans, 0.0);

    CuMatrix<Real> C(S);
    C.Cholesky();

    CuMatrix<Real> S2(M, M);
    S2.AddMatMat(1.0, C, kNoTrans, C, kTrans, 0.0);
    S.CopyLowerToUpper();
    KALDI_ASSERT(S.ApproxEqual(S2));
  }
}

UnitTestCuCopy()

static void kaldi::UnitTestCuCopy ( )

static

Definition at line 2195 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, and Rand().

                             {
  for (int32 i = 0; i < 10; i++) {
    int32 M = 1 + Rand() % 10, N = 1 + Rand() % 10;
    CuMatrix<Real> A(M, N);
    CuMatrix<OtherReal> B(A, kTrans);
    CuMatrix<Real> C(B, kTrans);
    CuMatrix<Real> D(N, M);
    D.CopyFromMat(C, kTrans);
    CuMatrix<OtherReal> E(N, M);
    E.CopyFromMat(D, kNoTrans);
    CuMatrix<Real> F(M, N);
    F.CopyFromMat(E, kTrans);

    Matrix<OtherReal> G(M, N);
    G.CopyFromMat(F, kNoTrans);
    CuMatrix<Real> H(N, M);
    H.CopyFromMat(G, kTrans);
    Matrix<OtherReal> I(M, N);
    I.CopyFromMat(H, kTrans);
    CuMatrix<Real> J(I, kTrans);
    Matrix<OtherReal> K(J, kTrans);
    CuMatrix<Real> L(K, kNoTrans);

    KALDI_ASSERT(A.ApproxEqual(L));
  }

}

UnitTestCuDiffLogSoftmax()

static void kaldi::UnitTestCuDiffLogSoftmax ( )

static

Definition at line 2325 of file cu-matrix-test.cc.

References VectorBase< Real >::AddColSumMat(), MatrixBase< Real >::AddMat(), MatrixBase< Real >::ApplyExp(), ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::DiffLogSoftmaxPerRow(), rnnlm::i, KALDI_ASSERT, kNoTrans, MatrixBase< Real >::MulRowsVec(), rnnlm::n, MatrixBase< Real >::NumRows(), RandInt(), RandZeroToOneMatrix(), MatrixBase< Real >::Scale(), and MatrixBase< Real >::SetRandn().

                                       {
  for (int32 i = 0; i < 4; i++) {
    int m = RandInt(10, 280), n = RandInt(10, 280);
    Matrix<Real> Hi(m, n);
    Matrix<Real> Ho(m, n);
    Matrix<Real> Hy(m, n);
    Hi.SetRandn();
    RandZeroToOneMatrix(&Hy);

    CuMatrix<Real> Di(m, n);
    CuMatrix<Real> Do(m, n);
    CuMatrix<Real> Dy(m, n);
    Di.CopyFromMat(Hi);
    Dy.CopyFromMat(Hy);

    //gpu
    if (i % 2 == 0) {
      Do.DiffLogSoftmaxPerRow(Dy, Di);
    } else {
      // in-place.
      Do.CopyFromMat(Di);
      Do.DiffLogSoftmaxPerRow(Dy, Do);
    }
    //cpu
    {
      const MatrixBase<Real> &Y(Hy), &E(Hi);
      MatrixBase<Real> &D(Ho);
      D.CopyFromMat(Y);
      D.ApplyExp();                           // exp(y)
      Vector<Real> E_sum(D.NumRows());        // Initializes to zero
      E_sum.AddColSumMat(1.0, E);             // Sum(e)
      D.MulRowsVec(E_sum);                    // exp(y) Sum(e)
      D.Scale(-1.0);                          // - exp(y) Sum(e)
      D.AddMat(1.0, E, kNoTrans);             // e - exp(y_i) Sum(e)
    }

    Matrix<Real> Ho2(m, n);
    Do.CopyToMat(&Ho2);

    KALDI_ASSERT(ApproxEqual(Ho, Ho2));
 }
}

UnitTestCuDiffNormalizePerRow()

static void kaldi::UnitTestCuDiffNormalizePerRow ( )

static

Definition at line 593 of file cu-math-test.cc.

References VectorBase< Real >::AddDiagMat2(), VectorBase< Real >::AddDiagMatMat(), MatrixBase< Real >::AddDiagVecMat(), VectorBase< Real >::ApplyFloor(), AssertEqual(), CuMatrixBase< Real >::CopyFromMat(), MatrixBase< Real >::Data(), kaldi::cu::DiffNormalizePerRow(), Timer::Elapsed(), rnnlm::i, KALDI_LOG, kNoTrans, kTrans, kUndefined, MatrixBase< Real >::MulRowsVec(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                            {
  for (int32 i = 0; i < 2; i++) {
    int row = 10 + Rand() % 40;
    int col = 10 + Rand() % 50;

    Matrix<Real> Hi(row, col);
    Matrix<Real> Ho(row, col + 1);
    Matrix<Real> Hid(row, col);
    Matrix<Real> Hod(row, col + 1);
    Hi.SetRandn();
    Hod.SetRandn();
    Hi.Scale(5.0);

    CuMatrix<Real> Di(row, col);
    CuMatrix<Real> Do(row, col + 1);
    CuMatrix<Real> Did(row, col);
    CuMatrix<Real> Dod(row, col + 1);
    Di.CopyFromMat(Hi);
    Dod.CopyFromMat(Hod);

    Real target_rms = 0.3456;
    bool add_log_stddev = true;
    const Real kSquaredNormFloor = 1.3552527156068805425e-20; // 2^-66

    //gpu
    cu::DiffNormalizePerRow(Di, Dod, target_rms, add_log_stddev, &Did);

    //cpu
    {
      MatrixBase<Real>* in_deriv = &Hid;
      MatrixBase<Real>& out_deriv(Hod);
      MatrixBase<Real>& in_value(Hi);

      const SubMatrix<Real> out_deriv_no_log(out_deriv, 0, out_deriv.NumRows(),
                                             0, in_value.NumCols());
      Vector<Real> dot_products(out_deriv.NumRows());
      dot_products.AddDiagMatMat(1.0, out_deriv_no_log, kNoTrans, in_value,
                                 kTrans, 0.0);
      Vector<Real> in_norm(in_value.NumRows());
      Real d_scaled = (in_value.NumCols() * target_rms * target_rms);
      in_norm.AddDiagMat2(1.0, in_value, kNoTrans, 0.0);
      if (add_log_stddev) {
        Vector<Real> log_stddev_deriv(in_norm), // log_stddev deriv as dF/dy .* (x^T x)^-1
        out_deriv_for_stddev(out_deriv.NumRows(), kUndefined);
        // f = log(sqrt(max(epsi, x^T x / D)))
        // df/dx = epsi^2 * D < x^T x ? (1/(x^T x)) * x  : 0.
        // we don't compute this exactly below for the case when x^2 x is very
        // small, but we do make sure that the deriv isn't infinity when the input
        // is zero.
        log_stddev_deriv.ApplyFloor(in_value.NumCols() * kSquaredNormFloor);
        log_stddev_deriv.ApplyPow(-1.0);
        out_deriv_for_stddev.CopyColFromMat(out_deriv,
                                            (out_deriv.NumCols() - 1));
        log_stddev_deriv.MulElements(out_deriv_for_stddev);
        if (in_deriv)
          in_deriv->AddDiagVecMat(1.0, log_stddev_deriv, in_value, kNoTrans,
                                  1.0);
      }
      in_norm.Scale(1.0 / d_scaled);
      in_norm.ApplyFloor(kSquaredNormFloor);
      in_norm.ApplyPow(-0.5);
      if (in_deriv) {
        if (in_deriv->Data() != out_deriv_no_log.Data())
          in_deriv->AddDiagVecMat(1.0, in_norm, out_deriv_no_log, kNoTrans,
                                  1.0);
        else
          in_deriv->MulRowsVec(in_norm);
        in_norm.ReplaceValue(1.0 / sqrt(kSquaredNormFloor), 0.0);
        in_norm.ApplyPow(3.0);
        dot_products.MulElements(in_norm);

        in_deriv->AddDiagVecMat(-1.0 / d_scaled, dot_products, in_value,
                                kNoTrans, 1.0);
      }

      Matrix<Real> Hid2(Did);
      AssertEqual(Hid, Hid2, 0.00001);
    }
  }

  for (int dim = 16; dim <= 1024; dim *= 2) {
    BaseFloat time_in_secs = 0.025;
    CuMatrix<Real> id(dim, dim), iv(dim, dim), od(dim, dim + 1);
    iv.SetRandn();
    od.SetRandn();
    Timer tim;
    int32 iter = 0;
    for (; tim.Elapsed() < time_in_secs; iter++) {
      cu::DiffNormalizePerRow(iv, od, Real(0.456), true, &id);
    }
    BaseFloat fdim = dim;
    BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
    KALDI_LOG << "For CuMath::DiffNormalizePerRow"
              << (sizeof(Real)==8?"<double>":"<float>")
              << ", for dim = " << dim << ", speed was " << gflops
              << " gigaflops.";
  }
}

UnitTestCuDiffSigmoid()

static void kaldi::UnitTestCuDiffSigmoid ( )

static

Definition at line 2251 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::DiffSigmoid(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), RandZeroToOneMatrix(), and MatrixBase< Real >::SetRandn().

                                    {
  Matrix<Real> Hi(100,111);
  Matrix<Real> Ho(100,111);
  Matrix<Real> Hy(100,111);
  Hi.SetRandn();
  RandZeroToOneMatrix(&Hy);

  CuMatrix<Real> Di(100,111);
  CuMatrix<Real> Do(100,111);
  CuMatrix<Real> Dy(100,111);
  Di.CopyFromMat(Hi);
  Dy.CopyFromMat(Hy);

  //gpu
  Do.DiffSigmoid(Dy, Di);
  //cpu
  for(MatrixIndexT r=0; r<Ho.NumRows(); r++) {
    for(MatrixIndexT c=0; c<Ho.NumCols(); c++) {
      Ho(r, c) = Hy(r, c)*(1.0 - Hy(r, c)) * Hi(r, c);
    }
  }

  Matrix<Real> Ho2(100,111);
  Do.CopyToMat(&Ho2);

  KALDI_ASSERT(ApproxEqual(Ho,Ho2));
}

UnitTestCuDiffSoftmax()

static void kaldi::UnitTestCuDiffSoftmax ( )

static

Definition at line 2281 of file cu-matrix-test.cc.

References VectorBase< Real >::AddDiagMatMat(), MatrixBase< Real >::AddDiagVecMat(), ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::DiffSoftmaxPerRow(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::MulElements(), rnnlm::n, MatrixBase< Real >::NumRows(), RandInt(), RandZeroToOneMatrix(), and MatrixBase< Real >::SetRandn().

                                    {
  for (int32 i = 0; i < 4; i++) {
    int m = RandInt(10, 280), n = RandInt(10, 280);
    Matrix<Real> Hi(m, n);
    Matrix<Real> Ho(m, n);
    Matrix<Real> Hy(m, n);
    Hi.SetRandn();
    RandZeroToOneMatrix(&Hy);

    CuMatrix<Real> Di(m, n);
    CuMatrix<Real> Do(m, n);
    CuMatrix<Real> Dy(m, n);
    Di.CopyFromMat(Hi);
    Dy.CopyFromMat(Hy);

    //gpu
    if (i % 2 == 0) {
      Do.DiffSoftmaxPerRow(Dy, Di);
    } else {
      // in-place.
      Do.CopyFromMat(Di);
      Do.DiffSoftmaxPerRow(Dy, Do);
    }
    //cpu
    {
      const MatrixBase<Real> &P(Hy), &E(Hi);
      MatrixBase<Real> &D(Ho);
      D.CopyFromMat(P);
      D.MulElements(E);
      // At this point, D = P .* E (in matlab notation)
      Vector<Real> pe_vec(D.NumRows()); // For each row i, the dot product (p_t . e_t).
      pe_vec.AddDiagMatMat(1.0, P, kNoTrans, E, kTrans, 0.0);
      D.AddDiagVecMat(-1.0, pe_vec, P, kNoTrans, 1.0); // does D -= diag(pe_vec) * P.
    }

    Matrix<Real> Ho2(m, n);
    Do.CopyToMat(&Ho2);

    KALDI_ASSERT(ApproxEqual(Ho, Ho2));
  }
}

UnitTestCuDiffTanh()

static void kaldi::UnitTestCuDiffTanh ( )

static

Definition at line 2593 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::DiffTanh(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), RandZeroToOneMatrix(), and MatrixBase< Real >::SetRandn().

                                 {
  Matrix<Real> Hi(100,111);
  Matrix<Real> Ho(100,111);
  Matrix<Real> Hy(100,111);
  Hi.SetRandn();
  RandZeroToOneMatrix(&Hy);

  CuMatrix<Real> Di(100,111);
  CuMatrix<Real> Do(100,111);
  CuMatrix<Real> Dy(100,111);
  Di.CopyFromMat(Hi);
  Dy.CopyFromMat(Hy);

  //gpu
  Do.DiffTanh(Dy, Di);
  //cpu
  for(MatrixIndexT r=0; r<Ho.NumRows(); r++) {
    for(MatrixIndexT c=0; c<Ho.NumCols(); c++) {
      Ho(r, c) = (1.0 - Hy(r, c)*Hy(r, c)) * Hi(r, c);
    }
  }

  Matrix<Real> Ho2(100,111);
  Do.CopyToMat(&Ho2);

  KALDI_ASSERT(ApproxEqual(Ho,Ho2));
}

UnitTestCuDiffXent()

static void kaldi::UnitTestCuDiffXent ( )

static

Definition at line 2483 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuArray< T >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), CuVectorBase< Real >::CopyToVec(), CuMatrixBase< Real >::DiffXent(), rnnlm::i, KALDI_ASSERT, Log(), MatrixBase< Real >::NumRows(), Rand(), and RandZeroToOneMatrix().

                                 {
  int32 X=100, Y=111;
  //nnet output / diff
  Matrix<Real> Hi(X,Y);
  RandZeroToOneMatrix(&Hi);
  CuMatrix<Real> Di(X,Y);
  Di.CopyFromMat(Hi);
  //target vector
  std::vector<int32> Htgt(X);
  for(int32 i=0; i<X; i++) {
    Htgt[i] = Rand()%Y;
  }
  CuArray<int32> Dtgt(X);
  Dtgt.CopyFromVec(Htgt);
  //logpost vector
  Vector<Real> Hlogpost(X);
  CuVector<Real> Dlogpost(X);

  //gpu
  Di.DiffXent(Dtgt, &Dlogpost);
  //cpu
  for(MatrixIndexT r=0; r<Hi.NumRows(); r++) {
    int32 col_tgt = Htgt[r];
    Hlogpost(r) = Log(Hi(r, col_tgt));
    Hi(r, col_tgt) -= 1.0;
  }

  Matrix<Real> Hi2(X,Y);
  Di.CopyToMat(&Hi2);
  Vector<Real> Hlogpost2(X);
  Dlogpost.CopyToVec(&Hlogpost2);

  KALDI_ASSERT(ApproxEqual(Hi,Hi2));
  KALDI_ASSERT(ApproxEqual(Hlogpost,Hlogpost2));
}

UnitTestCuFindRowMaxId()

static void kaldi::UnitTestCuFindRowMaxId ( )

static

Definition at line 2444 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), CuArrayBase< T >::CopyToVec(), CuMatrixBase< Real >::FindRowMaxId(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), and MatrixBase< Real >::SetRandn().

                                     {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 100 + Rand() % 200, dimN = 100 + Rand() % 200;
    Matrix<Real> Hi(dimM, dimN);
    Hi.SetRandn();

    CuMatrix<Real> Di(dimM, dimN);
    Di.CopyFromMat(Hi);

    std::vector<int32> Hmax(dimM);
    CuArray<int32> Dmax(dimN);

    // on gpu
    Di.FindRowMaxId(&Dmax);

    // on cpu
    for(MatrixIndexT r=0; r<Hi.NumRows(); r++) {
      Real max=-1.0e+20; int32 idx=-1;
      for(MatrixIndexT c=0; c<Hi.NumCols(); c++) {
        if(Hi(r,c) > max) { idx=c; max=Hi(r,c); }
      }
      Hmax[r] = idx;
    }

    std::vector<int32> Hmax2(dimM);
    Dmax.CopyToVec(&Hmax2);

    // If the same value were generated randomly we can get to a case
    // where the GPU and CPU return different columns.  Both would be correct.
    // Thus check that the max for each row is the same and not the index.
    for (MatrixIndexT r=0; r<Hi.NumRows(); r++) {
      KALDI_ASSERT(Hi(r, Hmax[r]) == Di(r, Hmax2[r]));
    }
  }
}

UnitTestCuLogSoftmax()

static void kaldi::UnitTestCuLogSoftmax ( )

static

Definition at line 2407 of file cu-matrix-test.cc.

References ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, CuMatrixBase< Real >::LogSoftMaxPerRow(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Row(), MatrixBase< Real >::Scale(), and MatrixBase< Real >::SetRandn().

                                   {

  for (int32 i = 0; i < 50; i++) {
    int row = 10 + Rand() % 300;
    int col = 10 + Rand() % 300;

    Matrix<Real> Hi(row, col);
    Matrix<Real> Ho(row, col);
    Hi.SetRandn();
    Hi.Scale(5.0);

    CuMatrix<Real> Di(row, col);
    CuMatrix<Real> Do(row, col);
    Di.CopyFromMat(Hi);

    //gpu
    if (i % 2 == 0) {
      Do.LogSoftMaxPerRow(Di);
    } else {
      // in-place.
      Do.CopyFromMat(Di);
      Do.LogSoftMaxPerRow(Do);
    }
    //cpu
    Ho.CopyFromMat(Hi);
    for(MatrixIndexT r=0; r<Ho.NumRows(); r++) {
      Ho.Row(r).ApplyLogSoftMax();
    }

    Matrix<Real> Ho2(Do);

    KALDI_ASSERT(ApproxEqual(Ho, Ho2, (Real)0.00001));
  }
}

UnitTestCuMathComputeLstmNonlinearity()

static void kaldi::UnitTestCuMathComputeLstmNonlinearity ( )

static

Definition at line 166 of file cu-math-test.cc.

References AssertEqual(), kaldi::cu::ComputeLstmNonlinearity(), kaldi::cu::CpuComputeLstmNonlinearity(), Timer::Elapsed(), rnnlm::i, KALDI_LOG, Rand(), RandInt(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                    {
  for (int i = 0; i < 3; i++) {
    int32 num_rows = 1 + Rand() % 100;
    int32 cell_dim = 1 + Rand() % 2000;
    int32 dropout_dim = (RandInt(0, 1) == 0 ? 0 : 3);
    Matrix<Real> Hinput(num_rows, 5 * cell_dim + dropout_dim);
    Matrix<Real> Hparams(3, cell_dim);
    Matrix<Real> Houtput(num_rows, 2 * cell_dim);
    Hinput.SetRandn();
    Hparams.SetRandn();

    CuMatrix<Real> Dinput(Hinput);
    CuMatrix<Real> Dparams(Hparams);
    CuMatrix<Real> Doutput(Houtput);

    cu::CpuComputeLstmNonlinearity(Hinput, Hparams, &Houtput);
    cu::ComputeLstmNonlinearity(Dinput, Dparams, &Doutput);

    Matrix<Real> HDoutput(Doutput);
    AssertEqual(Houtput, HDoutput);
  }

  for (int i = 16; i <= 1024; i *= 2) {
    BaseFloat time_in_secs = 0.025;
    int32 num_rows = i;
    int32 cell_dim = i;
    int32 dropout_dim = (RandInt(0, 1) == 0 ? 0 : 3);
    CuMatrix<Real> input(num_rows, 5 * cell_dim + dropout_dim);
    CuMatrix<Real> params(3, cell_dim);
    CuMatrix<Real> output(num_rows, 2 * cell_dim);
    input.SetRandn();
    params.SetRandn();

    Timer tim;
    int32 iter = 0;
    for (; tim.Elapsed() < time_in_secs; iter++)
      cu::ComputeLstmNonlinearity(input, params, &output);

    BaseFloat gflops = ((BaseFloat) i * i * iter) / (tim.Elapsed() * 1.0e+09);
    KALDI_LOG << "For ComputeLstmNonlinearity"
              << (sizeof(Real)==8 ? "<double>" : "<float>") << ", for dim = "
              << i << ", speed was " << gflops << " gigaflops";
    if (tim.Elapsed() > 0.05)
      break;
  }
}

UnitTestCuMathCopy()

static void kaldi::UnitTestCuMathCopy ( )

static

Definition at line 97 of file cu-math-test.cc.

References AssertEqual(), kaldi::cu::Copy(), CuArray< T >::CopyFromVec(), rnnlm::i, rnnlm::j, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), Rand(), and CuMatrixBase< Real >::SetRandn().

                                 {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  CuMatrix<Real> src(M, N);
  CuMatrix<Real> tgt(M, N);
  CuArray<int32> copy_from_idx;

  src.SetRandn();
  int32 n_rows = src.NumRows();
  int32 n_columns = src.NumCols();
  std::vector<int32> copy_from_idx_vec;

  for (int32 i = 0; i < n_columns; i++) {
    copy_from_idx_vec.push_back(Rand() % n_columns);
  }
  copy_from_idx.CopyFromVec(copy_from_idx_vec);
  cu::Copy(src, copy_from_idx, &tgt);

  for (int32 i = 0; i < n_rows; i++) {
    for (int32 j = 0; j < n_columns; j++) {
      Real src_val = src(i, copy_from_idx_vec.at(j));
      Real tgt_val = tgt(i, j);
      AssertEqual(src_val, tgt_val);
    }
  }
}

UnitTestCuMathNormalizePerRow()

static void kaldi::UnitTestCuMathNormalizePerRow ( )

static

Definition at line 479 of file cu-math-test.cc.

References AssertEqual(), MatrixBase< Real >::CopyColFromVec(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), MatrixBase< Real >::Data(), Timer::Elapsed(), rnnlm::i, KALDI_LOG, kNoTrans, kaldi::cu::NormalizePerRow(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                            {

  for (int32 i = 0; i < 2; i++) {
    int row = 10 + Rand() % 40;
    int col = 10 + Rand() % 50;

    Matrix<Real> Hi(row,col);
    Matrix<Real> Ho(row,col+1);
    Hi.SetRandn();
    Hi.Scale(5.0);

    CuMatrix<Real> Di(row, col);
    CuMatrix<Real> Do(row, col+1);
    Di.CopyFromMat(Hi);

    Real target_rms = 0.3456;
    bool add_log_stddev = true;
    const Real kSquaredNormFloor = 1.35525271560688e-20; // 2^-66

    //gpu
    cu::NormalizePerRow(Di, target_rms, add_log_stddev, &Do);

    //cpu
    {
      MatrixBase<Real>& in(Hi);
      MatrixBase<Real>& out(Ho);
      Real target_rms=0.3456;
      SubMatrix<Real> out_no_log(out, 0, out.NumRows(), 0, in.NumCols());
      if (in.Data() != out_no_log.Data())
        out_no_log.CopyFromMat(in);
      Vector<Real> in_norm(in.NumRows());
      Real d_scaled = in.NumCols() * target_rms * target_rms;
      in_norm.AddDiagMat2(1.0 / d_scaled, in, kNoTrans, 0.0);
      in_norm.ApplyFloor(kSquaredNormFloor);
      in_norm.ApplyPow(-0.5);
      out_no_log.MulRowsVec(in_norm);
      if (add_log_stddev) {
        in_norm.ApplyLog();
        in_norm.Scale(-1.0);
        in_norm.Add(log(target_rms));
        out.CopyColFromVec(in_norm, in.NumCols());
      }
    }

    Matrix<Real> Ho2(Do);
    AssertEqual(Ho,Ho2,0.00001);
  }

  for (int dim = 16; dim <= 1024; dim *= 2) {
    BaseFloat time_in_secs = 0.025;
    CuMatrix<Real> M(dim, dim), N(dim, dim + 1);
    M.SetRandn();
    N.SetRandn();
    Timer tim;
    int32 iter = 0;
    for (; tim.Elapsed() < time_in_secs; iter++) {
      cu::NormalizePerRow(M, Real(1), true, &N);
    }

    BaseFloat gflops = ((BaseFloat) dim * dim * iter)
        / (tim.Elapsed() * 1.0e+09);
    KALDI_LOG << "For CuMath::NormalizePerRow"
              << (sizeof(Real)==8?"<double>":"<float>") << ", for dim = "
              << dim << ", speed was " << gflops << " gigaflops.";
    if (tim.Elapsed() > 0.05)
      break;
  }
}

UnitTestCuMathNormalizePerRow_v2()

static void kaldi::UnitTestCuMathNormalizePerRow_v2 ( )

static

Definition at line 550 of file cu-math-test.cc.

References MatrixBase< Real >::ApplyFloor(), AssertEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), kNoTrans, MatrixBase< Real >::MulRowsVec(), kaldi::cu::NormalizePerRow(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::Scale(), and MatrixBase< Real >::SetRandn().

                                               {

  int row = 128;
  int col = 1024;

  Matrix<Real> Hi(row,col);
  Matrix<Real> Ho(row,col);
  Hi.SetRandn();
  Hi.Scale(5.0);
  Hi.ApplyFloor(0.0); // like ReLU,

  CuMatrix<Real> Di(row, col);
  CuMatrix<Real> Do(row, col);
  Di.CopyFromMat(Hi);

  Real target_rms = 0.3456;
  bool add_log_stddev = false;
  const Real kSquaredNormFloor = 1.35525271560688e-20; // 2^-66

  //gpu
  cu::NormalizePerRow(Di, target_rms, add_log_stddev, &Do);

  //cpu
  {
    MatrixBase<Real>& in(Hi);
    MatrixBase<Real>& out(Ho);
    Real target_rms=0.3456;
    Vector<Real> in_norm(in.NumRows());
    Real d_scaled = in.NumCols() * target_rms * target_rms;
    in_norm.AddDiagMat2(1.0 / d_scaled, in, kNoTrans, 0.0);
    in_norm.ApplyFloor(kSquaredNormFloor);
    in_norm.ApplyPow(-0.5);
    out.CopyFromMat(in);
    out.MulRowsVec(in_norm);
  }

  Matrix<Real> Ho2(Do);
  // here the BUG was detected (by processing big-enough matrix),
  AssertEqual(Ho,Ho2,0.00001);
}

UnitTestCuMathRandomize()

static void kaldi::UnitTestCuMathRandomize ( )

static

Definition at line 46 of file cu-math-test.cc.

References AssertEqual(), CuArray< T >::CopyFromVec(), rnnlm::i, rnnlm::j, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), Rand(), kaldi::cu::Randomize(), and CuMatrixBase< Real >::SetRandn().

                                      {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  CuMatrix<Real> src(M, N);
  CuMatrix<Real> tgt(M, N);
  CuArray<int32> copy_from_idx;

  src.SetRandn();
  int32 n_rows = src.NumRows();
  int32 n_columns = src.NumCols();
  std::vector<int32> copy_from_idx_vec;

  for (int32 i = 0; i < n_rows; i++) {
    copy_from_idx_vec.push_back(Rand() % n_rows);
  }
  copy_from_idx.CopyFromVec(copy_from_idx_vec);
  cu::Randomize(src, copy_from_idx, &tgt);

  for (int32 i = 0; i < n_rows; i++) {
    for (int32 j = 0; j < n_columns; j++) {
      Real src_val = src(copy_from_idx_vec.at(i), j);
      Real tgt_val = tgt(i, j);
      AssertEqual(src_val, tgt_val);
    }
  }
}

UnitTestCuMathSplice()

static void kaldi::UnitTestCuMathSplice ( )

static

Definition at line 124 of file cu-math-test.cc.

References AssertEqual(), CuArray< T >::CopyFromVec(), rnnlm::i, rnnlm::j, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), Rand(), CuMatrixBase< Real >::SetRandn(), and kaldi::cu::Splice().

                                   {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  CuMatrix<Real> src(M, N);
  CuArray<int32> frame_offsets;

  src.SetRandn();
  int32 n_rows = src.NumRows();
  int32 n_columns = src.NumCols();
  std::vector<int32> frame_offsets_vec;

  // The number of columns of tgt is rows(src)
  // times n_frame_offsets, so we keep n_frame_offsets
  // reasonably small (2 <= n <= 6).
  int32 n_frame_offsets = Rand() % 7 + 2;
  for (int32 i = 0; i < n_frame_offsets; i++) {
    frame_offsets_vec.push_back(Rand() % 2 * n_columns - n_columns);
  }

  CuMatrix<Real> tgt(M, N * n_frame_offsets);
  frame_offsets.CopyFromVec(frame_offsets_vec);
  cu::Splice(src, frame_offsets, &tgt);

  Matrix<Real> src_copy(src), tgt_copy(tgt);
  for (int32 i = 0; i < n_rows; i++) {
    for (int32 k = 0; k < n_frame_offsets; k++) {
      for (int32 j = 0; j < n_columns; j++) {
        Real src_val;
        if (i + frame_offsets_vec.at(k) >= n_rows) {
          src_val = src_copy(n_rows-1, j);
        } else if (i + frame_offsets_vec.at(k) <= 0) {
          src_val = src_copy(0, j);
        } else {
          src_val = src_copy(i + frame_offsets_vec.at(k), j);
        }
        Real tgt_val = tgt_copy(i, k * n_columns + j);
        AssertEqual(src_val, tgt_val);
      }
    }
  }
}

UnitTestCuMatrixAdd()

static void kaldi::UnitTestCuMatrixAdd ( )

static

Definition at line 254 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::Add(), MatrixBase< Real >::Add(), ApproxEqual(), KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                  {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  Matrix<Real> H(M, N);
  H.SetRandn();

  BaseFloat offset = -1 + (0.33 * (Rand() % 5));
  CuMatrix<Real> D(H);
  D.Add(offset);
  H.Add(offset);
  Matrix<Real> E(D);

  KALDI_ASSERT(ApproxEqual(H, E));
}

UnitTestCuMatrixAdd2()

static void kaldi::UnitTestCuMatrixAdd2 ( )

static

Definition at line 1803 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::Add(), MatrixBase< Real >::Add(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, and Rand().

                                   {
  for (int32 i = 0; i < 10; i++) {
    int32 dimM = 100 + Rand() % 200, dimN = 100 + Rand() % 200;
    Matrix<Real> M(dimM, dimN);
    CuMatrix<Real> Mc(M);
    Real alpha = 5.5;
    M.Add(alpha);
    Mc.Add(alpha);
    Matrix<Real> M2(Mc);
    KALDI_ASSERT(ApproxEqual(M, M2));
  }
}

UnitTestCuMatrixAddCols()

static void kaldi::UnitTestCuMatrixAddCols ( )

static

Definition at line 886 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                      {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_cols1 = 10 + Rand() % 10,
        num_cols2 = 10 + Rand() % 10,
        num_rows = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows, num_cols1);
    M.SetRandn();

    CuMatrix<Real> N(num_rows, num_cols2), O(num_rows, num_cols2);
    std::vector<int32> reorder(num_cols2);
    for (int32 i = 0; i < num_cols2; i++)
      reorder[i] = -1 + (Rand() % (num_cols1 + 1));

    CuArray<int32> reorder_gpu(reorder);
    N.AddCols(M, reorder_gpu);

    for (int32 i = 0; i < num_rows; i++)
      for (int32 j = 0; j < num_cols2; j++)
        if (reorder[j] < 0) O(i, j) = 0;
        else O(i, j) = M(i, reorder[j]);
    KALDI_ASSERT(ApproxEqual(N, O));
  }
}

UnitTestCuMatrixAddDiagVecMat()

static void kaldi::UnitTestCuMatrixAddDiagVecMat ( )

static

Definition at line 1236 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddVec(), ApproxEqual(), CuVectorBase< Real >::CopyColFromMat(), CuVectorBase< Real >::CopyFromVec(), KALDI_ASSERT, kNoTrans, kTrans, Rand(), CuMatrixBase< Real >::Row(), CuVectorBase< Real >::Scale(), CuVectorBase< Real >::SetRandn(), CuMatrixBase< Real >::SetRandn(), CuVectorBase< Real >::Sum(), CuMatrixBase< Real >::Sum(), and CuMatrix< Real >::Transpose().

                                                                    {
  for (int p = 0; p < 4; p++) {
    MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
    //MatrixIndexT dimM = 10 + Rand() % 2, dimN = 10 + Rand() % 2;
    Real alpha = 0.43243, beta = 1.423;
    CuMatrix<Real> M(dimM, dimN), N(dimM, dimN);
    M.SetRandn();
    N.SetRandn();
    MatrixTransposeType trans = (p % 2 == 0 ? kNoTrans : kTrans);
    if (trans == kTrans)
      N.Transpose();

    KALDI_ASSERT(M.Sum() != 0.0);
    KALDI_ASSERT(N.Sum() != 0.0);

    CuVector<Real> V(dimM);
    V.SetRandn();

    KALDI_ASSERT(V.Sum() != 0.0);

    CuMatrix<Real> Mcheck(M);

    for (int32 r = 0; r < dimM; r++) {
      CuSubVector<Real> Mcheckrow(Mcheck, r);
      CuVector<Real> Nrow(dimN);
      if (trans == kTrans) Nrow.CopyColFromMat(N, r);
      else Nrow.CopyFromVec(N.Row(r));
      Mcheckrow.Scale(beta);
      Mcheckrow.AddVec(alpha * V(r), Nrow);
    }

    M.AddDiagVecMat(alpha, V, N, trans, beta);
    KALDI_ASSERT(ApproxEqual(M, Mcheck));
    KALDI_ASSERT(M.Sum() != 0.0);
  }
}

UnitTestCuMatrixAddElements()

static void kaldi::UnitTestCuMatrixAddElements ( )

static

Definition at line 2822 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddElements(), ApproxEqual(), Int32Pair::first, rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), Int32Pair::second, and CuMatrixBase< Real >::SetRandn().

                                          {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 100 + Rand() % 50, dimN = 100 + Rand() % 50;
   // int32 dimM = 256, dimN = 256;
    CuMatrix<Real> H(dimM, dimN);
    H.SetRandn();
    CuMatrix<Real> H_copy(H);
    CuMatrix<Real> M(H);
    int32 num_elements = 100 + Rand() % 10;
    std::vector<MatrixElement<Real> > input;
    std::set<Int32Pair> input_index;      //Set used to ensure unique elements
    std::vector<Int32Pair> input_index_v;
    Real *input_value = new Real[num_elements];
    BaseFloat scale = -1 + (0.33 * (Rand() % 5));
    for (int32 j = 0; j < num_elements; j++) {
      Int32Pair tmp_pair;
      // Generate a unique random index
      do {
        tmp_pair.first = Rand() % dimM;
        tmp_pair.second = Rand() % dimN;
      } while (input_index.find(tmp_pair)!=input_index.end());
      input_index.insert(tmp_pair);  

      MatrixIndexT r = tmp_pair.first;
      MatrixIndexT c = tmp_pair.second;
      input_index_v.push_back(tmp_pair);

      Real offset = -1 + (0.33 * (Rand() % 5));
      M(r, c) += scale * offset;
      MatrixElement<Real> t = {r, c, offset};
      input.push_back(t);
      input_value[j] = offset;
    }
    
    H.AddElements(scale, input);
    CuArray<Int32Pair> cu_input_index(input_index_v);
    H_copy.AddElements(scale, cu_input_index, input_value);
    delete[] input_value;

    KALDI_ASSERT(ApproxEqual(H, M));
    KALDI_ASSERT(ApproxEqual(H_copy, M));
  }
}

UnitTestCuMatrixAddMat()

static void kaldi::UnitTestCuMatrixAddMat ( )

static

Definition at line 1367 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMat(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, KALDI_ASSERT, kSetZero, kTrans, Rand(), CuMatrixBase< Real >::Range(), and MatrixBase< Real >::SetRandn().

                                     {
  Matrix<Real> Ha(100,100);
  Matrix<Real> Hb(100,100);
  Ha.SetRandn();
  Hb.SetRandn();

  CuMatrix<Real> Da(100,100);
  CuMatrix<Real> Db(100,100);
  Da.CopyFromMat(Ha);
  Db.CopyFromMat(Hb);

  Da.AddMat(0.5,Db);
  Ha.AddMat(0.5,Hb);

  Matrix<Real> Ha2(100,100);
  Da.CopyToMat(&Ha2);

  KALDI_ASSERT(ApproxEqual(Ha,Ha2));

  //check use with submatrix
  CuMatrix<Real> mat1(10,10,kSetZero);
  mat1.AddMat(1.0,Da.Range(5,10,12,10)); //different stride for mat1,mat2
  CuMatrix<Real> mat2(Da.Range(5,10,12,10));
  KALDI_ASSERT(ApproxEqual(mat1,mat2));

  for (int i = 0; i < 10; i++) {
    int32 N = 5 * (10 + Rand() % 10),  M = 100 + Rand() % 50;
    Matrix<Real> Hc(N,M);
    Matrix<Real> Hd(M,N);
    Hc.SetRandn();
    Hd.SetRandn();

    CuMatrix<Real> Dc(N,M);
    CuMatrix<Real> Dd(M,N);
    Dc.CopyFromMat(Hc);
    Dd.CopyFromMat(Hd);

    Real alpha = 0.5;
    Dc.AddMat(alpha,Dd,kTrans);
    Hc.AddMat(alpha,Hd,kTrans);

    Matrix<Real> Hc2(N,M);
    Dc.CopyToMat(&Hc2);
    KALDI_ASSERT(ApproxEqual(Hc,Hc2));

    // check use with submatrix
    CuMatrix<Real> mat3(N/5,M,kSetZero);
    mat3.AddMat(1.0, Dd.Range(0,M,0,N/5),kTrans);

    CuMatrix<Real> mat4(Dd.Range(0,M,0,N/5),kTrans);
    KALDI_ASSERT(ApproxEqual(mat3,mat4));
  }
}

UnitTestCuMatrixAddMatBlocks1()

static void kaldi::UnitTestCuMatrixAddMatBlocks1 ( )

static

Definition at line 1425 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMat(), CuMatrixBase< Real >::AddMatBlocks(), ApproxEqual(), KALDI_ASSERT, RandInt(), and CuMatrixBase< Real >::SetRandn().

                                            {
  for (int32 l = 0; l < 5; l++) {
    int32 num_row_blocks = RandInt(1, 10), num_col_blocks = RandInt(1, 20);
    int32 block_rows = RandInt(1, 100), block_cols = RandInt(1, 100);
    BaseFloat alpha = RandInt(3, 10);
    CuMatrix<Real> dst(block_rows, block_cols);
    dst.SetRandn();
    CuMatrix<Real> src(num_row_blocks * block_rows,
                       num_col_blocks * block_cols);
    src.SetRandn();

    CuMatrix<Real> dst_copy(dst);
    for (int32 rb = 0; rb < num_row_blocks; rb++) {
      for (int32 cb = 0; cb < num_col_blocks; cb++) {
        CuSubMatrix<Real> src_part(src,
                                   rb * block_rows, block_rows,
                                   cb * block_cols, block_cols);
        dst_copy.AddMat(alpha, src_part);
      }
    }
    dst.AddMatBlocks(alpha, src);
    KALDI_ASSERT(ApproxEqual(dst, dst_copy));
  }
}

UnitTestCuMatrixAddMatBlocks1Trans()

static void kaldi::UnitTestCuMatrixAddMatBlocks1Trans ( )

static

Definition at line 1452 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMat(), CuMatrixBase< Real >::AddMatBlocks(), ApproxEqual(), KALDI_ASSERT, kTrans, RandInt(), and CuMatrixBase< Real >::SetRandn().

                                                 {
  for (int32 l = 0; l < 5; l++) {
    int32 num_row_blocks = RandInt(1, 10), num_col_blocks = RandInt(1, 20);
    int32 block_rows = RandInt(1, 100), block_cols = RandInt(1, 100);
    BaseFloat alpha = RandInt(3, 10);
    CuMatrix<Real> dst(block_cols, block_rows);
    dst.SetRandn();
    CuMatrix<Real> src(num_row_blocks * block_rows,
                       num_col_blocks * block_cols);
    src.SetRandn();

    CuMatrix<Real> dst_copy(dst);
    for (int32 rb = 0; rb < num_row_blocks; rb++) {
      for (int32 cb = 0; cb < num_col_blocks; cb++) {
        CuSubMatrix<Real> src_part(src,
                                   rb * block_rows, block_rows,
                                   cb * block_cols, block_cols);
        dst_copy.AddMat(alpha, src_part, kTrans);
      }
    }
    dst.AddMatBlocks(alpha, src, kTrans);
    KALDI_ASSERT(ApproxEqual(dst, dst_copy));
  }
}

UnitTestCuMatrixAddMatBlocks2()

static void kaldi::UnitTestCuMatrixAddMatBlocks2 ( )

static

Definition at line 1482 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMat(), CuMatrixBase< Real >::AddMatBlocks(), ApproxEqual(), KALDI_ASSERT, RandInt(), and CuMatrixBase< Real >::SetRandn().

                                            {
  for (int32 l = 0; l < 5; l++) {
    int32 num_row_blocks = RandInt(1, 10), num_col_blocks = RandInt(1, 20);
    int32 block_rows = RandInt(1, 100), block_cols = RandInt(1, 100);
    BaseFloat alpha = RandInt(3, 10);
    CuMatrix<Real> src(block_rows, block_cols);
    src.SetRandn();
    CuMatrix<Real> dst(num_row_blocks * block_rows,
                       num_col_blocks * block_cols);
    src.SetRandn();

    CuMatrix<Real> dst_copy(dst);
    for (int32 rb = 0; rb < num_row_blocks; rb++) {
      for (int32 cb = 0; cb < num_col_blocks; cb++) {
        CuSubMatrix<Real> dst_copy_part(dst_copy,
                                        rb * block_rows, block_rows,
                                        cb * block_cols, block_cols);
        dst_copy_part.AddMat(alpha, src);
      }
    }
    dst.AddMatBlocks(alpha, src);
    KALDI_ASSERT(ApproxEqual(dst, dst_copy));
  }
}

UnitTestCuMatrixAddMatDiagVec()

static void kaldi::UnitTestCuMatrixAddMatDiagVec ( )

static

Definition at line 1273 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMat(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), KALDI_ASSERT, kNoTrans, kTrans, CuMatrixBase< Real >::MulColsVec(), Rand(), CuMatrixBase< Real >::Scale(), and CuVectorBase< Real >::SetRandn().

                                                                    {
  // M <- alpha * N[^T] * diag(v) + beta * M
  for (int p = 0; p < 2; p++) {
    MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
    Real alpha = 0.43243, beta = 1.423;

    CuMatrix<Real> M(dimM, dimN), N(dimM, dimN), buf(dimM, dimN);
    M.SetRandn();
    N.SetRandn();
    buf.CopyFromMat(N);
    MatrixTransposeType trans = (p % 2 == 0 ? kNoTrans : kTrans);
    if (trans == kTrans)
      N.Transpose();

    CuVector<Real> V(dimN);
    V.SetRandn();

    CuMatrix<Real> Mcheck(M);
    Mcheck.Scale(beta);
    buf.MulColsVec(V);
    Mcheck.AddMat(alpha, buf, kNoTrans);

    M.AddMatDiagVec(alpha, N, trans, V, beta);
    KALDI_ASSERT(ApproxEqual(M, Mcheck));
    KALDI_ASSERT(M.Sum() != 0.0);
  }
}

UnitTestCuMatrixAddMatMat()

static void kaldi::UnitTestCuMatrixAddMatMat ( )

static

Definition at line 1660 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddMatMat(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, kNoTrans, kTrans, and MatrixBase< Real >::SetRandn().

                                        {
  Matrix<Real> Ha(200,100);
  Matrix<Real> Hb(100,200);
  Matrix<Real> Hc1(200,200);
  Matrix<Real> Hc2(100,100);
  Ha.SetRandn();
  Hb.SetRandn();

  CuMatrix<Real> Da(200,100);
  CuMatrix<Real> Db(100,200);
  Da.CopyFromMat(Ha);
  Db.CopyFromMat(Hb);
  CuMatrix<Real> Dc1(200,200);
  CuMatrix<Real> Dc2(100,100);

  Dc1.AddMatMat(0.5f,Da,kNoTrans,Db,kNoTrans,0.0f);
  Dc2.AddMatMat(0.5f,Da,kTrans,Db,kTrans,0.0f);
  Hc1.AddMatMat(0.5f,Ha,kNoTrans,Hb,kNoTrans,0.0f);
  Hc2.AddMatMat(0.5f,Ha,kTrans,Hb,kTrans,0.0f);

  Matrix<Real> Hc1a(200,200);
  Matrix<Real> Hc2a(100,100);
  Dc1.CopyToMat(&Hc1a);
  Dc2.CopyToMat(&Hc2a);

  KALDI_ASSERT(ApproxEqual(Hc1,Hc1a));
  KALDI_ASSERT(ApproxEqual(Hc2,Hc2a));
}

UnitTestCuMatrixAddMatMatBatched()

static void kaldi::UnitTestCuMatrixAddMatMatBatched ( )

static

Definition at line 1715 of file cu-matrix-test.cc.

References AddMatMatBatched(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, and MatrixBase< Real >::SetRandn().

                                               {
  // Random stride is disabled as AddMatMatBatched requires consistent stride
#if HAVE_CUDA == 1
  bool old_mode = CuDevice::Instantiate().SetDebugStrideMode(false);
#endif
  const int32 batchCount = 10;
  std::vector<Matrix<Real>* > Ha(batchCount), Hb(batchCount), Hc1(batchCount), Hc2(batchCount);
  std::vector<CuMatrix<Real>* > Da(batchCount), Db(batchCount), Dc1(batchCount), Dc2(batchCount);
  std::vector<SubMatrix<Real>* > HA, HB, HC1, HC2;
  std::vector<CuSubMatrix<Real>* > DA, DB, DC1, DC2;

  for (int32 i = 0; i < batchCount; i++) {
    // first create a Matrix intance and then creat a SubMatrix instance from that
    Ha[i] = new Matrix<Real>(200, 100);
    Hb[i] = new Matrix<Real>(100, 200);
    Hc1[i] = new Matrix<Real>(200, 200);
    Hc2[i] = new Matrix<Real>(100, 100);
    Ha[i]->SetRandn();
    Hb[i]->SetRandn();
    HA.push_back(new SubMatrix<Real>(*(Ha[i]), 0, Ha[i]->NumRows(), 0,
                                     Ha[i]->NumCols()));
    HB.push_back(new SubMatrix<Real>(*(Hb[i]), 0, Hb[i]->NumRows(), 0,
                                     Hb[i]->NumCols()));
    HC1.push_back(new SubMatrix<Real>(*(Hc1[i]), 0, Hc1[i]->NumRows(), 0,
                                      Hc1[i]->NumCols()));
    HC2.push_back(new SubMatrix<Real>(*(Hc2[i]), 0, Hc2[i]->NumRows(), 0,
                                      Hc2[i]->NumCols()));

    // first create a CuMatrix intance and then creat a CuSubMatrix instance from that
    Da[i] = new CuMatrix<Real>(200, 100);
    Db[i] = new CuMatrix<Real>(100, 200);
    Dc1[i] = new CuMatrix<Real>(200, 200);
    Dc2[i] = new CuMatrix<Real>(100, 100);
    Da[i]->CopyFromMat(*(Ha[i]));
    Db[i]->CopyFromMat(*(Hb[i]));
    DA.push_back(new CuSubMatrix<Real>(*(Da[i]), 0, Da[i]->NumRows(), 0,
                                       Da[i]->NumCols()));
    DB.push_back(new CuSubMatrix<Real>(*(Db[i]), 0, Db[i]->NumRows(), 0,
                                       Db[i]->NumCols()));
    DC1.push_back(new CuSubMatrix<Real>(*(Dc1[i]), 0, Dc1[i]->NumRows(), 0,
                                        Dc1[i]->NumCols()));
    DC2.push_back(new CuSubMatrix<Real>(*(Dc2[i]), 0, Dc2[i]->NumRows(), 0,
                                        Dc2[i]->NumCols()));
  }

  AddMatMatBatched(static_cast<Real>(0.5f), DC1, DA, kNoTrans, DB, kNoTrans,
                   static_cast<Real>(0.0f));
  AddMatMatBatched(static_cast<Real>(0.5f), DC2, DA, kTrans, DB, kTrans,
                   static_cast<Real>(0.0f));

  // used to store results from DC1 and DC2 for equality check
  Matrix<Real> Hca1(200,200);
  Matrix<Real> Hca2(100,100);

  // equality check
  for (int32 i = 0; i< batchCount; i++) {
    (*HC1[i]).AddMatMat(0.5f, *(HA[i]), kNoTrans, *(HB[i]), kNoTrans, 0.0f);
    (*HC2[i]).AddMatMat(0.5f, *(HA[i]), kTrans, *(HB[i]), kTrans, 0.0f);
    DC1[i]->CopyToMat(&Hca1);
    DC2[i]->CopyToMat(&Hca2);
    KALDI_ASSERT(ApproxEqual(*(HC1[i]), Hca1));
    KALDI_ASSERT(ApproxEqual(*(HC2[i]), Hca2));
    delete Ha[i]; delete Hb[i]; delete Hc1[i]; delete Hc2[i];
    delete HA[i]; delete HB[i]; delete HC1[i]; delete HC2[i];
    delete Da[i]; delete Db[i]; delete Dc1[i]; delete Dc2[i];
    delete DA[i]; delete DB[i]; delete DC1[i]; delete DC2[i];
  }
#if HAVE_CUDA == 1
  CuDevice::Instantiate().SetDebugStrideMode(old_mode);
#endif
}

UnitTestCuMatrixAddMatMatElements()

static void kaldi::UnitTestCuMatrixAddMatMatElements ( )

static

Definition at line 1301 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMat(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), KALDI_ASSERT, kNoTrans, CuMatrixBase< Real >::MulElements(), Rand(), and CuMatrixBase< Real >::Scale().

                                                                        {
  // M <- alpha *(A .* B) + beta * M
  MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
  Real alpha = 0.43243, beta = 1.423;
  CuMatrix<Real> M(dimM, dimN), A(dimM, dimN), B(dimM, dimN), buf(dimM, dimN);
  M.SetRandn();
  A.SetRandn();
  B.SetRandn();

  CuMatrix<Real> Mcheck(M);
  buf.CopyFromMat(A); buf.MulElements(B);
  Mcheck.Scale(beta); Mcheck.AddMat(alpha, buf, kNoTrans);

  M.AddMatMatElements(alpha, A, B, beta);
  KALDI_ASSERT(ApproxEqual(M, Mcheck));
  KALDI_ASSERT(M.Sum() != 0.0);
}

UnitTestCuMatrixAddMatTp()

static void kaldi::UnitTestCuMatrixAddMatTp ( )

static

Definition at line 1849 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatTp(), MatrixBase< Real >::AddMatTp(), rnnlm::i, KALDI_ASSERT, kNoTrans, Rand(), PackedMatrix< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                       {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;

    Matrix<Real> A(dim, dim);
    Matrix<Real> B(dim, dim);
    TpMatrix<Real> C(dim);
    A.SetRandn();
    B.SetRandn();
    C.SetRandn();
    CuMatrix<Real> D(A);
    CuMatrix<Real> E(B);
    CuTpMatrix<Real> F(C);

    A.AddMatTp(1.0, B, kNoTrans, C, kNoTrans, 1.0);
    D.AddMatTp(1.0, E, kNoTrans, F, kNoTrans, 1.0);

    CuMatrix<Real> G(A);
    KALDI_ASSERT(ApproxEqual<Real>(G, D));
  }
}

UnitTestCuMatrixAddRowRanges()

static void kaldi::UnitTestCuMatrixAddRowRanges ( )

static

Definition at line 713 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddRowRanges(), ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                           {
  for (int32 p = 0; p < 10; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    Matrix<Real> src(num_rows1, num_cols); src.SetRandn();
    Matrix<Real> dst(num_rows2, num_cols); dst.SetRandn();

    // Computes the indexes.
    std::vector<Int32Pair> indexes(num_rows2);
    for (MatrixIndexT i = 0; i < num_rows2; i++) {
      indexes[i].first = Rand() % num_rows1;
      int32 headroom = num_rows1 - indexes[i].first,
            size = (Rand() % headroom) + 1;
      indexes[i].second = indexes[i].first + size;
      KALDI_ASSERT(indexes[i].second >= indexes[i].first &&
                   indexes[i].second <= num_rows1 &&
                   indexes[i].first >= 0);
    }
    // Computes reference matrix.
    Matrix<Real> dst1(dst);
    for (MatrixIndexT i = 0; i < num_rows2; i++) {
      int32 start = indexes[i].first, end = indexes[i].second;
      for (MatrixIndexT j = 0; j < num_cols; j++) {
        for (MatrixIndexT i2 = start; i2 < end; i2++)
          dst1(i, j) += src(i2, j);
      }
    }

    CuMatrix<Real> cu_src(src);
    CuMatrix<Real> cu_dst(dst);
    CuArray<Int32Pair> cu_indexes(indexes);
    cu_dst.AddRowRanges(cu_src, cu_indexes);
    Matrix<Real> dst2(cu_dst);
    KALDI_ASSERT(ApproxEqual(dst1, dst2));
  }
}

UnitTestCuMatrixAddRows()

static void kaldi::UnitTestCuMatrixAddRows ( )

static

Definition at line 517 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                      {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    CuMatrix<Real> N1(num_rows2, num_cols),
        N2(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<int32> reorder(num_rows2);
    std::vector<const Real*> reorder_src(num_rows2, NULL);
    for (int32 i = 0; i < num_rows2; i++) {
      reorder[i] = -1 + (Rand() % (num_rows1 + 1));
      if (reorder[i] != -1)
        reorder_src[i] = M.RowData(reorder[i]);
    }

    Real alpha =
        static_cast<Real>((Rand() % num_rows2)) / static_cast<Real>(num_rows1);

    CuArray<int32> reorder_cuda(reorder);
    CuArray<const Real*> reorder_src_cuda(reorder_src);
    N1.AddRows(alpha, M, reorder_cuda);
    N2.AddRows(alpha, reorder_src_cuda);

    for (int32 i = 0; i < num_rows2; i++) {
      if (reorder[i] != -1) {
        for (int32 j = 0; j < num_cols; j++) {
          O(i, j) += alpha * M(reorder[i], j);
        }
      }
    }

    KALDI_ASSERT(ApproxEqual(N1, O));
    KALDI_ASSERT(ApproxEqual(N2, O));
  }
}

UnitTestCuMatrixAddToDiag()

static void kaldi::UnitTestCuMatrixAddToDiag ( )

static

Definition at line 1789 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddToDiag(), MatrixBase< Real >::AddToDiag(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, and Rand().

                                        {
  for (int32 i = 0; i < 10; i++) {
    int32 dimM = 100 + Rand() % 200, dimN = 100 + Rand() % 200;
    Matrix<Real> M(dimM, dimN);
    CuMatrix<Real> Mc(M);
    Real alpha = 5.5;
    M.AddToDiag(alpha);
    Mc.AddToDiag(alpha);
    Matrix<Real> M2(Mc);
    KALDI_ASSERT(ApproxEqual(M, M2));
  }
}

UnitTestCuMatrixAddToElements()

static void kaldi::UnitTestCuMatrixAddToElements ( )

static

Definition at line 2867 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddToElements(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::SetRandn(), and WithProb().

                                            {
  for (int32 i = 0; i < 2; i++) {
    int32 NR = 100 + Rand() % 50, NC = 100 + Rand() % 50;
    CuMatrix<Real> A(NR, NC);
    A.SetRandn();
    CuMatrix<Real> A_copy(A);
    std::vector<int32> elements(NR, -1);
    BaseFloat alpha = -1 + (0.33 * (Rand() % 5));
    for (int32 r = 0; r < NR; r++) {
      MatrixIndexT c = Rand() % NC;
      if (WithProb(0.6)) {
        elements[r] = c;
        A(r, c) += alpha;
      }
    }
    CuArray<int32> cu_elements(elements);
    A_copy.AddToElements(alpha, cu_elements);
    KALDI_ASSERT(ApproxEqual(A_copy, A));
  }
}

UnitTestCuMatrixAddToRows()

static void kaldi::UnitTestCuMatrixAddToRows ( )

static

Definition at line 594 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddToRows(), ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                        {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    Real alpha =
        static_cast<Real>((Rand() % num_rows2)) / static_cast<Real>(num_rows1);

    CuMatrix<Real> N1(num_rows2, num_cols), N2(num_rows2, num_cols),
        O(num_rows2, num_cols);
    std::vector<int32> reorder(num_rows1);
    std::vector<Real*> reorder_dst(num_rows1, NULL);
    unordered_map<MatrixIndexT, bool> used_index;
    for (int32 i = 0; i < num_rows1; i++) {
      MatrixIndexT index = -1 + (Rand() % (num_rows2 + 1));
      if (used_index.find(index) == used_index.end()) {
        used_index[index] = true;
      } else {
        index = -1;
      }
      reorder[i] = index;
      if (index != -1) {
        reorder_dst[i] = N1.RowData(index);
        for (int32 j = 0; j < num_cols; j++)
          O(index, j) += alpha * M(i, j);
      }
    }

    CuArray<int32> reorder_cuda(reorder);
    CuArray<Real*> reorder_dst_cuda(reorder_dst);
    M.AddToRows(alpha, reorder_dst_cuda);
    M.AddToRows(alpha, reorder_cuda, &N2);
    KALDI_ASSERT(ApproxEqual(N1, O));
    KALDI_ASSERT(ApproxEqual(N2, O));
  }
}

UnitTestCuMatrixAddTpMat()

static void kaldi::UnitTestCuMatrixAddTpMat ( )

static

Definition at line 1891 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddTpMat(), MatrixBase< Real >::AddTpMat(), rnnlm::i, KALDI_ASSERT, kNoTrans, Rand(), PackedMatrix< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                       {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;

    Matrix<Real> A(dim, dim);
    Matrix<Real> B(dim, dim);
    TpMatrix<Real> C(dim);
    A.SetRandn();
    B.SetRandn();
    C.SetRandn();
    CuMatrix<Real> D(A);
    CuMatrix<Real> E(B);
    CuTpMatrix<Real> F(C);

    A.AddTpMat(1.0, C, kNoTrans, B, kNoTrans, 1.0);
    D.AddTpMat(1.0, F, kNoTrans, E, kNoTrans, 1.0);

    CuMatrix<Real> G(A);
    KALDI_ASSERT(ApproxEqual<Real>(G, D));
  }
}

UnitTestCuMatrixAddVecToCols()

static void kaldi::UnitTestCuMatrixAddVecToCols ( )

static

Definition at line 1538 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddVecToCols(), MatrixBase< Real >::AddVecToCols(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), InitRand(), KALDI_ASSERT, and MatrixBase< Real >::SetRandn().

                                           {
  Matrix<Real> Hm(100,99);
  Vector<Real> Hv(100);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(100,99);
  CuVector<Real> Dv(100);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dm.AddVecToCols(0.5,Dv);
  Hm.AddVecToCols(0.5,Hv);

  Matrix<Real> Hm2(100,99);
  Dm.CopyToMat(&Hm2);

  KALDI_ASSERT(ApproxEqual(Hm,Hm2));
}

UnitTestCuMatrixAddVecToRows()

static void kaldi::UnitTestCuMatrixAddVecToRows ( )

static

Definition at line 1561 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddVecToRows(), MatrixBase< Real >::AddVecToRows(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), InitRand(), KALDI_ASSERT, and MatrixBase< Real >::SetRandn().

                                           {
  Matrix<Real> Hm(100,99);
  Vector<Real> Hv(99);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(100,99);
  CuVector<Real> Dv(99);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dm.AddVecToRows(0.5,Dv);
  Hm.AddVecToRows(0.5,Hv);

  Matrix<Real> Hm2(100,99);
  Dm.CopyToMat(&Hm2);

  KALDI_ASSERT(ApproxEqual(Hm,Hm2));
}

UnitTestCuMatrixAddVecVec()

static void kaldi::UnitTestCuMatrixAddVecVec ( )

static

Definition at line 1691 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddVecVec(), MatrixBase< Real >::AddVecVec(), ApproxEqual(), CuVectorBase< Real >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, and VectorBase< Real >::SetRandn().

                                        {
  Vector<Real> x(100);
  Vector<Real> y(200);
  x.SetRandn();
  y.SetRandn();

  CuVector<Real> Cux(100);
  CuVector<Real> Cuy(200);
  Cux.CopyFromVec(x);
  Cuy.CopyFromVec(y);

  Matrix<Real> A(100,200);
  CuMatrix<Real> CuA(100,200);

  A.AddVecVec(0.5f, x, y);
  CuA.AddVecVec(0.5f, Cux, Cuy);
  Matrix<Real> A2(100, 200);
  CuA.CopyToMat(&A2);

  KALDI_ASSERT(ApproxEqual(A,A2));
}

UnitTestCuMatrixApplyCeiling()

static void kaldi::UnitTestCuMatrixApplyCeiling ( )

static

Definition at line 933 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyCeiling(), CuMatrixBase< Real >::ApplyCeiling(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kTrans, Rand(), and MatrixBase< Real >::SetRandn().

                                           {

  for (int32 i = 0; i < 3; i++) {
    BaseFloat ceiling = 0.33 * (Rand() % 6);

    Matrix<Real> H(10 + Rand() % 600, 10 + Rand() % 20);
    H.SetRandn();
    if (i == 2) { Matrix<Real> tmp(H,kTrans); H = tmp; }

    CuMatrix<Real> cH(H);

    cH.ApplyCeiling(ceiling);

    H.ApplyCeiling(ceiling);
    Matrix<Real> H2(cH);

    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixApplyExp()

static void kaldi::UnitTestCuMatrixApplyExp ( )

static

Definition at line 181 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyExp(), CuMatrixBase< Real >::ApplyExp(), ApproxEqual(), KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                       {
  int32 M = 10 + Rand() % 20, N = 10 + Rand() % 20;
  Matrix<Real> H(M, N);
  H.SetRandn();

  CuMatrix<Real> D(H);

  D.ApplyExp();
  H.ApplyExp();

  Matrix<Real> H2(D);

  KALDI_ASSERT(ApproxEqual(H,H2));
}

UnitTestCuMatrixApplyExpLimited()

static void kaldi::UnitTestCuMatrixApplyExpLimited ( )

static

Definition at line 198 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyCeiling(), MatrixBase< Real >::ApplyExp(), CuMatrixBase< Real >::ApplyExpLimited(), MatrixBase< Real >::ApplyFloor(), ApproxEqual(), KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                              {
  int32 M = 10 + Rand() % 20, N = 10 + Rand() % 20;
  Matrix<Real> H(M, N);
  H.SetRandn();

  BaseFloat lower_limit = -0.2, upper_limit = 0.2;

  CuMatrix<Real> D(H);
  D.ApplyExpLimited(lower_limit, upper_limit);

  H.ApplyFloor(lower_limit);
  H.ApplyCeiling(upper_limit);
  H.ApplyExp();
  Matrix<Real> H2(D);

  KALDI_ASSERT(ApproxEqual(H,H2));
}

UnitTestCuMatrixApplyExpSpecial()

static void kaldi::UnitTestCuMatrixApplyExpSpecial ( )

static

Definition at line 165 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyExpSpecial(), CuMatrixBase< Real >::ApplyExpSpecial(), ApproxEqual(), KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                              {
  int32 M = 10 + Rand() % 20;
  int32 N = 10 + Rand() % 20;
  Matrix<Real> H(M, N);
  H.SetRandn();

  CuMatrix<Real> D(H);

  D.ApplyExpSpecial();
  H.ApplyExpSpecial();

  Matrix<Real> H2(D);
  KALDI_ASSERT(ApproxEqual(H,H2));
}

UnitTestCuMatrixApplyFloor()

static void kaldi::UnitTestCuMatrixApplyFloor ( )

static

Definition at line 912 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyFloor(), CuMatrixBase< Real >::ApplyFloor(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kTrans, Rand(), and MatrixBase< Real >::SetRandn().

                                         {

  for (int32 i = 0; i < 3; i++) {
    BaseFloat floor = 0.33 * (Rand() % 6);

    Matrix<Real> H(10 + Rand() % 600, 10 + Rand() % 20);
    H.SetRandn();
    if (i == 2) { Matrix<Real> tmp(H, kTrans); H = tmp; }

    CuMatrix<Real> cH(H);

    cH.ApplyFloor(floor);

    H.ApplyFloor(floor);
    Matrix<Real> H2(cH);

    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixApplyHeaviside()

static void kaldi::UnitTestCuMatrixApplyHeaviside ( )

static

Definition at line 954 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyHeaviside(), CuMatrixBase< Real >::ApplyHeaviside(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kTrans, Rand(), MatrixBase< Real >::Row(), and MatrixBase< Real >::SetRandn().

                                             {

  for (int32 i = 0; i < 1; i++) {
    Matrix<Real> H(10 + Rand() % 60, 10 + Rand() % 20);
    H.SetRandn();
    H.Row(0).Set(0.0);
    if (i == 2) { Matrix<Real> tmp(H, kTrans); H = tmp; }


    CuMatrix<Real> cH(H);

    cH.ApplyHeaviside();
    H.ApplyHeaviside();
    Matrix<Real> H2(cH);
    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixApplyLog()

static void kaldi::UnitTestCuMatrixApplyLog ( )

static

Definition at line 143 of file cu-matrix-test.cc.

References MatrixBase< Real >::Add(), MatrixBase< Real >::ApplyLog(), CuMatrixBase< Real >::ApplyLog(), ApproxEqual(), KALDI_ASSERT, MatrixBase< Real >::MulElements(), Rand(), and MatrixBase< Real >::SetRandUniform().

                                       {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  Matrix<Real> H(M, N);
  H.SetRandUniform(); // Using uniform distribution to ensure positive numbers
  H.Add(0.1);         // Add bias to eliminate zeros
  H.MulElements(H); // make numbers positive

  CuMatrix<Real> D(H);

  D.ApplyLog();
  H.ApplyLog();

  Matrix<Real> H2(D);

  KALDI_ASSERT(ApproxEqual(H,H2));
}

UnitTestCuMatrixApplyPow()

static void kaldi::UnitTestCuMatrixApplyPow ( )

static

Definition at line 349 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyPow(), CuMatrixBase< Real >::ApplyPow(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kTrans, MatrixBase< Real >::MulElements(), Rand(), MatrixBase< Real >::Row(), and MatrixBase< Real >::SetRandn().

                                       {

  for (int32 i = 0; i < 2; i++) {
    BaseFloat pow = 0.5 * (Rand() % 6);

    Matrix<Real> H(10 + Rand() % 60, 10 + Rand() % 20);
    H.SetRandn();
    H.Row(0).Set(0.0);
    if (i == 2) { Matrix<Real> tmp(H, kTrans); H = tmp; }

    if (pow != 1.0 && pow != 2.0 && pow != 3.0)
      H.MulElements(H); //make numbers positive

    CuMatrix<Real> cH(H);

    cH.ApplyPow(pow);

    H.ApplyPow(pow);
    Matrix<Real> H2(cH);
    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixApplyPowAbs()

static void kaldi::UnitTestCuMatrixApplyPowAbs ( )

static

Definition at line 373 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyPowAbs(), CuMatrixBase< Real >::ApplyPowAbs(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kTrans, Rand(), MatrixBase< Real >::Row(), and MatrixBase< Real >::SetRandn().

                                          {

  for (int32 i = 0; i < 2; i++) {
    BaseFloat pow = 0.5 * (Rand() % 6);

    Matrix<Real> H(10 + Rand() % 60, 10 + Rand() % 20);
    H.SetRandn();
    H.Row(0).Set(0.0);
    if (i == 2) { Matrix<Real> tmp(H, kTrans); H = tmp; }

    CuMatrix<Real> cH(H);

    cH.ApplyPowAbs(pow, true);

    H.ApplyPowAbs(pow, true);
    Matrix<Real> H2(cH);
    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixCopyCols()

static void kaldi::UnitTestCuMatrixCopyCols ( )

static

Definition at line 753 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                       {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_cols1 = 10 + Rand() % 10,
        num_cols2 = 10 + Rand() % 10,
        num_rows = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows, num_cols1);
    M.SetRandn();

    CuMatrix<Real> N(num_rows, num_cols2), O(num_rows, num_cols2);
    std::vector<int32> reorder(num_cols2);
    for (int32 i = 0; i < num_cols2; i++)
      reorder[i] = -1 + (Rand() % (num_cols1 + 1));

    CuArray<int32> reorder_gpu(reorder);
    N.CopyCols(M, reorder_gpu);

    for (int32 i = 0; i < num_rows; i++)
      for (int32 j = 0; j < num_cols2; j++)
        if (reorder[j] < 0) O(i, j) = 0;
        else O(i, j) = M(i, reorder[j]);
    KALDI_ASSERT(ApproxEqual(N, O));
  }
}

UnitTestCuMatrixCopyColsFromVec()

static void kaldi::UnitTestCuMatrixCopyColsFromVec ( )

static

Definition at line 422 of file cu-matrix-test.cc.

References ApproxEqual(), MatrixBase< Real >::CopyColsFromVec(), CuMatrixBase< Real >::CopyColsFromVec(), KALDI_ASSERT, Rand(), and CuVectorBase< Real >::SetRandn().

                                              {
  for (int32 p = 0; p < 2; p++) {
    int32 num_rows = 100 + Rand() % 255;
    int32 num_cols = 100 + Rand() % 200;

    int32 vec_dim;
    if (p % 2 == 0) vec_dim = num_rows;
    else vec_dim = num_cols * num_rows;

    CuVector<Real> cu_vec(vec_dim);
    cu_vec.SetRandn();
    Vector<Real> vec(cu_vec);

    CuMatrix<Real> cu_mat(num_rows, num_cols);
    cu_mat.CopyColsFromVec(cu_vec);
    Matrix<Real> mat(num_rows, num_cols);
    mat.CopyColsFromVec(vec);

    Matrix<Real> mat2(cu_mat);
    KALDI_ASSERT(ApproxEqual(mat, mat2));
  }
}

UnitTestCuMatrixCopyCross()

void kaldi::UnitTestCuMatrixCopyCross

(

)

Definition at line 636 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, kTrans, Rand(), and CuMatrixBase< Real >::SetRandn().

                                 {
  for (int32 i = 0; i < 2; i++) {
    int32 M = 100 + Rand() % 255, N = 100 + Rand() % 255;
    if (Rand() % 3 == 0) { M = 0; N = 0; }
    CuMatrix<Real> mat1(M, N);
    mat1.SetRandn();
    if (i % 2 == 0) {
      CuMatrix<float> mat2(M, N);
      mat2.CopyFromMat(mat1);
      CuMatrix<Real> mat3(M, N);
      mat3.CopyFromMat(mat2);
      KALDI_ASSERT(ApproxEqual(mat1, mat3));
    } else {
      CuMatrix<float> mat2(N, M);
      mat2.CopyFromMat(mat1, kTrans);
      CuMatrix<Real> mat3(M, N);
      mat3.CopyFromMat(mat2, kTrans);
      KALDI_ASSERT(ApproxEqual(mat1, mat3));
    }
  }
}

UnitTestCuMatrixCopyCross2()

void kaldi::UnitTestCuMatrixCopyCross2

(

)

Definition at line 658 of file cu-matrix-test.cc.

References ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                                          {
  for (int32 i = 0; i < 2; i++) {
    int32 M = 100 + Rand() % 255, N = 100 + Rand() % 255;
    if (Rand() % 3 == 0) { M = 0; N = 0; }
    CuMatrix<Real> mat1(M, N);
    mat1.SetRandn();
    Matrix<float> mat2(M, N);
    mat2.CopyFromMat(mat1);
    CuMatrix<Real> mat3(M, N);
    mat3.CopyFromMat(mat2);
    KALDI_ASSERT(ApproxEqual(mat1, mat3));
  }
}

UnitTestCuMatrixCopyFromMat()

static void kaldi::UnitTestCuMatrixCopyFromMat ( )

static

Definition at line 1818 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                          {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;

    Matrix<Real> A(dim, dim);
    A.SetRandn();
    CuMatrix<Real> E(A);
    CuMatrix<Real> B(dim, dim);
    B.CopyFromMat(E);

    KALDI_ASSERT(ApproxEqual<Real>(B, E));
  }
}

UnitTestCuMatrixCopyFromTp()

static void kaldi::UnitTestCuMatrixCopyFromTp ( )

static

Definition at line 1833 of file cu-matrix-test.cc.

References MatrixBase< Real >::CopyFromTp(), CuMatrixBase< Real >::CopyFromTp(), rnnlm::i, KALDI_ASSERT, kNoTrans, Rand(), and PackedMatrix< Real >::SetRandn().

                                         {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;
    TpMatrix<Real> A(dim);
    A.SetRandn();
    CuTpMatrix<Real> E(A);
    Matrix<Real> B(dim, dim);
    CuMatrix<Real> C(dim, dim);
    B.CopyFromTp(A, kNoTrans);
    C.CopyFromTp(E, kNoTrans);
    CuMatrix<Real> D(B);
    KALDI_ASSERT(ApproxEqual<Real>(D, C));
  }
}

UnitTestCuMatrixCopyLowerToUpper()

static void kaldi::UnitTestCuMatrixCopyLowerToUpper ( )

static

Definition at line 2718 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::CopyLowerToUpper(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::SetRandn(), and MatrixBase< Real >::Trace().

                                               {
  for (int i = 1; i < 2; ++i) {
    MatrixIndexT dim = 10 * i + Rand() % 4 + (i == 9 ? 255 : 0);
    if (i == 8) dim = 0;
    CuMatrix<Real> A(dim, dim);
    A.SetRandn();
    Matrix<Real> A2(A);
    A.CopyLowerToUpper();
    Matrix<Real> A3(A);
    for (int32 i = 0; i < dim;  i++) {
      for (int32 j = 0; j <= i; j++) {
        KALDI_ASSERT(A3(i, j) == A3(j, i));
        KALDI_ASSERT(A3(i, j) == A2(i, j));
      }
    }
    KALDI_ASSERT(dim == 0 || A3.Trace() != 0);
  }
}

UnitTestCuMatrixCopyRows()

static void kaldi::UnitTestCuMatrixCopyRows ( )

static

Definition at line 447 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                       {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    CuMatrix<Real> N1(num_rows2, num_cols),
        N2(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<int32> reorder(num_rows2);
    std::vector<const Real*> reorder_src(num_rows2, NULL);
    for (int32 i = 0; i < num_rows2; i++) {
      reorder[i] = -1 + (Rand() % (num_rows1 + 1));
      if (reorder[i] != -1) {
        reorder_src[i] = M.RowData(reorder[i]);
      }
    }

    CuArray<int32> reorder_cuda(reorder);
    CuArray<const Real*> reorder_src_cuda(reorder_src);
    N1.CopyRows(M, reorder_cuda);
    N2.CopyRows(reorder_src_cuda);

    for (int32 i = 0; i < num_rows2; i++)
      for (int32 j = 0; j < num_cols; j++)
        if (reorder[i] < 0) O(i, j) = 0;
        else O(i, j) = M(reorder[i], j);

    KALDI_ASSERT(ApproxEqual(N1, O));
    KALDI_ASSERT(ApproxEqual(N2, O));
  }
}

UnitTestCuMatrixCopyRowsFromVec()

static void kaldi::UnitTestCuMatrixCopyRowsFromVec ( )

static

Definition at line 395 of file cu-matrix-test.cc.

References ApproxEqual(), MatrixBase< Real >::CopyRowsFromVec(), CuMatrixBase< Real >::CopyRowsFromVec(), KALDI_ASSERT, Rand(), and CuVectorBase< Real >::SetRandn().

                                              {
  for (int32 p = 0; p < 2; p++) {
    int32 num_rows = 100 + Rand() % 255, num_cols;
    if (p <= 2) num_cols = 128;
    else if (p <= 4) num_cols = 256;
    else num_cols = 100 + Rand() % 200;

    int32 vec_dim;
    if (p % 2 == 0) vec_dim = num_cols;
    else vec_dim = num_cols * num_rows;

    CuVector<Real> cu_vec(vec_dim);
    cu_vec.SetRandn();
    Vector<Real> vec(cu_vec);

    CuMatrix<Real> cu_mat(num_rows, num_cols);
    cu_mat.CopyRowsFromVec(cu_vec);
    Matrix<Real> mat(num_rows, num_cols);
    mat.CopyRowsFromVec(vec);

    Matrix<Real> mat2(cu_mat);
    KALDI_ASSERT(ApproxEqual(mat, mat2));
  }
}

UnitTestCuMatrixCopyToRows()

static void kaldi::UnitTestCuMatrixCopyToRows ( )

static

Definition at line 483 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyToRows(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and CuMatrixBase< Real >::SetRandn().

                                         {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    CuMatrix<Real> N(num_rows2, num_cols), O(num_rows2, num_cols);
    std::vector<Real*> reorder_dst(num_rows1, NULL);
    unordered_map<MatrixIndexT, bool> used_index;
    for (int32 i = 0; i < num_rows1; i++) {
      MatrixIndexT index = -1 + (Rand() % (num_rows2 + 1));
      if (used_index.find(index) == used_index.end()) {
        used_index[index] = true;
      } else {
        index = -1;
      }
      if (index != -1) {
        reorder_dst[i] = N.RowData(index);
        for (int32 j = 0; j < num_cols; j++)
          O(index, j) = M(i, j);
      }
    }

    CuArray<Real*> reorder_dst_cuda(reorder_dst);
    M.CopyToRows(reorder_dst_cuda);

    KALDI_ASSERT(ApproxEqual(N, O));
  }
}

UnitTestCuMatrixCopyUpperToLower()

static void kaldi::UnitTestCuMatrixCopyUpperToLower ( )

static

Definition at line 2759 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::CopyUpperToLower(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::SetRandn(), and MatrixBase< Real >::Trace().

                                               {
  for (int i = 1; i < 10; ++i) {
    MatrixIndexT dim = 10 * i + Rand() % 4 + (i == 9 ? 255 : 0);
    if (i == 8) dim = 0;
    CuMatrix<Real> A(dim, dim);
    A.SetRandn();
    Matrix<Real> A2(A);
    A.CopyUpperToLower();
    Matrix<Real> A3(A);
    //KALDI_LOG << "A2 is " << A2 << " A3 is " << A3;
    for (int32 i = 0; i < dim;  i++) {
      for (int32 j = i; j < dim; j++) {
        KALDI_ASSERT(A3(i, j) == A3(j, i));
        KALDI_ASSERT(A3(i, j) == A2(i, j));
      }
    }
    KALDI_ASSERT(dim == 0 || A3.Trace() != 0);
  }
}

UnitTestCuMatrixDiffGroupPnorm()

static void kaldi::UnitTestCuMatrixDiffGroupPnorm ( )

static

Definition at line 1164 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyFloor(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::DiffGroupPnorm(), MatrixBase< Real >::GroupPnorm(), MatrixBase< Real >::GroupPnormDeriv(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::MulRowsGroupMat(), Rand(), and MatrixBase< Real >::SetRandn().

                                             {
  Real p[] = { 1.234, 2.345, 1, 2, std::numeric_limits<Real>::infinity() };
  for (int i = 0; i < 2 * sizeof(p) / sizeof(Real); i++) {
    int32 dimM = 100 + Rand() % 200, dimNs = 100 + Rand() % 200;
    int32 group_size = 1 + Rand() % 10;
    BaseFloat power = p[i / 2];
    int32 dimN = group_size * dimNs;
    Matrix<Real> Hiv(dimM, dimN);
    Matrix<Real> Hov(dimM, dimNs);
    Matrix<Real> Hid(dimM, dimN);
    Matrix<Real> Hod(dimM, dimNs);
    Hiv.SetRandn();
    Hod.SetRandn();
    if (i % 2 == 0)
      Hiv.ApplyFloor(0.0); // will put some zeros in the matrix.. harder to
                           // do derivatives.
    Hov.GroupPnorm(Hiv, power);
    CuMatrix<Real> Div(dimM, dimN);
    CuMatrix<Real> Dov(dimM, dimNs);
    CuMatrix<Real> Did(dimM, dimN);
    CuMatrix<Real> Dod(dimM, dimNs);
    Div.CopyFromMat(Hiv);
    Dod.CopyFromMat(Hod);
    Dov.CopyFromMat(Hov);

    // GPU
    Did.DiffGroupPnorm(Div, Dov, Dod, power);

    // CPU
    Hid.GroupPnormDeriv(Hiv, Hov, power);
    Hid.MulRowsGroupMat(Hod);

    Matrix<Real> Hid2(dimM, dimN);
    Did.CopyToMat(&Hid2);
    KALDI_ASSERT(ApproxEqual(Hid, Hid2));
  }
}

UnitTestCuMatrixDivElements()

static void kaldi::UnitTestCuMatrixDivElements ( )

static

Definition at line 1018 of file cu-matrix-test.cc.

References MatrixBase< Real >::Add(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), MatrixBase< Real >::DivElements(), CuMatrixBase< Real >::DivElements(), rnnlm::i, KALDI_ASSERT, Rand(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandUniform().

                                          {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT dimM = 100 + Rand() % 256, dimN = 100 + Rand() % 256;

    Matrix<Real> Ha(dimM, dimN);
    Matrix<Real> Hb(dimM, dimN);
    Ha.SetRandn();

    Hb.SetRandUniform();  // Use uniform distirbution t ensure positive numbers
    Hb.Add(0.1);          // Add bias to ensure we do not divide by zero

    CuMatrix<Real> Da(dimM, dimN);
    CuMatrix<Real> Db(dimM, dimN);
    Da.CopyFromMat(Ha);
    Db.CopyFromMat(Hb);

    Da.DivElements(Db);
    Ha.DivElements(Hb);

    Matrix<Real> Ha2(dimM, dimN);
    Da.CopyToMat(&Ha2);

    KALDI_ASSERT(ApproxEqual(Ha,Ha2));
  }
}

UnitTestCuMatrixDivRowsVec()

static void kaldi::UnitTestCuMatrixDivRowsVec ( )

static

Definition at line 1342 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), CuMatrixBase< Real >::DivRowsVec(), InitRand(), VectorBase< Real >::InvertElements(), KALDI_ASSERT, MatrixBase< Real >::MulRowsVec(), and MatrixBase< Real >::SetRandn().

                                         {
  MatrixIndexT dimM = 1000, dimN = 5;
  Matrix<Real> Hm(dimM, dimN);
  Vector<Real> Hv(dimM);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(dimM, dimN);
  CuVector<Real> Dv(dimM);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dm.DivRowsVec(Dv);
  Hv.InvertElements();
  Hm.MulRowsVec(Hv);

  Matrix<Real> Hm2(dimM, dimN);
  Dm.CopyToMat(&Hm2);

  KALDI_ASSERT(ApproxEqual(Hm, Hm2));
}

UnitTestCuMatrixEqualElementMask()

static void kaldi::UnitTestCuMatrixEqualElementMask ( )

static

Definition at line 2920 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::Add(), KALDI_ASSERT, kSetZero, CuMatrixBase< Real >::SetRandUniform(), and CuMatrixBase< Real >::Sum().

                                               {
  CuMatrix<Real> m1(10,9), m2(10,9);
  CuMatrix<Real> mask_same, mask_different;
  m1.SetRandUniform(); // U[0,1]
  m2.SetRandUniform(); m2.Add(10.0); // U[10,11]

  m1.EqualElementMask(m1,&mask_same); // all elements ones
  m1.EqualElementMask(m2,&mask_different); // all elements zeros

  //KALDI_LOG << m1 << m2 << mask_same << mask_different;
  KALDI_ASSERT(mask_same.Sum() == 10*9);
  KALDI_ASSERT(mask_different.Sum() == 0.0);

  //check matrices with different strides:
  CuMatrix<Real> m3(m1.Range(1,6,2,6));
  CuMatrix<Real> m4(5,5,kSetZero);
  m1.Range(1,5,2,5).EqualElementMask(m3.Range(0,5,0,5),&m4); // strides 9, 6, 5
  KALDI_ASSERT(m4.Sum() == 25);

}

UnitTestCuMatrixGroupMax()

static void kaldi::UnitTestCuMatrixGroupMax ( )

static

Definition at line 313 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyFloor(), ApproxEqual(), CuMatrixBase< Real >::GroupMax(), MatrixBase< Real >::GroupMax(), KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                       {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  // M = 256; N = 256;
  for (int32 K = 5; K < 7; K++) {
    int32 N_src = N * K;
    Matrix<Real> H_src(M, N_src);
    H_src.SetRandn();
    if (rand () % 2 == 0)
      H_src.ApplyFloor(0.0); // will put some zeros in the matrix.. harder to
                             // do derivatives.
    Matrix<Real> H(M, N);
    H.GroupMax(H_src);
    CuMatrix<Real> D(H_src);
    CuMatrix<Real> E(M, N);
    E.GroupMax(D);
    Matrix<Real> H2(E);
    KALDI_ASSERT(ApproxEqual(H,H2));
  }
}

UnitTestCuMatrixGroupMaxDeriv()

static void kaldi::UnitTestCuMatrixGroupMaxDeriv ( )

static

Definition at line 1204 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyFloor(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), MatrixBase< Real >::GroupMax(), CuMatrixBase< Real >::GroupMaxDeriv(), MatrixBase< Real >::GroupMaxDeriv(), KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                            {
  int32 dimM = 100 + Rand() % 200, dimNs = 100 + Rand() % 200;
  int32 group_size = 1 + Rand() % 10;
  // int32 dimM = 256, dimNs = 2;
  // int32 group_size = 2;
  int32 dimN = group_size * dimNs;
  Matrix<Real> Hm(dimM, dimN);
  Matrix<Real> Hr(dimM, dimN);
  Matrix<Real> Hs(dimM, dimNs);
  Hs.SetRandn();
  if (rand () % 2 == 0)
    Hm.ApplyFloor(0.0); // will put some zeros in the matrix.. harder to
                        // do derivatives.
  Hs.GroupMax(Hm);

  CuMatrix<Real> Dm(dimM, dimN);
  CuMatrix<Real> Dr(dimM, dimN);
  CuMatrix<Real> Ds(dimM, dimNs);
  Dm.CopyFromMat(Hm);
  Dr.CopyFromMat(Hr);
  Ds.CopyFromMat(Hs);

  // KALDI_LOG << "Hr " << Hr << " Dr " << Dr << "Ds" << Ds << " Hs " << Hs ;
  Dr.GroupMaxDeriv(Dm, Ds);
  Hr.GroupMaxDeriv(Hm, Hs);

  // KALDI_LOG << "Hr " << Hr << " Dr " << Dr << "Ds" << Ds << " Hs " << Hs ;
  Matrix<Real> Hr2(dimM, dimN);
  Dr.CopyToMat(&Hr2);
  KALDI_ASSERT(ApproxEqual(Hr,Hr2));
}

UnitTestCuMatrixGroupPnorm()

static void kaldi::UnitTestCuMatrixGroupPnorm ( )

static

Definition at line 288 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyFloor(), ApproxEqual(), CuMatrixBase< Real >::GroupPnorm(), MatrixBase< Real >::GroupPnorm(), rnnlm::i, KALDI_ASSERT, Rand(), and MatrixBase< Real >::SetRandn().

                                         {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  Real power[] = { 1.4, 1.6, 0.1234, 2.123, 0, 1, 2,
      std::numeric_limits<Real>::infinity() };
  for (int32 K = 5; K < 7; K++) {
    for (int32 i = 0; i < 2 * sizeof(power) / sizeof(Real); ++i) {
      Real p = power[i / 2];
      int32 N_src = N * K;
      Matrix<Real> H_src(M, N_src);
      H_src.SetRandn();
      if (i % 2 == 0)
        H_src.ApplyFloor(0.0); // will put some zeros in the matrix.. harder to
                               // do derivatives.
      Matrix<Real> H(M, N);
      H.GroupPnorm(H_src, p);
      CuMatrix<Real> D(H_src);
      CuMatrix<Real> E(M, N);
      E.GroupPnorm(D, p);
      Matrix<Real> H2(E);
      KALDI_ASSERT(ApproxEqual(H, H2));
    }
  }
}

UnitTestCuMatrixHeaviside()

static void kaldi::UnitTestCuMatrixHeaviside ( )

static

Definition at line 974 of file cu-matrix-test.cc.

References MatrixBase< Real >::ApplyHeaviside(), ApproxEqual(), CuMatrixBase< Real >::Heaviside(), rnnlm::i, KALDI_ASSERT, kTrans, kUndefined, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Row(), and MatrixBase< Real >::SetRandn().

                                        {

  for (int32 i = 0; i < 1; i++) {
    Matrix<Real> H(10 + Rand() % 60, 10 + Rand() % 20);
    H.SetRandn();
    H.Row(0).Set(0.0);
    if (i == 2) { Matrix<Real> tmp(H, kTrans); H = tmp; }

    CuMatrix<Real> cH(H);
    CuMatrix<Real> cH2(H.NumRows(), H.NumCols(), kUndefined);
    cH2.Heaviside(cH);
    H.ApplyHeaviside();
    Matrix<Real> H2(cH2);
    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixInvertElements()

static void kaldi::UnitTestCuMatrixInvertElements ( )

static

Definition at line 2093 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), InitRand(), MatrixBase< Real >::InvertElements(), CuMatrixBase< Real >::InvertElements(), and KALDI_ASSERT.

                                             {
  Matrix<Real> Hm(77, 77);
  InitRand(&Hm);

  CuMatrix<Real> Dm(77, 77);
  Dm.CopyFromMat(Hm);

  Dm.InvertElements();
  Hm.InvertElements();

  Matrix<Real> Hm2(77, 77);
  Dm.CopyToMat(&Hm2);

  KALDI_ASSERT(ApproxEqual(Hm,Hm2));
}

UnitTestCuMatrixIO()

static void kaldi::UnitTestCuMatrixIO ( )

static

Definition at line 2111 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, Rand(), CuMatrix< Real >::Read(), CuMatrixBase< Real >::SetRandn(), swap(), and CuMatrixBase< Real >::Write().

                                 {
  for (int32 i = 0; i < 10; i++) {
    int32 dimM = 100 + Rand() % 255, dimN = 10 + Rand() % 20;
    if (i % 2 == 0) std::swap(dimM, dimN);
    if (i % 5 == 0) { dimM = 0; dimN = 0; }
    CuMatrix<Real> mat(dimM, dimN);
    mat.SetRandn();
    std::ostringstream os;
    bool binary = (i % 4 < 2);
    mat.Write(os, binary);

    CuMatrix<Real> mat2;
    std::istringstream is(os.str());
    mat2.Read(is, binary);
    KALDI_ASSERT(ApproxEqual(mat, mat2));
  }
}

UnitTestCuMatrixLookup()

static void kaldi::UnitTestCuMatrixLookup ( )

static

Definition at line 2889 of file cu-matrix-test.cc.

References Int32Pair::first, rnnlm::i, rnnlm::j, KALDI_ASSERT, CuMatrixBase< Real >::Lookup(), Rand(), Int32Pair::second, and CuMatrixBase< Real >::SetRandn().

                                     {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 100 + Rand() % 200, dimN = 100 + Rand() % 200;
    CuMatrix<Real> H(dimM, dimN);
    H.SetRandn();

    int32 num_elements = 10 + Rand() % 10;
    std::vector<Int32Pair> indices;
    std::vector<Real> reference;
    std::vector<Real> output;
    output.resize(num_elements);

    // Generates the indices and the reference.
    for (int32 j = 0; j < num_elements; j++) {
      MatrixIndexT r = Rand() % dimM;
      MatrixIndexT c = Rand() % dimN;

      Int32Pair tmp_pair;
      tmp_pair.first = r;
      tmp_pair.second = c;
      indices.push_back(tmp_pair);
      reference.push_back(H(r, c));
    }

    H.Lookup(indices, &(output[0]));

    KALDI_ASSERT(reference == output);
  }
}

UnitTestCuMatrixMax()

static void kaldi::UnitTestCuMatrixMax ( )

static

Definition at line 1045 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, MatrixBase< Real >::Max(), CuMatrixBase< Real >::Max(), and MatrixBase< Real >::SetRandn().

                                  {
  Matrix<Real> Ha(100,100);
  Matrix<Real> Hb(100,100);
  Ha.SetRandn();
  Hb.SetRandn();

  CuMatrix<Real> Da(100,100);
  CuMatrix<Real> Db(100,100);
  
  Da.CopyFromMat(Ha);
  Db.CopyFromMat(Hb);

  Da.Max(Db);
  Ha.Max(Hb);

  Matrix<Real> Ha2(100,100);
  Da.CopyToMat(&Ha2);

  KALDI_ASSERT(ApproxEqual(Ha,Ha2));
}

UnitTestCuMatrixMin()

static void kaldi::UnitTestCuMatrixMin ( )

static

Definition at line 1067 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, MatrixBase< Real >::Min(), CuMatrixBase< Real >::Min(), and MatrixBase< Real >::SetRandn().

                                  {
  Matrix<Real> Ha(100,100);
  Matrix<Real> Hb(100,100);
  Ha.SetRandn();
  Hb.SetRandn();

  CuMatrix<Real> Da(100,100);
  CuMatrix<Real> Db(100,100);
  Da.CopyFromMat(Ha);
  Db.CopyFromMat(Hb);

  Da.Min(Db);
  Ha.Min(Hb);

  Matrix<Real> Ha2(100,100);
  Da.CopyToMat(&Ha2);

  KALDI_ASSERT(ApproxEqual(Ha, Ha2));
}

UnitTestCuMatrixMulColsVec()

static void kaldi::UnitTestCuMatrixMulColsVec ( )

static

Definition at line 1090 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), InitRand(), KALDI_ASSERT, MatrixBase< Real >::MulColsVec(), CuMatrixBase< Real >::MulColsVec(), and MatrixBase< Real >::SetRandn().

                                         {
  Matrix<Real> Hm(100,99);
  Vector<Real> Hv(99);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(100,99);
  CuVector<Real> Dv(99);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dm.MulColsVec(Dv);
  Hm.MulColsVec(Hv);

  Matrix<Real> Hm2(100,99);
  Dm.CopyToMat(&Hm2);

  KALDI_ASSERT(ApproxEqual(Hm,Hm2));
}

UnitTestCuMatrixMulElements()

static void kaldi::UnitTestCuMatrixMulElements ( )

static

Definition at line 993 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::MulElements(), CuMatrixBase< Real >::MulElements(), Rand(), and MatrixBase< Real >::SetRandn().

                                          {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT dimM = 100 + Rand() % 256, dimN = 100 + Rand() % 256;

    Matrix<Real> Ha(dimM, dimN);
    Matrix<Real> Hb(dimM, dimN);
    Ha.SetRandn();
    Hb.SetRandn();

    CuMatrix<Real> Da(dimM, dimN);
    CuMatrix<Real> Db(dimM, dimN);
    Da.CopyFromMat(Ha);
    Db.CopyFromMat(Hb);

    Da.MulElements(Db);
    Ha.MulElements(Hb);

    Matrix<Real> Ha2(dimM, dimN);
    Da.CopyToMat(&Ha2);

    KALDI_ASSERT(ApproxEqual(Ha,Ha2));
  }
}

UnitTestCuMatrixMulRows()

static void kaldi::UnitTestCuMatrixMulRows ( )

static

Definition at line 558 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::RowData(), and CuMatrixBase< Real >::SetRandn().

                                      {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_rows1 = 10 + Rand() % 10,
        num_rows2 = 10 + Rand() % 10,
        num_cols = 10 + Rand() % 10;
    CuMatrix<Real> M(num_rows1, num_cols);
    M.SetRandn();

    CuMatrix<Real> N1(num_rows2, num_cols),
        O(num_rows2, num_cols);
    std::vector<int32> reorder(num_rows2);
    std::vector<const Real*> reorder_src(num_rows2, NULL);
    for (int32 i = 0; i < num_rows2; i++) {
      reorder[i] = -1 + (Rand() % (num_rows1 + 1));
      if (reorder[i] != -1)
        reorder_src[i] = M.RowData(reorder[i]);
    }

    CuArray<int32> reorder_cuda(reorder);
    N1.MulRows(M, reorder_cuda);

    for (int32 i = 0; i < num_rows2; i++) {
      if (reorder[i] != -1) {
        CuSubVector<Real> O_row(O, i),
            M_row(M, reorder[i]);
        O_row.MulElements(M_row);
      }
    }

    KALDI_ASSERT(ApproxEqual(N1, O));
  }
}

UnitTestCuMatrixMulRowsGroupMat()

static void kaldi::UnitTestCuMatrixMulRowsGroupMat ( )

static

Definition at line 1138 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::MulRowsGroupMat(), CuMatrixBase< Real >::MulRowsGroupMat(), Rand(), and MatrixBase< Real >::SetRandn().

                                              {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 100 + Rand() % 200, dimNs = 100 + Rand() % 200;
    int32 group_size = 1 + Rand() % 10;
    //int32 group_size = 1;
    int32 dimN = group_size * dimNs;
    Matrix<Real> Hm(dimM, dimN);
    Matrix<Real> Hs(dimM, dimNs);
    Hm.SetRandn();
    Hs.SetRandn();

    CuMatrix<Real> Dm(dimM, dimN);
    CuMatrix<Real> Ds(dimM, dimNs);
    Dm.CopyFromMat(Hm);
    Ds.CopyFromMat(Hs);

    Dm.MulRowsGroupMat(Ds);
    Hm.MulRowsGroupMat(Hs);

    Matrix<Real> Hm2(dimM, dimN);
    Dm.CopyToMat(&Hm2);
    KALDI_ASSERT(ApproxEqual(Hm,Hm2));
  }
}

UnitTestCuMatrixMulRowsVec()

static void kaldi::UnitTestCuMatrixMulRowsVec ( )

static

Definition at line 1113 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, InitRand(), KALDI_ASSERT, MatrixBase< Real >::MulRowsVec(), CuMatrixBase< Real >::MulRowsVec(), Rand(), and MatrixBase< Real >::SetRandn().

                                         {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 100 + Rand() % 200, dimN = 100 + Rand() % 200;
   // int32 dimM = 256, dimN = 256;
    Matrix<Real> Hm(dimM, dimN);
    Vector<Real> Hv(dimM);
    Hm.SetRandn();
    InitRand(&Hv);

    CuMatrix<Real> Dm(dimM, dimN);
    CuVector<Real> Dv(dimM);
    Dm.CopyFromMat(Hm);
    Dv.CopyFromVec(Hv);

    Dm.MulRowsVec(Dv);
    Hm.MulRowsVec(Hv);

    Matrix<Real> Hm2(dimM, dimN);
    Dm.CopyToMat(&Hm2);

    KALDI_ASSERT(ApproxEqual(Hm,Hm2));
  }
}

UnitTestCuMatrixObjfDeriv()

static void kaldi::UnitTestCuMatrixObjfDeriv ( )

static

Definition at line 2781 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::Add(), CuMatrixBase< Real >::ApplyFloor(), CuMatrixBase< Real >::ApplyLog(), ApproxEqual(), CuMatrix< Real >::CompObjfAndDeriv(), rnnlm::i, CuMatrixBase< Real >::InvertElements(), rnnlm::j, KALDI_ASSERT, kTrans, Rand(), RandUniform(), CuMatrixBase< Real >::Set(), CuMatrixBase< Real >::SetRandn(), and TraceMatMat().

                                        {
  int32 n_r = 100 + Rand() % 200, n_c = 20 + Rand() % 30;
  CuMatrix<Real> A(n_r, n_c), B(n_r, n_c);
  B.SetRandn();
  B.Add(1.0);
  B.ApplyFloor(1.0e-10);

  std::vector<MatrixElement<Real> > labels;
  for(int i = 0; i < n_r; i++) {
    for(int j = 0; j < n_c; j++) {
      // have approximately one weight per row of the matrix.
      if (Rand() % n_c == 0) {
        A(i, j) = RandUniform();
        MatrixElement<Real> t = {i, j, A(i, j)};
        labels.push_back(t);
      }
    }
  }
  CuMatrix<Real> C(n_r, n_c);
  C.Set(0);
  Real a = 0, b = 0;

  // (sv_labels, logprobs, &tot_objf, &tot_weight)
  C.CompObjfAndDeriv(labels, B, &a, &b);

  KALDI_ASSERT(ApproxEqual(b, A.Sum()));

  Real sum2;  // sum(i, j) A(i, j) log(B(i, j));
  {
    CuMatrix<Real> Bcopy(B);
    Bcopy.ApplyLog();
    sum2 = TraceMatMat(Bcopy, A, kTrans);
  }
  KALDI_ASSERT(ApproxEqual(a, sum2));

  B.InvertElements();
  A.MulElements(B);  // each element of A is now A(i, j) / B(i, j);
  KALDI_ASSERT(ApproxEqual(A, C));
}

UnitTestCuMatrixReduceMax()

static void kaldi::UnitTestCuMatrixReduceMax ( )

static

Definition at line 1520 of file cu-matrix-test.cc.

References ApproxEqual(), KALDI_ASSERT, MatrixBase< Real >::Max(), CuMatrixBase< Real >::Max(), Rand(), and CuMatrixBase< Real >::SetRandn().

                                        {
  int32 M = 100 + Rand() % 300, N = 100 + Rand() % 300;
  CuMatrix<Real> A(M, N);
  A.SetRandn();
  Matrix<Real> mA(A);
  KALDI_ASSERT(ApproxEqual(mA.Max(), A.Max()));
}

UnitTestCuMatrixReduceMin()

static void kaldi::UnitTestCuMatrixReduceMin ( )

static

Definition at line 1529 of file cu-matrix-test.cc.

References ApproxEqual(), KALDI_ASSERT, MatrixBase< Real >::Min(), CuMatrixBase< Real >::Min(), Rand(), and CuMatrixBase< Real >::SetRandn().

                                        {
  int32 M = 100 + Rand() % 300, N = 100 + Rand() % 300;
  CuMatrix<Real> A(M, N);
  A.SetRandn();
  Matrix<Real> mA(A);
  KALDI_ASSERT(ApproxEqual(mA.Min(), A.Min()));
}

UnitTestCuMatrixReduceSum()

static void kaldi::UnitTestCuMatrixReduceSum ( )

static

Definition at line 1511 of file cu-matrix-test.cc.

References ApproxEqual(), KALDI_ASSERT, Rand(), CuMatrixBase< Real >::SetRandn(), MatrixBase< Real >::Sum(), and CuMatrixBase< Real >::Sum().

                                        {
  int32 M = 100 + Rand() % 300, N = 100 + Rand() % 300;
  CuMatrix<Real> A(M, N);
  A.SetRandn();
  Matrix<Real> mA(A);
  KALDI_ASSERT(ApproxEqual(mA.Sum(), A.Sum()));
}

UnitTestCuMatrixScale()

static void kaldi::UnitTestCuMatrixScale ( )

static

Definition at line 239 of file cu-matrix-test.cc.

References ApproxEqual(), KALDI_ASSERT, Rand(), MatrixBase< Real >::Scale(), CuMatrixBase< Real >::Scale(), and MatrixBase< Real >::SetRandn().

                                    {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  Matrix<Real> H(M, N);
  H.SetRandn();

  BaseFloat scale = -1 + (0.33 * (Rand() % 5));
  CuMatrix<Real> D(H);
  D.Scale(scale);
  H.Scale(scale);
  Matrix<Real> E(D);

  KALDI_ASSERT(ApproxEqual(H, E));
}

UnitTestCuMatrixSet()

static void kaldi::UnitTestCuMatrixSet ( )

static

Definition at line 334 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, Rand(), MatrixBase< Real >::Set(), and CuMatrixBase< Real >::Set().

                                  {
  for (int32 i = 0; i < 2; i++) {
    BaseFloat value= 0.333;
    int32 dimM = 10 + Rand() % 600, dimN = 10 + Rand() % 400;
    CuMatrix<Real> m1(dimM, dimN);
    Matrix<Real> m2(dimM, dimN);
    m1.Set(value);
    m2.Set(value);
    Matrix<Real> m3(m1);
    KALDI_ASSERT(ApproxEqual(m2, m3));
  }
}

UnitTestCuMatrixSetMatMatDivMat()

static void kaldi::UnitTestCuMatrixSetMatMatDivMat ( )

static

Definition at line 1319 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatMatElements(), CuMatrixBase< Real >::ApplyFloor(), ApproxEqual(), CuMatrixBase< Real >::DivElements(), KALDI_ASSERT, Rand(), CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetZero().

                                                                      {
  // M = a * b / c (by element; when c = 0, M = a)
  MatrixIndexT dimM = 100 + Rand() % 255, dimN = 100 + Rand() % 255;
  CuMatrix<Real> M(dimM, dimN), A(dimM, dimN), B(dimM, dimN), C(dimM, dimN);
  CuMatrix<Real> ref(dimM, dimN);
  M.SetRandn();
  A.SetRandn();
  B.SetRandn();
  C.SetRandn();

  C.ApplyFloor(0.01);  // make sure there are no zeros.

  M.SetMatMatDivMat(A,B,C);
  ref.AddMatMatElements(1.0, A, B, 0.0);
  ref.DivElements(C);
  KALDI_ASSERT(ApproxEqual(M, ref));

  C.SetZero();
  M.SetMatMatDivMat(A,B,C);
  KALDI_ASSERT(ApproxEqual(M, A));
}

UnitTestCuMatrixSetRandn()

static void kaldi::UnitTestCuMatrixSetRandn ( )

static

Definition at line 2627 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::ApplyPow(), ApproxEqual(), DoubleFactorial(), rnnlm::i, KALDI_ASSERT, Rand(), MatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::Sum().

                                       {


  if (false) {
    // This block tests consistency when called twice.
    // It has been disabled since we added multi-threaded testing,
    // since consistency wouldn't be expected if other threads were running.
    int32 dimM = 100 + Rand() % 200, dimN = 100 + Rand() % 200;
    Matrix<Real> M(dimM, dimN), N(dimM, dimN);
    srand(104);
    M.SetRandn();
    srand(104);
    N.SetRandn();
    KALDI_ASSERT(ApproxEqual(M, N));
  }

  for (int32 i = 0; i < 5; i++) {
    MatrixIndexT rows = 100 + Rand() % 50, cols = 100 + Rand() % 50;
    CuMatrix<Real> M(rows, cols);
    M.SetRandn();

    for (int32 pow = 1; pow < 5; pow++) {
      // test moments 1 through 4 of
      // the distribution.
      CuMatrix<Real> Mpow(M);
      Mpow.ApplyPow(pow);
      Real observed_moment = Mpow.Sum() / (rows * cols);
      // see http://en.wikipedia.org/wiki/Normal_distribution#Moments,
      // note that mu = 0 and sigma = 1.
      Real expected_moment = (pow % 2 == 1 ? 0 : DoubleFactorial(pow - 1));
      Real expected_twice_moment = DoubleFactorial(2 * pow - 1);
      Real k = 10.0; // This is just a constant we use to give us some wiggle
                     // room before rejecting the distribution... e.g. 20 sigma,
                     // quite approximately.
      // VAR(X) = E(X^2) - (E(X))^2
      Real deviation = sqrt(expected_twice_moment - expected_moment * expected_moment);
      Real allowed_deviation = k * deviation / sqrt(static_cast<Real>(rows * cols));
      // give it a bit more wiggle room for higher powers.. this is quite
      // unscientific, it would be better to involve the absolute moments or
      // something like that, and use one of those statistical inequalities,
      // but it involves the gamma function and it's too much hassle to implement.
      Real lower_bound = expected_moment - allowed_deviation,
          upper_bound = expected_moment + allowed_deviation;
      KALDI_ASSERT(observed_moment >= lower_bound && observed_moment <= upper_bound);
    }
  }
}

UnitTestCuMatrixSetRandUniform()

static void kaldi::UnitTestCuMatrixSetRandUniform ( )

static

Definition at line 2677 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::Add(), CuMatrixBase< Real >::ApplyPow(), VectorBase< Real >::Dim(), rnnlm::i, KALDI_ERR, KALDI_LOG, Rand(), CuMatrixBase< Real >::SetRandUniform(), and CuMatrixBase< Real >::Sum().

                                             {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT rows = 180 + Rand() % 200, cols = 200 + Rand() % 200;
    CuMatrix<Real> M(rows, cols);
    M.SetRandUniform();

    M.Add(-0.5); // we'll be testing the central moments, so
    // center it around zero first.
    // Got these moments from http://mathworld.wolfram.com/UniformDistribution.html
    Vector<Real> central_moments(5);
    central_moments(0) = 0.0;
    central_moments(1) = 0.0;
    central_moments(2) = 1.0 / 12; // times (b - a)^2, which equals 1.
    central_moments(3) = 0.0;
    central_moments(4) = 1.0 / 80; // times (b - a)^4, which equals 1.

    for (int32 pow = 1; pow < central_moments.Dim(); pow++) {
      CuMatrix<Real> Mpow(M);
      Mpow.ApplyPow(pow);
      Real observed_moment = Mpow.Sum() / (rows * cols);
      // see http://en.wikipedia.org/wiki/Normal_distribution#Moments,
      // note that mu = 0 and sigma = 1.
      Real expected_moment = central_moments(pow);
      Real k = 20.0; // This is just a constant we use to give us some wiggle
                     // room before rejecting the distribution... e.g. 10 sigma,
                     // quite approximately.
      Real allowed_deviation = k / sqrt(static_cast<Real>(rows * cols));
      Real lower_bound = expected_moment - allowed_deviation,
          upper_bound = expected_moment + allowed_deviation;
      if (!(observed_moment >= lower_bound && observed_moment <= upper_bound)) {
        KALDI_LOG << "Random matrix is " << M;
        KALDI_ERR << "Bad observed " << pow <<  "'th moment " << observed_moment
                  << ", expected " << expected_moment << ", allowed range "
                  << lower_bound << " to " << upper_bound;
      }
    }
  }
}

UnitTestCuMatrixSetZeroAboveDiag()

static void kaldi::UnitTestCuMatrixSetZeroAboveDiag ( )

static

Definition at line 2738 of file cu-matrix-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), CuMatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetZeroAboveDiag().

                                               {
  for (int i = 1; i < 2; ++i) {
    MatrixIndexT dim = 10 * i + Rand() % 4 + (i == 9 ? 255 : 0);
    if (i == 8) dim = 0;
    CuMatrix<Real> A(dim, dim);
    A.SetRandn();
    Matrix<Real> A_orig(A);
    A.SetZeroAboveDiag();
    Matrix<Real> A_copy(A);

    for (int32 i = 0; i < dim;  i++) {
      for (int32 j = 0; j < dim; j++) {
        Real aval = A_copy(i, j), aorigval = A_orig(i, j);
        KALDI_ASSERT(aval == (j > i ? 0.0 : aorigval));
      }
    }
  }
}

UnitTestCuMatrixSigmoid()

static void kaldi::UnitTestCuMatrixSigmoid ( )

static

Definition at line 219 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::MulElements(), Rand(), MatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::Sigmoid(), and MatrixBase< Real >::Sigmoid().

                                      {
  for (int32 i = 0; i < 2; i++) {
    int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
    Matrix<Real> H(M, N);
    H.SetRandn();
    H.MulElements(H); // make numbers positive

    CuMatrix<Real> D(H);
    CuMatrix<Real> E(M, N);

    E.Sigmoid(D);
    H.Sigmoid(H);

    Matrix<Real> H2(E);

    KALDI_ASSERT(ApproxEqual(H, H2));
  }
}

UnitTestCuMatrixSoftHinge()

static void kaldi::UnitTestCuMatrixSoftHinge ( )

static

Definition at line 270 of file cu-matrix-test.cc.

References ApproxEqual(), KALDI_ASSERT, MatrixBase< Real >::MulElements(), Rand(), MatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::SoftHinge(), and MatrixBase< Real >::SoftHinge().

                                        {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  Matrix<Real> H(M, N);
  H.SetRandn();
  H.MulElements(H); // make numbers positive

  CuMatrix<Real> D(H);
  CuMatrix<Real> E(M, N);

  E.SoftHinge(D);
  H.SoftHinge(H);

  Matrix<Real> H2(E);

  KALDI_ASSERT(ApproxEqual(H,H2));
}

UnitTestCuMatrixSumColumnRanges()

static void kaldi::UnitTestCuMatrixSumColumnRanges ( )

static

Definition at line 673 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kUndefined, Rand(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SumColumnRanges().

                                              {
  for (int32 p = 0; p < 2; p++) {
    MatrixIndexT num_cols1 = 10 + Rand() % 10,
        num_cols2 = 10 + Rand() % 10,
        num_rows = 10 + Rand() % 10;
    Matrix<Real> src(num_rows, num_cols1);
    Matrix<Real> dst(num_rows, num_cols2);
    std::vector<Int32Pair> indices(num_cols2);
    for (int32 i = 0; i < num_cols2; i++) {
      indices[i].first = Rand() % num_cols1;
      int32 headroom = num_cols1 - indices[i].first,
        size = (Rand() % headroom) + 1;
      indices[i].second = indices[i].first + size;
      KALDI_ASSERT(indices[i].second >= indices[i].first &&
                   indices[i].second <= num_cols1 &&
                   indices[i].first >= 0);
      // In the test we allow second == first.
    }
    src.SetRandn();
    // Simple computation:
    for (MatrixIndexT i = 0; i < num_rows; i++) {
      for (MatrixIndexT j = 0; j < num_cols2; j++) {
        int32 start = indices[j].first, end = indices[j].second;
        Real sum = 0.0;
        for (MatrixIndexT j2 = start; j2 < end; j2++)
          sum += src(i, j2);
        dst(i, j) = sum;
      }
    }
    CuMatrix<Real> cu_src(src);
    CuMatrix<Real> cu_dst(num_rows, num_cols2, kUndefined);
    CuArray<Int32Pair> indices_tmp(indices);
    cu_dst.SumColumnRanges(cu_src, indices_tmp);
    Matrix<Real> dst2(cu_dst);
    KALDI_ASSERT(ApproxEqual(dst, dst2));
  }
}

UnitTestCuMatrixSymAddMat2()

static void kaldi::UnitTestCuMatrixSymAddMat2 ( )

static

Definition at line 1583 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatMat(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, Rand(), CuMatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::SymAddMat2(), and CuMatrix< Real >::Transpose().

                                         {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 10 + Rand() % 200, dimN = 10 + Rand() % 30;
    if (i == 8) {
      dimM = 0;
      dimN = 0;
    }
    CuMatrix<Real> M(dimM, dimM); // square matrix..
    CuMatrix<Real> N(dimM, dimN);
    M.SetRandn();
    N.SetRandn();
    MatrixTransposeType trans = (i % 2 == 0 ? kTrans : kNoTrans),
        other_trans = (trans == kTrans ? kNoTrans : kTrans);
    if (trans == kTrans) N.Transpose();
    CuMatrix<Real> M2(M);
    Real alpha = 0.3, beta = 1.75432;
    M.SymAddMat2(alpha, N, trans, beta);

    M2.AddMatMat(alpha, N, trans, N, other_trans, beta);

    CuTpMatrix<Real> T1(M), T2(M2);
    CuMatrix<Real> X1(T1), X2(T2); // so we can test equality.
    KALDI_ASSERT(ApproxEqual(X1, X2));
    KALDI_ASSERT(dimM == 0 || X1.Trace() != 0);
  }
}

UnitTestCuMatrixSymInvertPosDef()

static void kaldi::UnitTestCuMatrixSymInvertPosDef ( )

static

Definition at line 1613 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatMat(), ApproxEqual(), rnnlm::i, SpMatrix< Real >::Invert(), CuMatrixBase< Real >::IsUnit(), KALDI_ASSERT, kNoTrans, kTakeLower, kTrans, Rand(), CuMatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::SymAddMat2(), CuMatrixBase< Real >::SymInvertPosDef(), SpMatrix< Real >::Trace(), and CuMatrix< Real >::Transpose().

                                              {
  for (int32 i = 0; i < 2; i++) {
    int32 dimM = 10 + Rand() % 200, dimN = dimM + 20;
    // dimN > dimM, so will be PSD almost surely.
    if (i == 8) {
      dimM = 0;
      dimN = 0;
    }
    if (i == 0) {
      dimM = 2;
      dimN = 5;
    }
    if (i == 1) {
      dimM = 9;
      dimN = 20;
    }
    CuMatrix<Real> M(dimM, dimM); // square matrix..
    CuMatrix<Real> N(dimM, dimN);
    N.SetRandn();
    MatrixTransposeType trans = (i % 2 == 0 ? kTrans : kNoTrans);
    // MatrixTranposeType other_trans = (trans == kTrans ? kNoTrans : kTrans);

    if (trans == kTrans) N.Transpose();
    CuMatrix<Real> M2(M);
    Real alpha = 0.3, beta = 1.75432;
    M.SymAddMat2(alpha, N, trans, beta);
    // M.AddMatMat(alpha, N, trans, N, other_trans, beta);
    CuSpMatrix<Real> spTemp(M, kTakeLower);
    SpMatrix<Real> S(spTemp);
    S.Invert();
    CuSpMatrix<Real> spTemp2(M, kTakeLower);
    CuMatrix<Real> M_orig(spTemp2);
    M.SymInvertPosDef();
    CuSpMatrix<Real> spTemp3(M, kTakeLower);
    CuMatrix<Real> M_inverted(spTemp3);
    CuMatrix<Real> M_prod(dimM, dimM);
    M_prod.AddMatMat(Real(1.0), M_orig, kNoTrans, M_inverted, kNoTrans, Real(0.0));
    KALDI_ASSERT(M_prod.IsUnit());
    CuSpMatrix<Real> spTemp4(M, kTakeLower);
    SpMatrix<Real> S2(spTemp4);
    KALDI_ASSERT(ApproxEqual(S, S2, (Real)0.1));
    KALDI_ASSERT(dimM == 0 || S.Trace() != 0);
  }
}

UnitTestCuMatrixTraceMatMat()

static void kaldi::UnitTestCuMatrixTraceMatMat ( )

static

Definition at line 76 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::Add(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, Rand(), CuMatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::SetRandUniform(), MatrixBase< Real >::Sum(), CuMatrixBase< Real >::Sum(), and TraceMatMat().

                                          {
  for (int32 i = 0; i < 2; i++) {
    int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
    CuMatrix<Real> A(M, N);
    A.SetRandUniform();
    // Add bias to avoid numbers close to zero
    A.Add(0.1);
    if (i % 2 == 1) {
      CuMatrix<Real> B(M, N);
      B.SetRandn();
      // add a bias to avoid numerical failure when comparing r2 and r3
      B.Add(0.1);
      Real r1 = TraceMatMat(A, B, kTrans),
          r2 = TraceMatMat(Matrix<Real>(A), Matrix<Real>(B), kTrans),
          r3 = TraceMatMat(Matrix<Real>(A), Matrix<Real>(B, kTrans), kNoTrans);
      Matrix<Real> X(B, kTrans);
      KALDI_LOG << "Xsum = " << X.Sum();
      Matrix<Real> Y(B, kTrans);
      KALDI_LOG << "Ysum = " << Y.Sum();
      KALDI_LOG << "Bsum = " << B.Sum();
      KALDI_ASSERT(ApproxEqual(r1, r2));
      KALDI_ASSERT(ApproxEqual(r2, r3));
    } else {
      CuMatrix<Real> B(N, M);
      B.SetRandn();
      Real r1 = TraceMatMat(A, B, kNoTrans),
          r2 = TraceMatMat(Matrix<Real>(A), Matrix<Real>(B), kNoTrans),
          r3 = TraceMatMat(Matrix<Real>(A), Matrix<Real>(B, kTrans), kTrans);
      KALDI_ASSERT(ApproxEqual(r1, r2));
      KALDI_ASSERT(ApproxEqual(r2, r3));
    }
  }
}

UnitTestCuMatrixTranspose()

static void kaldi::UnitTestCuMatrixTranspose ( )

static

Definition at line 1873 of file cu-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, kTrans, Rand(), CuMatrixBase< Real >::SetRandn(), and Matrix< Real >::Transpose().

                                        {
  for (int32 i = 1; i < 2; i++) {
    MatrixIndexT dimM = 5 * i + Rand() % 10,
        dimN = dimM;
    if (i % 2 == 0) dimN += 5;

    CuMatrix<Real> A(dimM, dimN);
    A.SetRandn();
    CuMatrix<Real> B(A, kTrans);

    Matrix<Real> hA(A);
    Matrix<Real> hB(B);
    hB.Transpose();
    KALDI_ASSERT(ApproxEqual(hA, hB));
  }
}

UnitTestCuPackedMatrixAddToDiag()

static void kaldi::UnitTestCuPackedMatrixAddToDiag ( )

static

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

References CuPackedMatrix< Real >::AddToDiag(), AssertDiagEqual(), rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                              {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;
    
    PackedMatrix<Real> A(dim);
    A.SetRandn();
    CuPackedMatrix<Real> B(A);

    Real value = Rand() % 50;
    B.AddToDiag(value); 
    
    AssertDiagEqual(A, B, value);
  }
}

UnitTestCuPackedMatrixConstructor()

static void kaldi::UnitTestCuPackedMatrixConstructor ( )

static

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

References AssertEqual(), rnnlm::i, and PackedMatrix< Real >::SetRandn().

                                                { 
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;

    PackedMatrix<Real> A(dim);
    A.SetRandn();
    CuPackedMatrix<Real> B(A);
    CuPackedMatrix<Real> C(B);
    AssertEqual(B, C);
  }
}

UnitTestCuPackedMatrixCopy()

static void kaldi::UnitTestCuPackedMatrixCopy ( )

static

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

References AssertEqual(), CuPackedMatrix< Real >::CopyFromPacked(), CuPackedMatrix< Real >::CopyToPacked(), rnnlm::i, and PackedMatrix< Real >::SetRandn().

                                         { 
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;
    
    PackedMatrix<Real> A(dim);
    A.SetRandn();
    CuPackedMatrix<Real> B(A);

    CuPackedMatrix<Real> C(dim);
    C.CopyFromPacked(A);
    CuPackedMatrix<Real> D(dim);
    D.CopyFromPacked(B);
    AssertEqual(C, D);

    PackedMatrix<Real> E(dim);
    D.CopyToPacked(&E);
    AssertEqual(A, E);
  }
}

UnitTestCuPackedMatrixScale()

static void kaldi::UnitTestCuPackedMatrixScale ( )

static

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

References AssertEqual(), rnnlm::i, Rand(), CuPackedMatrix< Real >::Scale(), PackedMatrix< Real >::Scale(), and PackedMatrix< Real >::SetRandn().

                                          {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;
    
    PackedMatrix<Real> A(dim);
    A.SetRandn();
    CuPackedMatrix<Real> B(A);

    Real scale_factor = 23.5896223;
    A.Scale(scale_factor); 
    B.Scale(scale_factor);
    AssertEqual(A, B);
  }
}

UnitTestCuPackedMatrixScaleDiag()

static void kaldi::UnitTestCuPackedMatrixScaleDiag ( )

static

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

References AssertEqual(), rnnlm::i, Rand(), CuPackedMatrix< Real >::ScaleDiag(), PackedMatrix< Real >::ScaleDiag(), and PackedMatrix< Real >::SetRandn().

                                              {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;
    
    PackedMatrix<Real> A(dim);
    A.SetRandn();
    CuPackedMatrix<Real> B(A);

    Real scale_factor = 23.5896223;
    A.ScaleDiag(scale_factor); 
    B.ScaleDiag(scale_factor);
    AssertEqual(A, B);
  }
}

UnitTestCuPackedMatrixSetUnit()

static void kaldi::UnitTestCuPackedMatrixSetUnit ( )

static

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

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

                                            {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;
    
    CuPackedMatrix<Real> A(dim);
    A.SetUnit();
    
    for (MatrixIndexT i = 0; i < A.NumRows(); i++) {
      for (MatrixIndexT j = 0; j < A.NumRows(); j++) {
        if (i != j) { 
          KALDI_ASSERT(A(i, j) == 0);
        } else {
          KALDI_ASSERT(A(i, j) == 1.0);
        }
      }
    } 
  }
}

UnitTestCuPackedMatrixTrace()

static void kaldi::UnitTestCuPackedMatrixTrace ( )

static

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

References AssertEqual(), rnnlm::i, Rand(), PackedMatrix< Real >::SetRandn(), PackedMatrix< Real >::Trace(), and CuPackedMatrix< Real >::Trace().

                                          {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;
    
    PackedMatrix<Real> A(dim);
    A.SetRandn();
    CuPackedMatrix<Real> B(A);
    
    AssertEqual(A.Trace(), B.Trace());
  }
}

UnitTestCuSigmoid()

static void kaldi::UnitTestCuSigmoid ( )

static

Definition at line 2224 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::Sigmoid().

                                {
  Matrix<Real> Hi(100,111);
  Matrix<Real> Ho(100,111);
  Hi.SetRandn();

  CuMatrix<Real> Di(100,111);
  CuMatrix<Real> Do(100,111);
  Di.CopyFromMat(Hi);

  //gpu
  Do.Sigmoid(Di);
  //cpu
  for(MatrixIndexT r=0; r < Hi.NumRows(); r++) {
    for(MatrixIndexT c=0; c < Hi.NumCols(); c++) {
      Ho(r, c) = 1.0/(1.0+exp(-Hi(r, c)));
    }
  }

  Matrix<Real> Ho2(100,111);
  Do.CopyToMat(&Ho2);

  KALDI_ASSERT(ApproxEqual(Ho,Ho2));
}

UnitTestCuSoftmax()

static void kaldi::UnitTestCuSoftmax ( )

static

Definition at line 2370 of file cu-matrix-test.cc.

References ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Row(), MatrixBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SoftMaxPerRow().

                                {

  for (int32 i = 0; i < 4; i++) {
    int row = 10 + Rand() % 40;
    int col = 10 + Rand() % 50;

    Matrix<Real> Hi(row,col);
    Matrix<Real> Ho(row,col);
    Hi.SetRandn();
    Hi.Scale(5.0);

    CuMatrix<Real> Di(row, col);
    CuMatrix<Real> Do(row, col);
    Di.CopyFromMat(Hi);

    //gpu
    if (i % 2 == 0) {
      Do.SoftMaxPerRow(Di);
    } else {
      // in-place
      Do.CopyFromMat(Di);
      Do.SoftMaxPerRow(Do);
    }
    //cpu
    Ho.CopyFromMat(Hi);
    for(MatrixIndexT r=0; r<Ho.NumRows(); r++) {
      Ho.Row(r).ApplySoftMax();
    }

    Matrix<Real> Ho2(Do);

    KALDI_ASSERT(ApproxEqual(Ho,Ho2,(Real)0.00001));
  }
}

UnitTestCuSparseMatrixConstructFromIndexes()

static void kaldi::UnitTestCuSparseMatrixConstructFromIndexes ( )

static

Definition at line 34 of file cu-sparse-matrix-test.cc.

References AssertEqual(), CuSparseMatrix< Real >::CopyToMat(), SparseMatrix< Real >::CopyToMat(), rnnlm::i, kNoTrans, kTrans, CuSparseMatrix< Real >::NumCols(), SparseMatrix< Real >::NumCols(), CuSparseMatrix< Real >::NumRows(), SparseMatrix< Real >::NumRows(), and Rand().

                                                         {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    MatrixTransposeType trans = (i % 2 == 0 ? kNoTrans : kTrans);

    std::vector<int32> idx(row);
    Vector<Real> weights(row);
    for (int i = 0; i < row; ++i) {
      idx[i] = Rand() % col;
      weights(i) = Rand() % 100;
    }
    CuArray<int32> cuidx(idx);
    CuVector<Real> cuweights(weights);

    // construct smat
    SparseMatrix<Real> smat1(idx, col, trans);
    CuSparseMatrix<Real> cusmat1(cuidx, col, trans);

    // copy to mat
    Matrix<Real> mat1(smat1.NumRows(), smat1.NumCols());
    smat1.CopyToMat(&mat1);
    CuMatrix<Real> cumat1(cusmat1.NumRows(), cusmat1.NumCols());
    cusmat1.CopyToMat(&cumat1);

    // compare
    Matrix<Real> mat1ver2(cumat1);
    AssertEqual(mat1, mat1ver2, 0.00001);

    // construct smat with weights
    SparseMatrix<Real> smat2(idx, weights, col, trans);
    CuSparseMatrix<Real> cusmat2(cuidx, cuweights, col, trans);

    // copy to mat
    Matrix<Real> mat2(smat2.NumRows(), smat2.NumCols());
    smat2.CopyToMat(&mat2);
    CuMatrix<Real> cumat2(cusmat2.NumRows(), cusmat2.NumCols());
    cusmat2.CopyToMat(&cumat2);

    // compare
    Matrix<Real> mat2ver2(cumat2);
    AssertEqual(mat2, mat2ver2, 0.00001);
  }
}

UnitTestCuSparseMatrixCopyToSmat()

static void kaldi::UnitTestCuSparseMatrixCopyToSmat ( )

static

Definition at line 202 of file cu-sparse-matrix-test.cc.

References AssertEqual(), CuSparseMatrix< Real >::CopyToMat(), CuSparseMatrix< Real >::CopyToSmat(), rnnlm::i, Rand(), and SparseMatrix< Real >::SetRandn().

                                               {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    SparseMatrix<Real> smat1(row, col);
    smat1.SetRandn(0.8);
    CuSparseMatrix<Real> cu_smat1(smat1);

    SparseMatrix<Real> smat2(col, row);
    cu_smat1.CopyToSmat(&smat2);
    CuSparseMatrix<Real> cu_smat2(smat2);

    CuMatrix<Real> mat1(row, col);
    CuMatrix<Real> mat2(row, col);

    cu_smat1.CopyToMat(&mat1);
    cu_smat2.CopyToMat(&mat2);

    AssertEqual(mat1, mat2, 0.00001);
  }
}

UnitTestCuSparseMatrixFrobeniusNorm()

static void kaldi::UnitTestCuSparseMatrixFrobeniusNorm ( )

static

Definition at line 181 of file cu-sparse-matrix-test.cc.

References AssertEqual(), CuSparseMatrix< Real >::CopyToMat(), CuSparseMatrix< Real >::FrobeniusNorm(), CuMatrixBase< Real >::FrobeniusNorm(), rnnlm::i, Rand(), SparseMatrix< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                  {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    CuMatrix<Real> mat(row, col);
    mat.SetRandn();

    SparseMatrix<Real> smat(row, col);
    smat.SetRandn(0.8);
    CuSparseMatrix<Real> cu_smat(smat);

    cu_smat.CopyToMat(&mat);

    Real sum1 = cu_smat.FrobeniusNorm();
    Real sum2 = mat.FrobeniusNorm();
    AssertEqual(sum1, sum2, 0.00001);
  }
}

UnitTestCuSparseMatrixSelectRowsAndTranspose()

static void kaldi::UnitTestCuSparseMatrixSelectRowsAndTranspose ( )

static

Definition at line 82 of file cu-sparse-matrix-test.cc.

References AssertEqual(), CuSparseMatrix< Real >::CopyToMat(), rnnlm::i, kTrans, CuSparseMatrix< Real >::NumCols(), CuSparseMatrix< Real >::NumRows(), Rand(), CuSparseMatrix< Real >::SelectRows(), SparseMatrix< Real >::SelectRows(), and SparseMatrix< Real >::SetRandn().

                                                           {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    SparseMatrix<Real> sp_input(row, col);
    sp_input.SetRandn(0.8);
    CuSparseMatrix<Real> cusp_input(sp_input);

    std::vector<int32> idx(row + col);
    for (auto && e : idx) {
      e = Rand() % row;
    }
    CuArray<int32> cu_idx(idx);

    // select on cpu
    SparseMatrix<Real> sp_selected2;
    sp_selected2.SelectRows(idx, sp_input);
    // select on gpu
    CuSparseMatrix<Real> cusp_selected;
    cusp_selected.SelectRows(cu_idx, cusp_input);

    // transpose by CopyToMat
    CuSparseMatrix<Real> cusp_selected2(sp_selected2);
    CuMatrix<Real> cu_selected2_trans(cusp_selected2.NumCols(),
                                      cusp_selected2.NumRows());
    cusp_selected2.CopyToMat(&cu_selected2_trans, kTrans);
    // transpose by Constructor
    CuSparseMatrix<Real> cusp_selected_trans(cusp_selected, kTrans);
    CuMatrix<Real> cu_selected_trans(cusp_selected_trans.NumRows(),
                                     cusp_selected_trans.NumCols());
    cusp_selected_trans.CopyToMat(&cu_selected_trans);

    CuMatrix<Real> cu_selected(row+col, col);
    CuMatrix<Real> cu_selected2(row+col, col);
    cusp_selected.CopyToMat(&cu_selected);
    cusp_selected2.CopyToMat(&cu_selected2);

    AssertEqual(cu_selected, cu_selected2, 0.00001);
    AssertEqual(cu_selected_trans, cu_selected2_trans, 0.00001);
  }
}

UnitTestCuSparseMatrixSum()

static void kaldi::UnitTestCuSparseMatrixSum ( )

static

Definition at line 160 of file cu-sparse-matrix-test.cc.

References CuSparseMatrix< Real >::CopyToMat(), rnnlm::i, KALDI_ASSERT, Rand(), SparseMatrix< Real >::SetRandn(), CuMatrixBase< Real >::SetRandn(), CuSparseMatrix< Real >::Sum(), and CuMatrixBase< Real >::Sum().

                                        {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    CuMatrix<Real> mat(row, col);
    mat.SetRandn();

    SparseMatrix<Real> smat(row, col);
    smat.SetRandn(0.8);
    CuSparseMatrix<Real> cu_smat(smat);

    cu_smat.CopyToMat(&mat);

    Real sum1 = cu_smat.Sum();
    Real sum2 = mat.Sum();
    KALDI_ASSERT(fabs(sum1 - sum2) < 1.0e-04);
  }
}

UnitTestCuSparseMatrixSwap()

static void kaldi::UnitTestCuSparseMatrixSwap ( )

static

Definition at line 226 of file cu-sparse-matrix-test.cc.

References AssertEqual(), CuSparseMatrix< Real >::CopyToMat(), rnnlm::i, CuSparseMatrix< Real >::NumCols(), SparseMatrix< Real >::NumCols(), CuSparseMatrix< Real >::NumRows(), SparseMatrix< Real >::NumRows(), Rand(), CuMatrix< Real >::Resize(), SparseMatrix< Real >::SetRandn(), and CuSparseMatrix< Real >::Swap().

                                         {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    CuMatrix<Real> mat1, mat2, mat3, mat4;

    SparseMatrix<Real> smat1(row, col);
    smat1.SetRandn(0.8);
    SparseMatrix<Real> smat2 = smat1;
    mat2.Resize(smat2.NumRows(), smat2.NumCols());
    CuSparseMatrix<Real> tmp1(smat2);
    tmp1.CopyToMat(&mat2);

    SparseMatrix<Real> smat3(col, row);
    smat3.SetRandn(0.5);
    CuSparseMatrix<Real> cu_smat1(smat3);
    CuSparseMatrix<Real> cu_smat2 = cu_smat1;
    mat4.Resize(cu_smat2.NumRows(), cu_smat2.NumCols());
    cu_smat2.CopyToMat(&mat4);

    cu_smat1.Swap(&smat1);

    mat1.Resize(smat1.NumRows(), smat1.NumCols());
    mat3.Resize(cu_smat1.NumRows(), cu_smat1.NumCols());
    CuSparseMatrix<Real> tmp2(smat1);
    tmp2.CopyToMat(&mat1);
    cu_smat1.CopyToMat(&mat3);

    AssertEqual(mat3, mat2, 0.00001);
    AssertEqual(mat1, mat4, 0.00001);

    cu_smat2.Swap(&cu_smat1);

    mat1.Resize(cu_smat1.NumRows(), cu_smat1.NumCols());
    cu_smat1.CopyToMat(&mat1);
    mat2.Resize(cu_smat2.NumRows(), cu_smat2.NumCols());
    cu_smat2.CopyToMat(&mat2);

    AssertEqual(mat3, mat2, 0.00001);
    AssertEqual(mat1, mat4, 0.00001);
  }
}

UnitTestCuSparseMatrixTraceMatSmat()

static void kaldi::UnitTestCuSparseMatrixTraceMatSmat ( )

static

Definition at line 126 of file cu-sparse-matrix-test.cc.

References AssertEqual(), CuSparseMatrix< Real >::CopyToMat(), rnnlm::i, kNoTrans, kTrans, Rand(), SparseMatrix< Real >::SetRandn(), CuMatrixBase< Real >::SetRandn(), TraceMatMat(), and TraceMatSmat().

                                                 {
  for (int32 i = 0; i < 2; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    CuMatrix<Real> mat1(row, col);
    CuMatrix<Real> mat2(col, row);
    CuMatrix<Real> mat3(row, col);
    mat1.SetRandn();
    mat2.SetRandn();
    mat3.SetRandn();

    SparseMatrix<Real> smat1(row, col);
    SparseMatrix<Real> smat2(col, row);
    smat1.SetRandn(0.8);
    smat2.SetRandn(0.8);
    CuSparseMatrix<Real> cu_smat1x(smat1);
    CuSparseMatrix<Real> cu_smat1(cu_smat1x);  // Test constructor.
    CuSparseMatrix<Real> cu_smat2(smat2);

    cu_smat1.CopyToMat(&mat1);
    cu_smat2.CopyToMat(&mat2);

    Real trace1 = TraceMatMat(mat3, mat1, kTrans);
    Real trace2 = TraceMatSmat(mat3, cu_smat1, kTrans);
    AssertEqual(trace1, trace2, 0.00001);

    trace1 = TraceMatMat(mat3, mat2, kNoTrans);
    trace2 = TraceMatSmat(mat3, cu_smat2, kNoTrans);
    AssertEqual(trace1, trace2, 0.00001);
  }
}

UnitTestCuSpMatrixAddMat2()

static void kaldi::UnitTestCuSpMatrixAddMat2 ( )

static

Definition at line 206 of file cu-sp-matrix-test.cc.

References CuSpMatrix< Real >::AddMat2(), SpMatrix< Real >::AddMat2(), AssertEqual(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, kTrans, Rand(), PackedMatrix< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                        {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim_row = 15 * i + Rand() % 10;
    MatrixIndexT dim_col = 7 *i + Rand() % 10;
    Matrix<Real> A(dim_row, dim_col);
    A.SetRandn();
    CuMatrix<Real> B(A);

    SpMatrix<Real> C(dim_col);
    C.SetRandn();
    CuSpMatrix<Real> D(C);

    const Real alpha = 2.0;
    const Real beta = 3.0;

    C.AddMat2(alpha, A, kTrans, beta);
    D.AddMat2(alpha, B, kTrans, beta);

    SpMatrix<Real> E(dim_col);
    D.CopyToSp(&E);

    AssertEqual(C, E);
  }
}

UnitTestCuSpMatrixAddSp() [1/2]

static void kaldi::UnitTestCuSpMatrixAddSp ( )

static

Definition at line 232 of file cu-sp-matrix-test.cc.

References CuSpMatrix< Real >::AddSp(), SpMatrix< Real >::AddSp(), AssertEqual(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                      {
  for (MatrixIndexT i = 1; i < 50; i++) {
    MatrixIndexT dim = 7 * i + Rand() % 10;

    SpMatrix<Real> A(dim);
    A.SetRandn();
    CuSpMatrix<Real> B(A);

    SpMatrix<Real> C(dim);
    C.SetRandn();
    const CuSpMatrix<Real> D(C);

    const Real alpha = 2.0;

    A.AddSp(alpha, C);
    B.AddSp(alpha, D);

    SpMatrix<Real> E(dim);
    B.CopyToSp(&E);

    AssertEqual(A, E);
  }
}

UnitTestCuSpMatrixAddSp() [2/2]

static void kaldi::UnitTestCuSpMatrixAddSp ( )

static

Definition at line 323 of file cu-sp-matrix-test.cc.

References CuSpMatrix< Real >::AddSp(), SpMatrix< Real >::AddSp(), AssertEqual(), rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                      {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 100 * i + Rand() % 255;

    SpMatrix<Real> A(dim);
    A.SetRandn();
    const CuSpMatrix<Real> B(A);
    SpMatrix<OtherReal> C(dim);
    C.SetRandn();
    const CuSpMatrix<OtherReal> D(C);

    A.AddSp(1.0, C);
    B.AddSp(1.0, D);

    AssertEqual(A, B);

  }
}

UnitTestCuSpMatrixAddToDiag()

static void kaldi::UnitTestCuSpMatrixAddToDiag ( )

static

Definition at line 110 of file cu-sp-matrix-test.cc.

References CuPackedMatrix< Real >::AddToDiag(), PackedMatrix< Real >::AddToDiag(), AssertEqual(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, and PackedMatrix< Real >::SetRandn().

                                          {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 10*i;
    SpMatrix<Real> A(dim);
    A.SetRandn();
    CuSpMatrix<Real> B(A);

    Matrix<Real> D(A);
    A.AddToDiag(i);

    CuMatrix<Real> C(B);
    B.AddToDiag(i);

    SpMatrix<Real> E(dim);
    B.CopyToSp(&E);

    AssertEqual(A, E);
  }
}

UnitTestCuSpMatrixAddVec2()

static void kaldi::UnitTestCuSpMatrixAddVec2 ( )

static

Definition at line 183 of file cu-sp-matrix-test.cc.

References CuSpMatrix< Real >::AddVec2(), SpMatrix< Real >::AddVec2(), AssertEqual(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, Rand(), RandGauss(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                        {
  for (int32 i = 0; i < 50; i++) {
    MatrixIndexT dim = 1 + Rand() % 200;
    SpMatrix<Real> A(dim);
    A.SetRandn();
    CuSpMatrix<Real> B(A);

    Vector<Real> C(dim);
    C.SetRandn();
    CuVector<Real> D(C);
    Real alpha = RandGauss();

    A.AddVec2(alpha, C);
    B.AddVec2(alpha, D);

    SpMatrix<Real> E(dim);
    B.CopyToSp(&E);

    AssertEqual(A, E);
  }
}

UnitTestCuSpMatrixApproxEqual()

static void kaldi::UnitTestCuSpMatrixApproxEqual ( )

static

Definition at line 73 of file cu-sp-matrix-test.cc.

References SpMatrix< Real >::AddSp(), SpMatrix< Real >::FrobeniusNorm(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), and PackedMatrix< Real >::SetRandn().

                                            {

  for (int32 i = 0; i < 10; i++) {
    int32 dim = 1 + Rand() % 10;
    SpMatrix<Real> A(dim), B(dim);
    A.SetRandn();
    B.SetRandn();
    BaseFloat threshold = 0.01;
    for (int32 j = 0; j < 20; j++, threshold *= 1.3) {
      bool b1 = A.ApproxEqual(B, threshold);
      SpMatrix<Real> diff(A);
      diff.AddSp(-1.0, B);
      bool b2 = (diff.FrobeniusNorm() < threshold * std::max(A.FrobeniusNorm(),
                                                             B.FrobeniusNorm()));
      KALDI_ASSERT(b1 == b2);
    }
  }

}

UnitTestCuSpMatrixConstructor()

static void kaldi::UnitTestCuSpMatrixConstructor ( )

static

Definition at line 44 of file cu-sp-matrix-test.cc.

References AssertEqual(), CuSpMatrix< Real >::CopyToSp(), rnnlm::i, SpMatrix< Real >::IsUnit(), KALDI_ASSERT, kTakeLower, PackedMatrix< Real >::SetDiag(), MatrixBase< Real >::SetRandn(), and PackedMatrix< Real >::SetZero().

                                            {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;

    Matrix<Real> A(dim, dim);
    A.SetRandn();
    SpMatrix<Real> B(A, kTakeLower);

    CuMatrix<Real> C(A);
    CuSpMatrix<Real> D(C, kTakeLower);

    SpMatrix<Real> E(dim);
    D.CopyToSp(&E);

    SpMatrix<Real> F(D);

    AssertEqual(F, B);
     //added by hxu, to test copy from SpMatrix to CuSpMatrix

    AssertEqual(B, E);

    KALDI_ASSERT(!B.IsUnit());
    B.SetZero();
    B.SetDiag(1.0);
    KALDI_ASSERT(B.IsUnit());
  }
}

UnitTestCuSpMatrixCopyFromMat() [1/2]

static void kaldi::UnitTestCuSpMatrixCopyFromMat ( int32  dim, SpCopyType  copy_type  )

static

Definition at line 84 of file cu-sp-matrix-speed-test.cc.

References CuSpMatrix< Real >::CopyFromMat(), Timer::Elapsed(), KALDI_LOG, kTakeLower, and kTakeUpper.

                                                                           {
  BaseFloat time_in_secs = 0.01;
  int32 iter = 0;
  Timer tim;
  CuMatrix<Real> A(dim, dim);
  CuSpMatrix<Real> S(dim);

  for (;tim.Elapsed() < time_in_secs; iter++) {
    S.CopyFromMat(A, copy_type);
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuSpMatrix::CopyFromMat" << NameOf<Real>()
            << ", with copy-type "
            <<(copy_type == kTakeLower ? "kTakeLower" :
               (copy_type == kTakeUpper ? "kTakeUpper" :
                "kTakeMeanAndCheck")) << " and dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

UnitTestCuSpMatrixCopyFromMat() [2/2]

static void kaldi::UnitTestCuSpMatrixCopyFromMat ( )

static

Definition at line 132 of file cu-sp-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, kTakeLower, kTakeMean, kTakeUpper, Rand(), CuMatrixBase< Real >::SetRandn(), and SpMatrix< Real >::Trace().

                                            {
  for (MatrixIndexT i = 1; i < 10; i++) {
    SpCopyType copy_type = (i % 3 == 0 ? kTakeMean :
                            (i % 3 == 1 ? kTakeLower : kTakeUpper));
    MatrixIndexT dim = 10 * i + Rand() % 5;
    CuMatrix<Real> A(dim, dim);
    A.SetRandn();
    Matrix<Real> A2(A);

    CuSpMatrix<Real> B(A, copy_type);
    SpMatrix<Real> B2(A2, copy_type);
    SpMatrix<Real> B3(B);
    if (!ApproxEqual(B2, B3) ) {
      KALDI_ERR << "Matrices differ, A = " << A << ", B2 = " << B2 << ", B3(CUDA) = " << B3;
    }
    KALDI_ASSERT(B3.Trace() != 0);
  }
}

UnitTestCuSpMatrixInvert() [1/2]

static void kaldi::UnitTestCuSpMatrixInvert ( int32  dim )

static

Definition at line 43 of file cu-sp-matrix-speed-test.cc.

References CuSpMatrix< Real >::AddMat2(), CuPackedMatrix< Real >::AddToDiag(), AssertEqual(), CuSpMatrix< Real >::CopyToSp(), Timer::Elapsed(), CuSpMatrix< Real >::Invert(), KALDI_ASSERT, KALDI_LOG, kTrans, CuPackedMatrix< Real >::SetRandn(), and CuPackedMatrix< Real >::Trace().

                                                {
  BaseFloat time_in_secs = 0.01;
  int32 iter = 0;
  Timer tim;
  CuSpMatrix<Real> A(dim);
  A.SetRandn();
  for (;tim.Elapsed() < time_in_secs; iter++) {
    KALDI_ASSERT(A.Trace() != 0.0); // true with probability 1...
    CuSpMatrix<Real> B(A);

    if (iter  > 0) {
      B.Invert();
    } else { // do some more testing...

      CuMatrix<Real> D(A);
      A.AddMat2(1.0, D, kTrans, 1.0);
      A.AddToDiag(0.1 * dim);

      CuMatrix<Real> C(B);
      B.AddMat2(1.0, C, kTrans, 1.0);
      B.AddToDiag(0.1 * dim);

      A.Invert();
      B.Invert();

      SpMatrix<Real> E(dim);
      B.CopyToSp(&E);

      SpMatrix<Real> A2(A);
      AssertEqual(A2, E);
    }
  }
  BaseFloat fdim = dim;
  BaseFloat gflops = (fdim * fdim * fdim * iter) / (tim.Elapsed() * 1.0e+09);
  KALDI_LOG << "For CuSpMatrix::Invert" << NameOf<Real>() << ", for dim = "
            << dim << ", speed was " << gflops << " gigaflops.";
}

UnitTestCuSpMatrixInvert() [2/2]

static void kaldi::UnitTestCuSpMatrixInvert ( )

static

Definition at line 152 of file cu-sp-matrix-test.cc.

References CuSpMatrix< Real >::AddMat2(), SpMatrix< Real >::AddMat2(), CuMatrixBase< Real >::AddMatMat(), CuPackedMatrix< Real >::AddToDiag(), PackedMatrix< Real >::AddToDiag(), AssertEqual(), rnnlm::i, CuSpMatrix< Real >::Invert(), SpMatrix< Real >::Invert(), CuMatrixBase< Real >::IsUnit(), KALDI_ASSERT, kNoTrans, kTrans, Rand(), CuPackedMatrix< Real >::SetRandn(), and CuPackedMatrix< Real >::Trace().

                                       {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 10*i + Rand() % 5;
    CuSpMatrix<Real> A(dim);
    A.SetRandn();
    KALDI_ASSERT(A.Trace() != 0.0); // true with probability 1...
    SpMatrix<Real> B(A);

    CuMatrix<Real> D(A);
    A.AddMat2(1.0, D, kTrans, 1.0);
    A.AddToDiag(i);

    Matrix<Real> C(B);
    B.AddMat2(1.0, C, kTrans, 1.0);
    B.AddToDiag(i);

    CuSpMatrix<Real> Acopy(A);
    A.Invert();
    B.Invert();

    SpMatrix<Real> A2(A);
    AssertEqual(A2, B);

    CuMatrix<Real> I(dim, dim);
    I.AddMatMat(1.0, CuMatrix<Real>(Acopy), kNoTrans, CuMatrix<Real>(A), kNoTrans, 0.0);
    KALDI_ASSERT(I.IsUnit(0.01));
  }
}

UnitTestCuSpMatrixIO()

static void kaldi::UnitTestCuSpMatrixIO ( )

static

Definition at line 302 of file cu-sp-matrix-test.cc.

References AssertEqual(), rnnlm::i, Rand(), CuPackedMatrix< Real >::Read(), CuPackedMatrix< Real >::SetRandn(), and CuPackedMatrix< Real >::Write().

                                   {
  for (int32 i = 0; i < 10; i++) {
    int32 dimM = Rand() % 255;
    if (i % 5 == 0) { dimM = 0; }
    CuSpMatrix<Real> mat(dimM);
    mat.SetRandn();
    std::ostringstream os;
    bool binary = (i % 4 < 2);
    mat.Write(os, binary);

    CuSpMatrix<Real> mat2;
    std::istringstream is(os.str());
    mat2.Read(is, binary);
    AssertEqual(mat, mat2);
  }
}

UnitTestCuSpMatrixOperator()

static void kaldi::UnitTestCuSpMatrixOperator ( )

static

Definition at line 96 of file cu-sp-matrix-test.cc.

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

                                         {
  SpMatrix<Real> A(100);
  A.SetRandn();

  CuSpMatrix<Real> B(100);
  B.CopyFromSp(A);

  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)) < 0.0001);
  }
}

UnitTestCuSpMatrixSetUnit()

void kaldi::UnitTestCuSpMatrixSetUnit

(

)

Definition at line 275 of file cu-sp-matrix-test.cc.

References CuPackedMatrix< Real >::AddToDiag(), AssertEqual(), SpMatrix< Real >::FrobeniusNorm(), rnnlm::i, KALDI_LOG, Rand(), CuPackedMatrix< Real >::SetRandn(), PackedMatrix< Real >::SetUnit(), and CuPackedMatrix< Real >::SetZero().

                                 {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 100 * i + Rand() % 255;
    if (i % 5 == 0) dim = 0;
    CuSpMatrix<Real> S1(dim), S2(dim), S4(dim);
    S1.SetRandn();
    S2.SetRandn();
    S4.SetRandn();
    SpMatrix<Real> S3(dim);
    S3.SetUnit();
    S1.SetUnit();
    S2.SetZero();
    S2.SetDiag(1.0);
    S4.SetZero();
    S4.AddToDiag(0.4);
    S4.AddToDiag(0.6);
    CuSpMatrix<Real> cu_S3(S3);
    KALDI_LOG << "S1 norm is " << S1.FrobeniusNorm();
    KALDI_LOG << "S2 norm is " << S2.FrobeniusNorm();
    KALDI_LOG << "S3 norm is " << S3.FrobeniusNorm();
    AssertEqual(S1, cu_S3);
    AssertEqual(S2, cu_S3);
    AssertEqual(S4, cu_S3);
  }
}

UnitTestCuSpMatrixTraceSpSp()

static void kaldi::UnitTestCuSpMatrixTraceSpSp ( )

static

Definition at line 257 of file cu-sp-matrix-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, Rand(), PackedMatrix< Real >::SetRandn(), and TraceSpSp().

                                          {
  for (MatrixIndexT i = 1; i < 2; i++) {
    MatrixIndexT dim = 100 + Rand() % 255;

    SpMatrix<Real> A(dim);
    A.SetRandn();
    const CuSpMatrix<Real> B(A);
    SpMatrix<OtherReal> C(dim);
    C.SetRandn();
    const CuSpMatrix<OtherReal> D(C);

    Real t1 = TraceSpSp(A, C), t2 = TraceSpSp(B, D);
    KALDI_ASSERT(ApproxEqual(t1, t2));
  }
}

UnitTestCuSubMatrix()

static void kaldi::UnitTestCuSubMatrix ( )

static

Definition at line 2029 of file cu-matrix-test.cc.

References KALDI_ASSERT, rnnlm::n, Rand(), CuMatrixBase< Real >::Range(), and CuMatrixBase< Real >::SetRandn().

                                  {
  for (int32 iter = 0 ; iter < 10; iter++) {
    int32 M1 = 1 + rand () % 10, M2 = 1 + Rand() % 1, M3 = 1 + Rand() % 10, M = M1 + M2 + M3,
        N1 = 1 + rand () % 10, N2 = 1 + Rand() % 1, N3 = 1 + Rand() % 10, N = N1 + N2 + N3,
        m = Rand() % M2, n = Rand() % N2;
    CuMatrix<Real> mat(M, N);
    mat.SetRandn();
    CuSubMatrix<Real> submat1(mat, M1, M2,
                              N1, N2),
        submat2 = mat.Range(M1, M2, N1, N2);
    Real f1 = mat(M1 + m, N1 + n), f2 = submat1(m, n), f3 = submat2(m, n);
    KALDI_ASSERT(f1 == f2);
    KALDI_ASSERT(f2 == f3);
  }
}

UnitTestCuSubVector()

static void kaldi::UnitTestCuSubVector ( )

static

Definition at line 85 of file cu-vector-test.cc.

References KALDI_ASSERT, Rand(), CuVectorBase< Real >::Range(), and CuVectorBase< Real >::SetRandn().

                                  {
  for (int32 iter = 0 ; iter < 10; iter++) {
    int32 M1 = 1 + rand () % 10, M2 = 1 + Rand() % 1, M3 = 1 + Rand() % 10, M = M1 + M2 + M3,
        m = Rand() % M2;
    CuVector<Real> vec(M);
    vec.SetRandn();
    CuSubVector<Real> subvec1(vec, M1, M2),
        subvec2 = vec.Range(M1, M2);
    Real f1 = vec(M1 + m), f2 = subvec1(m), f3 = subvec2(m);
    KALDI_ASSERT(f1 == f2);
    KALDI_ASSERT(f2 == f3);
  }
}

UnitTestCuTanh()

void kaldi::UnitTestCuTanh

(

)

Definition at line 2574 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, MatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), CuMatrixBase< Real >::NumRows(), MatrixBase< Real >::SetRandn(), CuMatrixBase< Real >::Tanh(), and MatrixBase< Real >::Tanh().

                      {
  Matrix<Real> H(100,110);
  H.SetRandn();
  CuMatrix<Real> D(100,110);
  D.CopyFromMat(H);

  //gpu
  CuMatrix<Real> Di(100,110);
  Di.Tanh(D);
  Matrix<Real> Df(Di.NumRows(), Di.NumCols());
  Di.CopyToMat(&Df);

  //cpu
  Matrix<Real> Hf(H.NumRows(), H.NumCols());
  Hf.Tanh(H);
  KALDI_ASSERT(ApproxEqual(Df,Hf));
}

UnitTestCuTpMatrixCholesky()

static void kaldi::UnitTestCuTpMatrixCholesky ( )

static

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

References SpMatrix< Real >::AddMat2(), CuTpMatrix< Real >::Cholesky(), TpMatrix< Real >::Cholesky(), rnnlm::i, kNoTrans, Rand(), PackedMatrix< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                         {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 1 + Rand() % 10;
    if (i > 4) {
      dim += 32 * (Rand() % 5);
    }

    Matrix<Real> M(dim, dim + 2);
    M.SetRandn();
    SpMatrix<Real> A(dim);
    A.AddMat2(1.0, M, kNoTrans, 0.0); // sets A to random almost-surely +ve
                                      // definite matrix.
    CuSpMatrix<Real> B(A);

    TpMatrix<Real> C(dim);
    C.SetRandn();
    CuTpMatrix<Real> D(C);
    C.Cholesky(A);
    D.Cholesky(B);

    AssertEqual<Real>(C, D);
  }
}

UnitTestCuTpMatrixCopyFromMat()

static void kaldi::UnitTestCuTpMatrixCopyFromMat ( )

static

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

References AssertEqual(), CuTpMatrix< Real >::CopyFromMat(), TpMatrix< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, Rand(), CuMatrixBase< Real >::SetRandn(), and PackedMatrix< Real >::Trace().

                                            {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixTransposeType trans = (i % 2 == 0 ? kNoTrans : kTrans);

    MatrixIndexT dim = 10*i + Rand() % 5;
    CuMatrix<Real> A(dim, dim);
    A.SetRandn();
    Matrix<Real> A2(A);

    CuTpMatrix<Real> B(dim);
    B.CopyFromMat(A, trans);
    TpMatrix<Real> B2(dim);
    B2.CopyFromMat(A2, trans);
    TpMatrix<Real> B3(B);
    AssertEqual(B2, B3);
    KALDI_ASSERT(B3.Trace() != 0);
  }
}

UnitTestCuTpMatrixCopyFromTp()

static void kaldi::UnitTestCuTpMatrixCopyFromTp ( )

static

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

References CuTpMatrix< Real >::CopyFromTp(), rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                           {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;

    TpMatrix<Real> A(dim);
    A.SetRandn();
    CuTpMatrix<Real> B(dim);
    B.CopyFromTp(A);
    CuTpMatrix<Real> C(dim);
    C.CopyFromTp(B);

    AssertEqual<Real>(A, B);
    AssertEqual<Real>(B, C);
  }
}

UnitTestCuTpMatrixInvert()

static void kaldi::UnitTestCuTpMatrixInvert ( )

static

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

References rnnlm::i, Rand(), and PackedMatrix< Real >::SetRandn().

                                       {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 5 * i + Rand() % 10;

    TpMatrix<Real> A(dim);
    A.SetRandn();
    CuTpMatrix<Real> B(A);

    AssertEqual<Real>(A, B, 0.005);
    A.Invert();
    B.Invert();
    AssertEqual<Real>(A, B, 0.005);
  }
}

UnitTestCuTpMatrixIO()

static void kaldi::UnitTestCuTpMatrixIO ( )

static

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

References AssertEqual(), rnnlm::i, Rand(), CuPackedMatrix< Real >::Read(), CuPackedMatrix< Real >::SetRandn(), and CuPackedMatrix< Real >::Write().

                                   {
  for (int32 i = 0; i < 3; i++) {
    int32 dimM = Rand() % 255 + 10;
    if (i % 5 == 0) { dimM = 0; }
    CuTpMatrix<Real> mat(dimM);
    mat.SetRandn();
    std::ostringstream os;
    bool binary = (i % 4 < 2);
    mat.Write(os, binary);

    CuTpMatrix<Real> mat2;
    std::istringstream is(os.str());
    mat2.Read(is, binary);
    AssertEqual(mat, mat2);
  }
}

UnitTestCuVectorAddColSumMat()

static void kaldi::UnitTestCuVectorAddColSumMat ( )

static

Definition at line 2000 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddColSumMat(), VectorBase< Real >::AddColSumMat(), VectorBase< Real >::AddVec(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, VectorBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::SetZero().

                                           {
  const int32 X=19, Y=4321;
  Real alpha=0.5, beta=0.7;

  Matrix<Real> Hm(X,Y);
  Vector<Real> Hv(X);
  Vector<Real> Hv_accu(X);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(X,Y);
  CuVector<Real> Dv(X);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dv.AddColSumMat(alpha,Dm,beta);

  Hv_accu.SetZero();
  Hv_accu.AddColSumMat(1.0, Hm);
  Hv.Scale(beta);
  Hv.AddVec(alpha, Hv_accu);

  Vector<Real> Hv2(X);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorAddColSumMatLarge()

static void kaldi::UnitTestCuVectorAddColSumMatLarge ( )

static

Definition at line 2048 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddColSumMat(), VectorBase< Real >::AddColSumMat(), VectorBase< Real >::AddVec(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, VectorBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::SetZero().

                                                {
  Matrix<Real> Hm(1000,990);
  Vector<Real> Hv(1000);
  Vector<Real> Hv_accu(1000);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(1000,990);
  CuVector<Real> Dv(1000);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dv.AddColSumMat(0.5, Dm, 0.7);

  Hv_accu.SetZero();
  Hv_accu.AddColSumMat(1.0, Hm);
  Hv.Scale(0.7);
  Hv.AddVec(0.5,Hv_accu);

  Vector<Real> Hv2(1000);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorAddRowSumMat()

static void kaldi::UnitTestCuVectorAddRowSumMat ( )

static

Definition at line 1941 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddRowSumMat(), VectorBase< Real >::AddRowSumMat(), VectorBase< Real >::AddVec(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, VectorBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::SetZero().

                                           {
 const int32 X=4321, Y=19;
  Real alpha=0.1, beta=0.7;

  Matrix<Real> Hm(X,Y);
  Vector<Real> Hv(Y);
  Vector<Real> Hv_accu(Y);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(X,Y);
  CuVector<Real> Dv(Y);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dv.AddRowSumMat(alpha,Dm,beta);

  Hv_accu.SetZero();
  Hv_accu.AddRowSumMat(1.0, Hm);
  Hv.Scale(beta);
  Hv.AddVec(alpha,Hv_accu);

  Vector<Real> Hv2(Y);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorAddRowSumMatLarge()

static void kaldi::UnitTestCuVectorAddRowSumMatLarge ( )

static

Definition at line 1972 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddRowSumMat(), VectorBase< Real >::AddRowSumMat(), VectorBase< Real >::AddVec(), ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, VectorBase< Real >::Scale(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::SetZero().

                                                {
  Matrix<Real> Hm(1000,990);
  Vector<Real> Hv(990);
  Vector<Real> Hv_accu(990);
  Hm.SetRandn();
  InitRand(&Hv);

  CuMatrix<Real> Dm(1000,990);
  CuVector<Real> Dv(990);
  Dm.CopyFromMat(Hm);
  Dv.CopyFromVec(Hv);

  Dv.AddRowSumMat(0.5,Dm,0.7);

  Hv_accu.SetZero();
  Hv_accu.AddRowSumMat(1.0, Hm);
  Hv.Scale(0.7);
  Hv.AddVec(0.5,Hv_accu);

  Vector<Real> Hv2(990);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorAddTp()

static void kaldi::UnitTestCuVectorAddTp ( )

static

Definition at line 122 of file cu-vector-test.cc.

References CuVectorBase< Real >::AddTpVec(), VectorBase< Real >::AddTpVec(), AssertEqual(), rnnlm::i, kNoTrans, VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                    {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;
    Vector<Real> A(dim);
    A.SetRandn();
    TpMatrix<Real> B(dim);
    B.SetRandn();
    Vector<Real> C(dim);
    C.SetRandn();

    CuVector<Real> D(A);
    CuTpMatrix<Real> E(B);
    CuVector<Real> F(C);

    A.AddTpVec(1.0, B, kNoTrans, C, 1.0);
    D.AddTpVec(1.0, E, kNoTrans, F, 1.0);

    CuVector<Real> G(A);
    AssertEqual(D, G);
  }
}

UnitTestCuVectorAddTpVec()

static void kaldi::UnitTestCuVectorAddTpVec ( )

static

Definition at line 2131 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddTpVec(), VectorBase< Real >::AddTpVec(), ApproxEqual(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, kNoTrans, and PackedMatrix< Real >::SetRandn().

                                       {
  Vector<Real> Hv(300);
  InitRand(&Hv);
  CuVector<Real> Dv(300);
  Dv.CopyFromVec(Hv);
  Vector<Real> Hv1(300);
  InitRand(&Hv1);
  CuVector<Real> Dv1(300);
  Dv1.CopyFromVec(Hv1);

  TpMatrix<Real> Hm(300);
  Hm.SetRandn();
  CuTpMatrix<Real> Dm(Hm);

  //gpu
  Dv.AddTpVec(1.0,Dm,kNoTrans,Dv1,1.0);
  //cpu
  Hv.AddTpVec(1.0,Hm,kNoTrans,Hv1,1.0);

  Vector<Real> Hv2(300);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorAddVec()

static void kaldi::UnitTestCuVectorAddVec ( )

static

Definition at line 1917 of file cu-matrix-test.cc.

References CuVectorBase< Real >::AddVec(), VectorBase< Real >::AddVec(), ApproxEqual(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, and VectorBase< Real >::Scale().

                                     {
  Vector<Real> Hv(777);
  Vector<Real> Hw(777);
  InitRand(&Hv);
  InitRand(&Hw);

  CuVector<Real> Dv(777);
  CuVector<Real> Dw(777);
  Dv.CopyFromVec(Hv);
  Dw.CopyFromVec(Hw);

  Dv.AddVec(0.1,Dw,0.9);
  Hv.Scale(0.9);
  Hv.AddVec(0.1,Hw);

  Vector<Real> Hv2(777);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorCopyFromVec()

static void kaldi::UnitTestCuVectorCopyFromVec ( )

static

Definition at line 67 of file cu-vector-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyFromVec(), VectorBase< Real >::CopyFromVec(), rnnlm::i, and VectorBase< Real >::SetRandn().

                                          {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;
    Vector<Real> A(dim);
    A.SetRandn();
    CuVector<OtherReal> B(A);
    Vector<Real> C(B);
    CuVector<Real> D(dim);
    D.CopyFromVec(C);
    Vector<OtherReal> E(dim);
    E.CopyFromVec(D);
    CuVector<Real> F(E);
    CuVector<Real> A2(A);
    AssertEqual(F, A2);
  }
}

UnitTestCuVectorInvertElements()

static void kaldi::UnitTestCuVectorInvertElements ( )

static

Definition at line 2076 of file cu-matrix-test.cc.

References ApproxEqual(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), CuVectorBase< Real >::InvertElements(), VectorBase< Real >::InvertElements(), and KALDI_ASSERT.

                                             {
  Vector<Real> Hv(777);
  InitRand(&Hv);

  CuVector<Real> Dv(777);
  Dv.CopyFromVec(Hv);

  Dv.InvertElements();
  Hv.InvertElements();

  Vector<Real> Hv2(777);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorIO()

static void kaldi::UnitTestCuVectorIO ( )

static

Definition at line 48 of file cu-vector-test.cc.

References AssertEqual(), rnnlm::i, Rand(), CuVector< Real >::Read(), CuVectorBase< Real >::SetRandn(), and CuVector< Real >::Write().

                                 {
  for (int32 i = 0; i < 10; i++) {
    int32 dimM = Rand() % 255;
    if (i % 5 == 0) { dimM = 0; }
    CuVector<Real> vec(dimM);
    vec.SetRandn();
    std::ostringstream os;
    bool binary = (i % 4 < 2);
    vec.Write(os, binary);

    CuVector<Real> vec2;
    std::istringstream is(os.str());
    vec2.Read(is, binary);
    AssertEqual(vec, vec2);
  }
}

UnitTestCuVectorMulTp() [1/2]

static void kaldi::UnitTestCuVectorMulTp ( )

static

Definition at line 102 of file cu-vector-test.cc.

References AssertEqual(), rnnlm::i, kNoTrans, CuVectorBase< Real >::MulTp(), VectorBase< Real >::MulTp(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                    {
  for (int32 i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;
    Vector<Real> A(dim);
    A.SetRandn();
    TpMatrix<Real> B(dim);
    B.SetRandn();

    CuVector<Real> C(A);
    CuTpMatrix<Real> D(B);

    A.MulTp(B, kNoTrans);
    C.MulTp(D, kNoTrans);

    CuVector<Real> E(A);
    AssertEqual(C, E);
  }
}

UnitTestCuVectorMulTp() [2/2]

static void kaldi::UnitTestCuVectorMulTp ( )

static

Definition at line 2173 of file cu-matrix-test.cc.

References ApproxEqual(), CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::CopyToVec(), InitRand(), KALDI_ASSERT, kNoTrans, CuVectorBase< Real >::MulTp(), VectorBase< Real >::MulTp(), and PackedMatrix< Real >::SetRandn().

                                    {
  Vector<Real> Hv(300);
  InitRand(&Hv);
  CuVector<Real> Dv(300);
  Dv.CopyFromVec(Hv);

  TpMatrix<Real> Hm(300);
  Hm.SetRandn();
  CuTpMatrix<Real> Dm(Hm);

  //gpu
  Dv.MulTp(Dm,kNoTrans);
  //cpu
  Hv.MulTp(Hm,kNoTrans);

  Vector<Real> Hv2(300);
  Dv.CopyToVec(&Hv2);

  KALDI_ASSERT(ApproxEqual(Hv,Hv2));
}

UnitTestCuVectorReplaceValue()

static void kaldi::UnitTestCuVectorReplaceValue ( )

static

Definition at line 298 of file cu-vector-test.cc.

References AssertEqual(), rnnlm::i, Rand(), CuVectorBase< Real >::ReplaceValue(), VectorBase< Real >::ReplaceValue(), and VectorBase< Real >::SetRandn().

                                                                   {
  for (int32 i = 0; i < 5; i++) {
    int32 dim = 100 + Rand() % 200;
    Real orig = 0.1 * (Rand() % 100), changed = 0.1 * (Rand() % 50);
    Vector<Real> vec(dim);
    vec.SetRandn();
    vec(dim / 2) = orig;
    CuVector<Real> vec1(vec);
    vec.ReplaceValue(orig, changed);
    vec1.ReplaceValue(orig, changed);
    Vector<Real> vec2(vec1);
    AssertEqual(vec, vec2);
  }
}

UnitTestCuVectorSum()

static void kaldi::UnitTestCuVectorSum ( )

static

Definition at line 313 of file cu-vector-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, RandInt(), and VectorBase< Real >::Range().

                                                          {
  for (int32 i = 0; i < 200; i++) {
    int32 start_dim = RandInt(1, 500), end_dim = RandInt(1, 500);
    int32 dim = RandInt(10, 12000) + start_dim + end_dim;
    Real quiet_nan = nan("");  // this is from <cmath>.
    Vector<BaseFloat> vec(start_dim + dim + end_dim);
    vec.Range(0, start_dim).Set(quiet_nan);
    vec.Range(start_dim, dim).Set(1.0);
    vec.Range(start_dim + dim, end_dim).Set(quiet_nan);
    BaseFloat sum = vec.Range(start_dim, dim).Sum();
    KALDI_ASSERT(ApproxEqual(sum, dim));
  }
}

UnitTestDct()

static void kaldi::UnitTestDct ( )

static

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

References MatrixBase< Real >::AddMatMat(), ComputeDctMatrix(), rnnlm::i, MatrixBase< Real >::IsUnit(), KALDI_ASSERT, kNoTrans, kTrans, and Rand().

                                                  {

  // Check that DCT matrix is orthogonal (i.e. M^T M = I);
  for (MatrixIndexT i = 0; i < 10; i++) {
    MatrixIndexT N = 1 + Rand() % 10;
    Matrix<Real> M(N, N);
    ComputeDctMatrix(&M);
    Matrix<Real> I(N, N);
    I.AddMatMat(1.0, M, kTrans, M, kNoTrans, 0.0);
    KALDI_ASSERT(I.IsUnit());
  }

}

UnitTestDefines()

void kaldi::UnitTestDefines

(

)

Definition at line 190 of file kaldi-math-test.cc.

References DBL_EPSILON, Exp(), FLT_EPSILON, KALDI_ASSERT, KALDI_ISFINITE, KALDI_ISINF, KALDI_ISNAN, kLogZeroDouble, kLogZeroFloat, M_2PI, M_LOG_2PI, and M_PI.

Referenced by main().

                       {  // Yes, we even unit-test the preprocessor statements.
  KALDI_ASSERT(Exp(kLogZeroFloat) == 0.0);
  KALDI_ASSERT(Exp(kLogZeroDouble) == 0.0);
  BaseFloat den = 0.0;
  KALDI_ASSERT(KALDI_ISNAN(0.0 / den));
  KALDI_ASSERT(!KALDI_ISINF(0.0 / den));
  KALDI_ASSERT(!KALDI_ISFINITE(0.0 / den));
  KALDI_ASSERT(!KALDI_ISNAN(1.0 / den));
  KALDI_ASSERT(KALDI_ISINF(1.0 / den));
  KALDI_ASSERT(!KALDI_ISFINITE(1.0 / den));
  KALDI_ASSERT(KALDI_ISFINITE(0.0));
  KALDI_ASSERT(!KALDI_ISINF(0.0));
  KALDI_ASSERT(!KALDI_ISNAN(0.0));

  std::cout << 1.0+DBL_EPSILON;
  std::cout << 1.0 + 0.5*DBL_EPSILON;
  KALDI_ASSERT(1.0 + DBL_EPSILON != 1.0 && 1.0 + (0.5*DBL_EPSILON) == 1.0
               && "If this test fails, you can probably just comment it out-- "
               "may mean your CPU exceeds expected floating point precision");
  KALDI_ASSERT(1.0f + FLT_EPSILON != 1.0f && 1.0f + (0.5f*FLT_EPSILON) == 1.0f
               && "If this test fails, you can probably just comment it out-- "
               "may mean your CPU exceeds expected floating point precision");
  KALDI_ASSERT(std::abs(sin(M_PI)) < 1.0e-05
               && std::abs(cos(M_PI)+1.0) < 1.0e-05);
  KALDI_ASSERT(std::abs(sin(M_2PI)) < 1.0e-05
               && std::abs(cos(M_2PI)-1.0) < 1.0e-05);
  KALDI_ASSERT(std::abs(sin(Exp(M_LOG_2PI))) < 1.0e-05);
  KALDI_ASSERT(std::abs(cos(Exp(M_LOG_2PI)) - 1.0) < 1.0e-05);
}

UnitTestDelay()

static void kaldi::UnitTestDelay ( )

static

Definition at line 219 of file pitch-functions-test.cc.

References OnlinePitchFeature::AcceptWaveform(), ApproxEqual(), ProcessPitchOptions::delay, ProcessPitchOptions::delta_pitch_noise_stddev, VectorBase< Real >::Dim(), OnlineProcessPitch::Dim(), OnlineProcessPitch::GetFrame(), rnnlm::i, OnlinePitchFeature::InputFinished(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, M_2PI, rnnlm::n, PitchExtractionOptions::nccf_ballast_online, MatrixBase< Real >::NumCols(), OnlineProcessPitch::NumFramesReady(), pitch_use_naive_search, RandGauss(), Matrix< Real >::Resize(), and PitchExtractionOptions::samp_freq.

Referenced by UnitTestFeatNoKeele().

                            {
  KALDI_LOG << "=== UnitTestDelay() ===\n";
  for (int32 n = 0; n < 10; n++) {
    // the parametrization object
    PitchExtractionOptions ext_opt;
    ProcessPitchOptions pro_opt1, pro_opt2;
    pro_opt1.delta_pitch_noise_stddev = 0.0;  // to avoid mismatch of delta_log_pitch
                                              // brought by rand noise.
    pro_opt2.delta_pitch_noise_stddev = 0.0;  // to avoid mismatch of delta_log_pitch
                                              // brought by rand noise.
    pro_opt2.delay = rand() % 50;
    ext_opt.nccf_ballast_online = true;  // this is necessary for the computation
    // to be identical regardless how many pieces we break the signal into.

    int32 size = 1000 + rand() % 5000;

    Vector<BaseFloat> v(size);
    // init with noise plus a sine-wave whose frequency is changing randomly.

    double cur_freq = 200.0, normalized_time = 0.0;

    for (int32 i = 0; i < size; i++) {
      v(i) = RandGauss() + cos(normalized_time * M_2PI);
      cur_freq += RandGauss();  // let the frequency wander a little.
      if (cur_freq < 100.0) cur_freq = 100.0;
      if (cur_freq > 300.0) cur_freq = 300.0;
      normalized_time += cur_freq / ext_opt.samp_freq;
    }

    Matrix<BaseFloat> m1, m2;
    // compute it online with multiple pieces.
    OnlinePitchFeature pitch_extractor(ext_opt);
    OnlineProcessPitch pitch_processor(pro_opt1, &pitch_extractor);
    OnlineProcessPitch pitch_processor_delayed(pro_opt2, &pitch_extractor);
    int32 start_samp = 0;
    while (start_samp < v.Dim()) {
      int32 num_samp = rand() % (v.Dim() + 1 - start_samp);
      SubVector<BaseFloat> v_part(v, start_samp, num_samp);
      pitch_extractor.AcceptWaveform(ext_opt.samp_freq, v_part);
      start_samp += num_samp;
    }
    pitch_extractor.InputFinished();

    int32 num_frames = pitch_processor.NumFramesReady();
    m1.Resize(num_frames, pitch_processor.Dim());
    for (int32 frame = 0; frame < num_frames; frame++) {
      SubVector<BaseFloat> rowp(m1, frame);
      pitch_processor.GetFrame(frame, &rowp);
    }

    int32 num_frames_delayed = pitch_processor_delayed.NumFramesReady();
    m2.Resize(num_frames_delayed, pitch_processor_delayed.Dim());
    for (int32 frame = 0; frame < num_frames_delayed; frame++) {
      SubVector<BaseFloat> rowp(m2, frame);
      pitch_processor_delayed.GetFrame(frame, &rowp);
    }

    KALDI_ASSERT(num_frames_delayed == num_frames + pro_opt2.delay);
    SubMatrix<BaseFloat> m3(m2, pro_opt2.delay, num_frames, 0, m2.NumCols());
    if (!ApproxEqual(m1, m3)) {
      KALDI_ERR << "Post-processed pitch differs: " << m1 << " vs. " << m3;
    }
    KALDI_LOG << "Test passed :)\n";
  }
}

UnitTestDeterminant()

static void kaldi::UnitTestDeterminant ( )

static

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

References MatrixBase< Real >::AddMat(), MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::CopyFromMat(), rnnlm::i, InitRandNonsingular(), MatrixBase< Real >::IsZero(), KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, SpMatrix< Real >::LogDet(), MatrixBase< Real >::LogDet(), SpMatrix< Real >::LogPosDefDet(), Rand(), MatrixBase< Real >::SetZero(), TraceMatMat(), and TraceSpSp().

                                                          {  // also tests matrix axpy and IsZero() and TraceOfProduct{, T}
  for (MatrixIndexT iter = 0;iter < 5;iter++) {  // First test the 2 det routines are the same
    int dimM = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimM), N(dimM, dimM);
    InitRandNonsingular(&M);
    N.AddMatMat(1.0, M, kNoTrans, M, kTrans, 0.0);  // N:=M*M^T.
    for (MatrixIndexT i = 0;i < (MatrixIndexT)dimM;i++) N(i, i) += 0.0001;  // Make sure numerically +ve det-- can by chance be almost singular the way we initialized it (I think)
    SpMatrix<Real> S(dimM);
    S.CopyFromMat(N);  // symmetric so should not crash.
    Real logdet = S.LogPosDefDet();
    Real logdet2, logdet3, sign2, sign3;
    logdet2 = N.LogDet(&sign2);
    logdet3 = S.LogDet(&sign3);
    KALDI_ASSERT(sign2 == 1.0 && sign3 == 1.0 && std::abs(logdet2-logdet) < 0.1 && std::abs(logdet2 - logdet3) < 0.1);
    Matrix<Real> tmp(dimM, dimM); tmp.SetZero();
    tmp.AddMat(1.0, N);
    tmp.AddMat(-1.0, N, kTrans);
    // symmetric so tmp should be zero.
    if ( ! tmp.IsZero(1.0e-04)) {
      printf("KALDI_ERR: matrix is not zero\n");
      KALDI_LOG << tmp;
      KALDI_ASSERT(0);
    }

    Real a = TraceSpSp(S, S), b = TraceMatMat(N, N), c = TraceMatMat(N, N, kTrans);
    KALDI_ASSERT(std::abs(a-b) < 0.1 && std::abs(b-c) < 0.1);
  }
}

UnitTestDeterminantSign()

static void kaldi::UnitTestDeterminantSign ( )

static

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

References MatrixBase< Real >::AddMatMat(), AssertEqual(), SpMatrix< Real >::CopyFromMat(), rnnlm::i, InitRandNonsingular(), KALDI_ASSERT, kNoTrans, kTrans, Log(), SpMatrix< Real >::LogDet(), MatrixBase< Real >::LogDet(), SpMatrix< Real >::LogPosDefDet(), Rand(), MatrixBase< Real >::Row(), PackedMatrix< Real >::Scale(), MatrixBase< Real >::Scale(), and MatrixBase< Real >::Svd().

                                                              {

  for (MatrixIndexT iter = 0;iter < 20;iter++) {  // First test the 2 det routines are the same
    int dimM = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimM), N(dimM, dimM);
    InitRandNonsingular(&M);
    N.AddMatMat(1.0, M, kNoTrans, M, kTrans, 0.0);  // N:=M*M^T.
    for (MatrixIndexT i = 0;i < (MatrixIndexT)dimM;i++) N(i, i) += 0.0001;  // Make sure numerically +ve det-- can by chance be almost singular the way we initialized it (I think)
    SpMatrix<Real> S(dimM);
    S.CopyFromMat(N);  // symmetric so should not crash.
    Real logdet = S.LogPosDefDet();
    Real logdet2, logdet3, sign2, sign3;
    logdet2 = N.LogDet(&sign2);
    logdet3 = S.LogDet(&sign3);
    KALDI_ASSERT(sign2 == 1.0 && sign3 == 1.0 && std::abs(logdet2-logdet) < 0.01 && std::abs(logdet2 - logdet3) < 0.01);

    MatrixIndexT num_sign_changes = Rand() % 5;
    for (MatrixIndexT change = 0; change < num_sign_changes; change++) {
      // Change sign of S's det by flipping one eigenvalue, and N by flipping one row.
      {
        Matrix<Real> M(S);
        Matrix<Real> U(dimM, dimM), Vt(dimM, dimM);
        Vector<Real> s(dimM);
        M.Svd(&s, &U, &Vt);  // SVD: M = U diag(s) Vt
        s(Rand() % dimM) *= -1;
        U.MulColsVec(s);
        M.AddMatMat(1.0, U, kNoTrans, Vt, kNoTrans, 0.0);
        S.CopyFromMat(M);
      }
      // change sign of N:
      N.Row(Rand() % dimM).Scale(-1.0);
    }

    // add in a scaling factor too.
    Real tmp = 1.0 + ((Rand() % 5) * 0.01);
    Real logdet_factor = dimM * Log(tmp);
    N.Scale(tmp);
    S.Scale(tmp);

    Real logdet4, logdet5, sign4, sign5;
    logdet4 = N.LogDet(&sign4);
    logdet5 = S.LogDet(&sign5);
    AssertEqual(logdet4, logdet+logdet_factor, 0.01);
    AssertEqual(logdet5, logdet+logdet_factor, 0.01);
    if (num_sign_changes % 2 == 0) {
      KALDI_ASSERT(sign4 == 1);
      KALDI_ASSERT(sign5 == 1);
    } else {
      KALDI_ASSERT(sign4 == -1);
      KALDI_ASSERT(sign5 == -1);
    }
  }
}

UnitTestDiagGmm()

void kaldi::UnitTestDiagGmm

(

)

Definition at line 86 of file diag-gmm-test.cc.

References AssertEqual(), DiagGmm::ComponentPosteriors(), DiagGmm::ComputeGconsts(), DiagGmm::CopyFromDiagGmm(), MatrixBase< Real >::CopyFromMat(), VectorBase< Real >::CopyFromVec(), rnnlm::d, DiagGmm::Dim(), Exp(), DiagGmm::GetComponentMean(), DiagGmm::GetMeans(), DiagGmm::GetVars(), rnnlm::i, MatrixBase< Real >::InvertElements(), Log(), DiagGmm::LogLikelihood(), DiagGmm::LogLikelihoods(), DiagGmm::LogLikelihoodsPreselect(), VectorBase< Real >::LogSumExp(), M_LOG_2PI, DiagGmm::Merge(), DiagGmm::MergeKmeans(), DiagGmm::NumGauss(), RandGauss(), RandInt(), RandUniform(), DiagGmm::Read(), DiagGmm::Resize(), DiagGmm::SetInvVars(), DiagGmm::SetInvVarsAndMeans(), DiagGmm::SetMeans(), DiagGmm::SetWeights(), MatrixBase< Real >::SetZero(), DiagGmm::Split(), Input::Stream(), VectorBase< Real >::Sum(), DiagGmm::weights(), and DiagGmm::Write().

Referenced by main().

                       {
  // random dimension of the gmm
  size_t dim = 1 + kaldi::RandInt(0, 5);
  // random number of mixtures
  size_t nMix = 1 + kaldi::RandInt(0, 5);

  std::cout << "Testing NumGauss: " << nMix << ", " << "Dim: " << dim
    << '\n';

  // generate random feature vector and
  // random mean and variance vectors
  Vector<BaseFloat> feat(dim), weights(nMix), loglikes(nMix);
  Matrix<BaseFloat> means(nMix, dim), vars(nMix, dim), invvars(nMix, dim);

  float loglike = 0.0;
  for (size_t d = 0; d < dim; d++) {
    feat(d) = kaldi::RandGauss();
  }

  float tot_weight = 0.0;
  for (size_t m = 0; m < nMix; m++) {
    weights(m) = kaldi::RandUniform();
    for (size_t d= 0; d < dim; d++) {
      means(m, d) = kaldi::RandGauss();
      vars(m, d) = Exp(kaldi::RandGauss()) + 1e-5;
    }
    tot_weight += weights(m);
  }

  // normalize weights
  for (size_t m = 0; m < nMix; m++) {
    weights(m) /= tot_weight;
    for (size_t d= 0; d < dim; d++) {
      loglikes(m) += -0.5 * (M_LOG_2PI + Log(vars(m, d)) + (feat(d) -
          means(m, d)) * (feat(d) - means(m, d)) / vars(m, d));
    }
    loglikes(m) += Log(weights(m));
  }

  loglike = loglikes.LogSumExp();

  // new GMM
  DiagGmm *gmm = new DiagGmm();
  gmm->Resize(nMix, dim);
  invvars.CopyFromMat(vars);
  invvars.InvertElements();
  gmm->SetWeights(weights);
  gmm->SetInvVarsAndMeans(invvars, means);
  gmm->ComputeGconsts();

  Vector<BaseFloat> posterior1(nMix);
  float loglike1 = gmm->ComponentPosteriors(feat, &posterior1);

  std::cout << "LogLike: " << loglike << '\n';
  std::cout << "LogLike1: " << loglike1 << '\n';
  AssertEqual(loglike, loglike1, 0.01);

  AssertEqual(1.0, posterior1.Sum(), 0.01);

  {  // Test various accessors / mutators
    Vector<BaseFloat> weights_bak(nMix);
    Matrix<BaseFloat> means_bak(nMix, dim);
    Matrix<BaseFloat> invvars_bak(nMix, dim);

    weights_bak.CopyFromVec(gmm->weights());
    gmm->GetMeans(&means_bak);
    gmm->GetVars(&invvars_bak);   // get vars
    invvars_bak.InvertElements();  // compute invvars

    // set all params one-by-one to new model
    DiagGmm gmm2;
    gmm2.Resize(gmm->NumGauss(), gmm->Dim());
    gmm2.SetWeights(weights_bak);
    gmm2.SetMeans(means_bak);
    gmm2.SetInvVars(invvars_bak);
    gmm2.ComputeGconsts();
    BaseFloat loglike_gmm2 = gmm2.LogLikelihood(feat);
    AssertEqual(loglike1, loglike_gmm2);
    {
      Vector<BaseFloat> loglikes;
      gmm2.LogLikelihoods(feat, &loglikes);
      AssertEqual(loglikes.LogSumExp(), loglike_gmm2);
    }
    {
      std::vector<int32> indices;
      for (int32 i = 0; i < gmm2.NumGauss(); i++)
        indices.push_back(i);
      Vector<BaseFloat> loglikes;
      gmm2.LogLikelihoodsPreselect(feat, indices, &loglikes);
      AssertEqual(loglikes.LogSumExp(), loglike_gmm2);
    }

    // single component mean accessor + mutator
    DiagGmm gmm3;
    gmm3.Resize(gmm->NumGauss(), gmm->Dim());
    gmm3.SetWeights(weights_bak);
    means_bak.SetZero();
    for (size_t i = 0; i < nMix; i++) {
      SubVector<BaseFloat> row(means_bak, i);
      gmm->GetComponentMean(i, &row);
      gmm3.SetComponentMean(i, row);
    }
    gmm3.SetInvVars(invvars_bak);
    gmm3.ComputeGconsts();
    BaseFloat loglike_gmm3 = gmm3.LogLikelihood(feat);
    AssertEqual(loglike1, loglike_gmm3, 0.01);
  }  // Test various accessors / mutators end


  // First, non-binary write.
  gmm->Write(Output("tmpf", false).Stream(), false);

  delete gmm;

  {
    bool binary_in;
    DiagGmm *gmm2 = new DiagGmm();
    Input ki("tmpf", &binary_in);
    gmm2->Read(ki.Stream(), binary_in);

    float loglike4 = gmm2->ComponentPosteriors(feat, &posterior1);
    AssertEqual(loglike, loglike4, 0.01);

    // binary write
    gmm2->Write(Output("tmpfb", true).Stream(), true);
    delete gmm2;

    // binary read
    DiagGmm *gmm3;
    gmm3 = new DiagGmm();
    Input ki2("tmpfb", &binary_in);
    gmm3->Read(ki2.Stream(), binary_in);

    float loglike5 = gmm3->ComponentPosteriors(feat, &posterior1);
    AssertEqual(loglike, loglike5, 0.01);
    delete gmm3;
  }

  {  // split and merge test for 1 component GMM (doesn't test the merge crit.)
    DiagGmm gmm1;
    Vector<BaseFloat> weights1(1);
    Matrix<BaseFloat> means1(1, dim), vars1(1, dim), invvars1(1, dim);
    weights1(0) = 1.0;
    means1.CopyFromMat(means.Range(0, 1, 0, dim));
    vars1.CopyFromMat(vars.Range(0, 1, 0, dim));
    invvars1.CopyFromMat(vars1);
    invvars1.InvertElements();
    gmm1.Resize(1, dim);
    gmm1.SetWeights(weights1);
    gmm1.SetInvVarsAndMeans(invvars1, means1);
    gmm1.ComputeGconsts();
    DiagGmm gmm2;
    gmm2.CopyFromDiagGmm(gmm1);
    gmm2.Split(2, 0.001);
    gmm2.Merge(1);
    float loglike1 = gmm1.LogLikelihood(feat);
    float loglike2 = gmm2.LogLikelihood(feat);
    AssertEqual(loglike1, loglike2, 0.01);
  }


  {  // split and merge test for 1 component GMM, this time using K-means algorithm.
    DiagGmm gmm1;
    Vector<BaseFloat> weights1(1);
    Matrix<BaseFloat> means1(1, dim), vars1(1, dim), invvars1(1, dim);
    weights1(0) = 1.0;
    means1.CopyFromMat(means.Range(0, 1, 0, dim));
    vars1.CopyFromMat(vars.Range(0, 1, 0, dim));
    invvars1.CopyFromMat(vars1);
    invvars1.InvertElements();
    gmm1.Resize(1, dim);
    gmm1.SetWeights(weights1);
    gmm1.SetInvVarsAndMeans(invvars1, means1);
    gmm1.ComputeGconsts();
    DiagGmm gmm2;
    gmm2.CopyFromDiagGmm(gmm1);
    gmm2.Split(2, 0.001);
    gmm2.MergeKmeans(1);
    float loglike1 = gmm1.LogLikelihood(feat);
    float loglike2 = gmm2.LogLikelihood(feat);
    AssertEqual(loglike1, loglike2, 0.01);
  }

    {  // Duplicate Gaussians using initializer that takes a vector, and
      // check like is unchanged.
    DiagGmm gmm1;
    Vector<BaseFloat> weights1(1);
    Matrix<BaseFloat> means1(1, dim), vars1(1, dim), invvars1(1, dim);
    weights1(0) = 1.0;
    means1.CopyFromMat(means.Range(0, 1, 0, dim));
    vars1.CopyFromMat(vars.Range(0, 1, 0, dim));
    invvars1.CopyFromMat(vars1);
    invvars1.InvertElements();
    gmm1.Resize(1, dim);
    gmm1.SetWeights(weights1);
    gmm1.SetInvVarsAndMeans(invvars1, means1);
    gmm1.ComputeGconsts();

    std::vector<std::pair<BaseFloat, const DiagGmm*> > vec;
    vec.push_back(std::make_pair(static_cast<BaseFloat>(0.4), (const DiagGmm*)(&gmm1)));
    vec.push_back(std::make_pair(static_cast<BaseFloat>(0.6), (const DiagGmm*)(&gmm1)));

    DiagGmm gmm2(vec);

    float loglike1 = gmm1.LogLikelihood(feat);
    float loglike2 = gmm2.LogLikelihood(feat);
    AssertEqual(loglike1, loglike2, 0.01);
  }

  unlink("tmpf");
  unlink("tmpfb");
}

UnitTestDiagGmmGenerate()

void kaldi::UnitTestDiagGmmGenerate

(

)

Definition at line 54 of file diag-gmm-test.cc.

References AccumDiagGmm::AccumulateFromDiag(), AssertEqual(), count, DiagGmm::Dim(), DiagGmm::Generate(), rnnlm::i, InitRandomGmm(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kGmmAll, MleDiagGmmUpdate(), and DiagGmm::NumGauss().

Referenced by main().

                               {
  DiagGmm gmm;
  InitRandomGmm(&gmm);
  int32 dim =  gmm.Dim();
  int32 npoints = 100 * gmm.NumGauss();
  Matrix<BaseFloat> rand_points(npoints, dim);
  for (int32 i = 0; i < npoints; i++) {
    SubVector<BaseFloat> row(rand_points, i);
    gmm.Generate(&row);
  }
  int32 niters = 15;
  BaseFloat objf_change_tot = 0.0, objf_change, count;
  for (int32 j = 0; j < niters; j++) {
    MleDiagGmmOptions opts;
    AccumDiagGmm stats(gmm, kGmmAll);  // all update flags.
    for (int32 i = 0; i < npoints; i++) {
      SubVector<BaseFloat> row(rand_points, i);
      stats.AccumulateFromDiag(gmm, row, 1.0);
    }
    MleDiagGmmUpdate(opts, stats, kGmmAll, &gmm, &objf_change, &count);
    objf_change_tot += objf_change;
  }
  AssertEqual(count, npoints, 1e-6);
  int32 num_params = gmm.NumGauss() * (gmm.Dim()*2 + 1);
  BaseFloat expected_objf_change = 0.5 * num_params;
  KALDI_LOG << "Expected objf change is: not much more than "
            << expected_objf_change <<", seen: " << objf_change_tot;
  KALDI_ASSERT(objf_change_tot < 2.0 * expected_objf_change);  // way too much.
  // This test relies on statistical laws and if it fails it does not
  // *necessarily* mean that something is wrong.
}

UnitTestDiffSampleRate()

void kaldi::UnitTestDiffSampleRate

(

)

Definition at line 528 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::lowpass_cutoff, PitchExtractionOptions::max_f0, WaveData::Read(), and PitchExtractionOptions::samp_freq.

Referenced by UnitTestFeatWithKeele().

                              {
  // you need to use sox to change sampling rate
  // e.g. sox -r 10k input.wav output.wav
  // put them in keele/(samp_rate in kHz)+"kHz" e.g. keele/10kHz
  int sample_rate = 16000;
  PitchExtractionOptions op;
  op.samp_freq = static_cast<double>(sample_rate);
  op.lowpass_cutoff = 1000;
  op.max_f0 = 400;
  std::string samp_rate = ConvertIntToString(sample_rate/1000);
  for (int32 i = 1; i < 11; i++) {
    std::string wavefile;
    std::string num;
    if (i < 6) {
      num = "f"+ConvertIntToString(i)+"nw0000";
      wavefile = "keele/"+samp_rate+"kHz/"+num+".wav";
    } else {
      num = "m"+ConvertIntToString(i-5)+"nw0000";
      wavefile = "keele/"+samp_rate+"kHz/"+num+".wav";
    }
    KALDI_LOG << "--- " << wavefile << " ---";
    std::ifstream is(wavefile.c_str(), std::ios_base::binary);
    WaveData wave;
    wave.Read(is);
    KALDI_ASSERT(wave.Data().NumRows() == 1);
    SubVector<BaseFloat> waveform(wave.Data(), 0);
    Matrix<BaseFloat> m;
    ComputeKaldiPitch(op, waveform, &m);
    std::string outfile = "keele/tmp/+"+num+"-kaldi-samp-freq-"+samp_rate+"kHz.txt";
    std::ofstream os(outfile.c_str());
    m.Write(os, false);
  }
}

UnitTestDivideRoundingDown()

void kaldi::UnitTestDivideRoundingDown

(

)

Definition at line 60 of file kaldi-math-test.cc.

References DivideRoundingDown(), rnnlm::i, KALDI_ASSERT, and RandInt().

Referenced by main().

                                  {
  for (int32 i = 0; i < 100; i++) {
    int32 a = RandInt(-100, 100);
    int32 b = 0;
    while (b == 0)
      b = RandInt(-100, 100);
    KALDI_ASSERT(DivideRoundingDown(a, b) ==
        std::floor(static_cast<double>(a) / static_cast<double>(b)));
  }
}

UnitTestDotprod()

static void kaldi::UnitTestDotprod ( )

static

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

References rnnlm::i, KALDI_ASSERT, Rand(), VectorBase< Real >::SetRandn(), and VecVec().

                                                      {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 200 + Rand()%100;
    Vector<Real> v(dimM), w(dimM);

    v.SetRandn();
    w.SetRandn();
    Vector<double> wd(w);

    Real f = VecVec(w, v), f2 = VecVec(wd, v), f3 = VecVec(v, wd);
    Real sum = 0.0;
    for (MatrixIndexT i = 0;i < dimM;i++) sum += v(i)*w(i);
    KALDI_ASSERT(std::abs(f-sum) < 0.001);
    KALDI_ASSERT(std::abs(f2-sum) < 0.001);
    KALDI_ASSERT(std::abs(f3-sum) < 0.001);
  }
}

UnitTestEig()

static void kaldi::UnitTestEig ( )

static

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

References MatrixBase< Real >::AddMatMat(), AssertEqual(), CreateEigenvalueMatrix(), MatrixBase< Real >::Eig(), rnnlm::i, InitRandNonsingular(), MatrixBase< Real >::Invert(), kNoTrans, Log(), and MatrixBase< Real >::LogDet().

                                                  {

  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 1 + iter;
    /*    if (iter < 10)
          dimM = 1 + Rand() % 6;
          else
          dimM = 5 + Rand()%10; */
    Matrix<Real> M(dimM, dimM);
    InitRandNonsingular(&M);
    Matrix<Real> P(dimM, dimM);
    Vector<Real> real_eigs(dimM), imag_eigs(dimM);
    M.Eig(&P, &real_eigs, &imag_eigs);

    {  // Check that the eigenvalues match up with the determinant.
      BaseFloat logdet_check = 0.0, logdet = M.LogDet();
      for (MatrixIndexT i = 0; i < dimM ; i++)
        logdet_check += 0.5 * Log(real_eigs(i)*real_eigs(i) + imag_eigs(i)*imag_eigs(i));
      AssertEqual(logdet_check, logdet);
    }
    Matrix<Real> Pinv(P);
    Pinv.Invert();
    Matrix<Real> D(dimM, dimM);
    CreateEigenvalueMatrix(real_eigs, imag_eigs, &D);

    // check that M = P D P^{-1}.
    Matrix<Real> tmp(dimM, dimM);
    tmp.AddMatMat(1.0, P, kNoTrans, D, kNoTrans, 0.0);  // tmp = P * D
    Matrix<Real> M2(dimM, dimM);
    M2.AddMatMat(1.0, tmp, kNoTrans, Pinv, kNoTrans, 0.0);  // M2 = tmp * Pinv = P * D * Pinv.

    {  // print out some stuff..
      Matrix<Real> MP(dimM, dimM);
      MP.AddMatMat(1.0, M, kNoTrans, P, kNoTrans, 0.0);
      Matrix<Real> PD(dimM, dimM);
      PD.AddMatMat(1.0, P, kNoTrans, D, kNoTrans, 0.0);

      Matrix<Real> PinvMP(dimM, dimM);
      PinvMP.AddMatMat(1.0, Pinv, kNoTrans, MP, kNoTrans, 0.0);
      AssertEqual(MP, PD);
    }

    AssertEqual(M, M2);  // check reconstruction worked.
  }
}

UnitTestEigSp()

static void kaldi::UnitTestEigSp ( )

static

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

References SpMatrix< Real >::AddMat2Vec(), SpMatrix< Real >::AddSp(), SpMatrix< Real >::ApproxEqual(), VectorBase< Real >::Data(), SpMatrix< Real >::Eig(), rnnlm::i, InitRandNonsingular(), KALDI_ASSERT, KALDI_LOG, kNoTrans, and Rand().

                                                    {
  // Test the Eig function with SpMatrix.
  // We make sure to test pathological cases, that have
  // either large zero eigenspaces, or two large
  // eigenspaces with the same absolute value but +ve
  // and -ve.  Also zero matrix.

  for (MatrixIndexT iter = 0; iter < 100; iter++) {
    MatrixIndexT dimM = 1 + (Rand() % 10);
    SpMatrix<Real> S(dimM);

    switch (iter % 5) {
      case 0: // zero matrix.
        break;
      case 1: // general random symmetric matrix.
        InitRandNonsingular(&S);
        break;
      default:
        { // start with a random matrix; do decomposition; change the eigenvalues to
          // try to cover the problematic cases; reconstruct.
          InitRandNonsingular(&S);
          Vector<Real> s(dimM); Matrix<Real> P(dimM, dimM);
          S.Eig(&s, &P);
          // We on purpose create a problematic case where
          // some eigs are either zero or share a value (+ve or -ve)
          // with some other eigenvalue.
          for (MatrixIndexT i = 0; i < dimM; i++) {
            if (Rand() % 10 == 0) s(i) = 0; // set that eig to zero.
            else if (Rand() % 10 < 2) {
              // set that eig to some other randomly chosen eig,
              // times random sign.
              s(i) = (Rand()%2 == 0 ? 1 : -1) * s(Rand() % dimM);
            }
          }
          // Reconstruct s from the eigenvalues "made problematic."
          S.AddMat2Vec(1.0, P, kNoTrans, s, 0.0);
          Real *data = s.Data();
          std::sort(data, data+dimM);
          KALDI_LOG << "Real eigs are: " << s;

        }
    }
    Vector<Real> s(dimM); Matrix<Real> P(dimM, dimM);
    S.Eig(&s, &P);
    KALDI_LOG << "Found eigs are: " << s;
    SpMatrix<Real> S2(dimM);
    S2.AddMat2Vec(1.0, P, kNoTrans, s, 0.0);
    {
      SpMatrix<Real> diff(S);
      diff.AddSp(-1.0, S2);
      Vector<Real> s(dimM); Matrix<Real> P(dimM, dimM);
      diff.Eig(&s, &P);
      KALDI_LOG << "Eigs of difference are " << s;
    }
    KALDI_ASSERT(S.ApproxEqual(S2, 1.0e-03f));
  }
}

UnitTestEigSymmetric()

static void kaldi::UnitTestEigSymmetric ( )

static

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

References MatrixBase< Real >::AddMatMat(), AssertEqual(), MatrixBase< Real >::Eig(), KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::MulColsVec(), Rand(), PackedMatrix< Real >::SetRandn(), and VectorBase< Real >::Sum().

                                                           {

  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 20 + Rand()%10;
    SpMatrix<Real> S(dimM);
    S.SetRandn();
    Matrix<Real> M(S);  // copy to regular matrix.
    Matrix<Real> P(dimM, dimM);
    Vector<Real> real_eigs(dimM), imag_eigs(dimM);
    M.Eig(&P, &real_eigs, &imag_eigs);
    KALDI_ASSERT(imag_eigs.Sum() == 0.0);
    // should have M = P D P^T
    Matrix<Real> tmp(P); tmp.MulColsVec(real_eigs);  // P * eigs
    Matrix<Real> M2(dimM, dimM);
    M2.AddMatMat(1.0, tmp, kNoTrans, P, kTrans, 0.0);  // M2 = tmp * Pinv = P * eigs * P^T
    AssertEqual(M, M2);  // check reconstruction worked.
  }
}

UnitTestEnsureNonzero()

static void kaldi::UnitTestEnsureNonzero ( )

static

Definition at line 73 of file cu-math-test.cc.

References kaldi::cu::EnsureNonzero(), rnnlm::i, KALDI_ASSERT, kUndefined, Rand(), RandInt(), and CuMatrixBase< Real >::SetRandn().

                                    {
  int32 M = 100 + Rand() % 200, N = 100 + Rand() % 200;
  Real epsilon = 0.1;
  CuMatrix<Real> x(M, N);
  x.SetRandn();
  CuMatrix<Real> y(M, N, kUndefined);
  cu::EnsureNonzero(x, epsilon, &y);
  Matrix<Real> x_cpu(x);
  Matrix<Real> y_cpu(y);
  for (int32 i = 0; i < 30; i++) {
    int32 r = RandInt(0, M-1), c = RandInt(0, N-1);
    Real src = x_cpu(r, c), dest = y_cpu(r, c);
    if (src <= -epsilon || src >= epsilon) {
      KALDI_ASSERT(src == dest);
    } else if (src >= 0) {
      KALDI_ASSERT(dest == epsilon);
    } else {
      KALDI_ASSERT(dest == -epsilon);
    }
  }
}

UnitTestError()

void kaldi::UnitTestError

(

)

Definition at line 29 of file kaldi-error-test.cc.

References MyFunction1().

Referenced by main().

                     {
  {
    std::cerr << "Ignore next error:\n";
    MyFunction1();
  }
}

UnitTestEstimateMmieDiagGmm()

void kaldi::UnitTestEstimateMmieDiagGmm

(

)

Definition at line 30 of file ebw-diag-gmm-test.cc.

References AccumDiagGmm::AccumulateFromDiag(), VectorBase< Real >::AddVec(), VectorBase< Real >::AddVec2(), VectorBase< Real >::ApplyPow(), DiagGmm::ComputeGconsts(), MatrixBase< Real >::CopyFromMat(), VectorBase< Real >::CopyRowFromMat(), count, rnnlm::d, DiagGmm::Dim(), Exp(), GmmFlagsToString(), rnnlm::i, MatrixBase< Real >::InvertElements(), IsmoothStatsDiagGmm(), KALDI_LOG, KALDI_WARN, kGmmMeans, kGmmVariances, kGmmWeights, DiagGmm::NumGauss(), Rand(), RandGauss(), RandInt(), DiagGmm::Resize(), AccumDiagGmm::Resize(), VectorBase< Real >::Scale(), DiagGmm::SetInvVarsAndMeans(), DiagGmm::SetWeights(), AccumDiagGmm::SetZero(), DiagGmm::Split(), UpdateEbwDiagGmm(), UpdateEbwWeightsDiagGmm(), and DiagGmm::weights().

Referenced by main().

                                   {
  size_t dim = RandInt(5, 10);  // dimension of the gmm
  size_t nMix = 2;  // number of mixtures in the data
  size_t maxiterations = RandInt(2, 5);  // number of iterations for estimation

  // maximum number of densities in the GMM
  // larger than the number of mixtures in the data
  // so that we can test the removal of unseen components
  int32 maxcomponents = 10;

  // generate random feature vectors
  Matrix<BaseFloat> means_f(nMix, dim), vars_f(nMix, dim);
  // first, generate random mean and variance vectors
  for (size_t m = 0; m < nMix; m++) {
    for (size_t d= 0; d < dim; d++) {
      means_f(m, d) = kaldi::RandGauss()*100.0F;
      vars_f(m, d) = Exp(kaldi::RandGauss())*1000.0F+ 1.0F;
    }
    // std::cout << "Gauss " << m << ": Mean = " << means_f.Row(m) << '\n'
    //          << "Vars = " << vars_f.Row(m) << '\n';
  }

  // Numerator stats
  // second, generate 1000 feature vectors for each of the mixture components
  size_t counter_num = 0, multiple = 200;
  Matrix<BaseFloat> feats_num(nMix*multiple, dim);
  for (size_t m = 0; m < nMix; m++) {
    for (size_t i = 0; i < multiple; i++) {
      for (size_t d = 0; d < dim; d++) {
        feats_num(counter_num, d) = means_f(m, d) + kaldi::RandGauss() *
            std::sqrt(vars_f(m, d));
      }
      counter_num++;
    }
  }

  // Denominator stats
  // second, generate 1000 feature vectors for each of the mixture components
  size_t counter_den = 0;
  Matrix<BaseFloat> feats_den(nMix*multiple, dim);
  for (size_t m = 0; m < nMix; m++) {
    for (size_t i = 0; i < multiple; i++) {
      for (size_t d = 0; d < dim; d++) {
        feats_den(counter_den, d) = means_f(m, d) + kaldi::RandGauss() *
            std::sqrt(vars_f(m, d));
      }
      counter_den++;
    }
  }

  // Compute the global mean and variance
  Vector<BaseFloat> mean_acc(dim);
  Vector<BaseFloat> var_acc(dim);
  Vector<BaseFloat> featvec(dim);
  for (size_t i = 0; i < counter_num; i++) {
    featvec.CopyRowFromMat(feats_num, i);
    mean_acc.AddVec(1.0, featvec);
    featvec.ApplyPow(2.0);
    var_acc.AddVec(1.0, featvec);
  }
  mean_acc.Scale(1.0F/counter_num);
  var_acc.Scale(1.0F/counter_num);
  var_acc.AddVec2(-1.0, mean_acc);
  // std::cout << "Mean acc = " << mean_acc << '\n' << "Var acc = "
  //         << var_acc << '\n';

  // write the feature vectors to a file
  std::ofstream of("tmpfeats");
  of.precision(10);
  of << feats_num;
  of.close();

  // now generate randomly initial values for the GMM
  Vector<BaseFloat> weights(1);
  Matrix<BaseFloat> means(1, dim), vars(1, dim), invvars(1, dim);
  for (size_t d= 0; d < dim; d++) {
    means(0, d) = kaldi::RandGauss()*100.0F;
    vars(0, d) = Exp(kaldi::RandGauss()) *10.0F + 1e-5F;
  }
  weights(0) = 1.0F;
  invvars.CopyFromMat(vars);
  invvars.InvertElements();

  // new GMM
  DiagGmm *gmm = new DiagGmm();
  gmm->Resize(1, dim);
  gmm->SetWeights(weights);
  gmm->SetInvVarsAndMeans(invvars, means);
  gmm->ComputeGconsts();


  EbwOptions ebw_opts;
  EbwWeightOptions ebw_weight_opts;

  int r = Rand() % 16;
  GmmFlagsType flags = (r%2 == 0 ? kGmmMeans : 0)
      + ((r/2)%2 == 0 ? kGmmVariances : 0)
      + ((r/4)%2 == 0 ? kGmmWeights : 0);
  double tau = (r/8)%2 == 0 ? 100 : 0.0;

  if ((flags & kGmmVariances) && !(flags & kGmmMeans)) {
    delete gmm;
    return; // Don't do this case: not supported in the update equations.
  }

  AccumDiagGmm num;
  AccumDiagGmm den;

  num.Resize(gmm->NumGauss(), gmm->Dim(), flags);
  num.SetZero(flags);
  den.Resize(gmm->NumGauss(), gmm->Dim(), flags);
  den.SetZero(flags);

  size_t iteration = 0;
  double last_log_like_diff = NAN;
  while (iteration < maxiterations) {
    Vector<BaseFloat> featvec_num(dim);
    Vector<BaseFloat> featvec_den(dim);
    num.Resize(gmm->NumGauss(), gmm->Dim(), flags);
    num.SetZero(flags);
    den.Resize(gmm->NumGauss(), gmm->Dim(), flags);
    den.SetZero(flags);

    double loglike_num = 0.0;
    double loglike_den = 0.0;
    for (size_t i = 0; i < counter_num; i++) {
      featvec_num.CopyRowFromMat(feats_num, i);
      loglike_num += static_cast<double>(num.AccumulateFromDiag(*gmm,
                                                                featvec_num, 1.0F));
      // std::cout << "Mean accum_num: " <<  num.mean_accumulator() << '\n';
    }
    for (size_t i = 0; i < counter_den; i++) {
      featvec_den.CopyRowFromMat(feats_den, i);
      loglike_den += static_cast<double>(den.AccumulateFromDiag(*gmm,
                                                                featvec_den, 1.0F));
      // std::cout << "Mean accum_den: " <<  den.mean_accumulator() << '\n';
    }

    std::cout << "Loglikelihood Num before iteration " << iteration << " : "
              << std::scientific << loglike_num << " number of components: "
              << gmm->NumGauss() << '\n';

    std::cout << "Loglikelihood Den before iteration " << iteration << " : "
              << std::scientific << loglike_den << " number of components: "
              << gmm->NumGauss() << '\n';

    double loglike_diff = loglike_num - loglike_den;
    if (iteration > 0) {
      KALDI_LOG << "Objective changed " << last_log_like_diff
                << " to " << loglike_diff;
      if (loglike_diff < last_log_like_diff)
        KALDI_WARN << "Objective decreased (flags = "
                   << GmmFlagsToString(flags) << ", tau = " << tau << " )";
    }
    last_log_like_diff = loglike_diff;

    AccumDiagGmm num_smoothed(num);
    IsmoothStatsDiagGmm(num, tau, &num_smoothed); // Apply I-smoothing.

    BaseFloat auxf_gauss, auxf_weight, count;
    std::cout << "MEANX: " << gmm->weights() << '\n';

    int32 num_floored;
    UpdateEbwDiagGmm(num_smoothed, den, flags, ebw_opts,
                     gmm, &auxf_gauss, &count, &num_floored);

    if (flags & kGmmWeights) {
      UpdateEbwWeightsDiagGmm(num, den, ebw_weight_opts, gmm, &auxf_weight,
                              &count);
    }

    // mean_hlp.CopyFromVec(gmm->means_invvars().Row(0));
    // std::cout << "MEANY: " << mean_hlp << '\n';
    std::cout << "MEANY: " << gmm->weights() << '\n';


    if ((iteration % 3 == 1) && (gmm->NumGauss() * 2 <= maxcomponents)) {
      gmm->Split(gmm->NumGauss() * 2, 0.001);
      std::cout << "Ngauss, Ndim: " << gmm->NumGauss() << " " << gmm->Dim() << '\n';
    }

    iteration++;
  }
  delete gmm;

  unlink("tmpfeats");
}

UnitTestExpSpeed()

void kaldi::UnitTestExpSpeed

(

)

Definition at line 276 of file kaldi-math-test.cc.

References Timer::Elapsed(), Exp(), rnnlm::i, KALDI_ASSERT, and KALDI_LOG.

                        {
  Real sum = 0.0;  // compute the sum to avoid optimizing it away.
  Real time = 0.01;  // how long this should last.
  int block_size = 10;
  int num_ops = 0;
  Timer tim;
  while (tim.Elapsed() < time) {
    for (int i = 0; i < block_size; i++) {
      sum += Exp((Real)i);
    }
    num_ops += block_size;
  }
  KALDI_ASSERT(sum > 0.0);  // make it harder for the compiler to optimize Exp
                            // away, as we have a conditional.
  Real flops = 1.0e-06 * num_ops / tim.Elapsed();
  KALDI_LOG << "Megaflops doing Exp("
            << (sizeof(Real) == 4 ? "float" : "double") << ") is " << flops;
}

UnitTestExtractCompressedMatrix()

static void kaldi::UnitTestExtractCompressedMatrix ( )

static

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

References MatrixBase< Real >::ApproxEqual(), CompressedMatrix::CopyToMat(), rnnlm::i, KALDI_ERR, KALDI_VLOG, Rand(), and MatrixBase< Real >::SetRandn().

                                              {
  for (int32 i = 0; i < 30; i++) {
    MatrixIndexT num_rows = Rand() % 20, num_cols = Rand() % 30;
    if (num_rows * num_cols == 0) {
      // this test wouldn't work for empty matrices.
      num_rows++;
      num_cols++;
    }
    Matrix<Real> mat(num_rows, num_cols);
    mat.SetRandn();
    CompressedMatrix cmat(mat);

    MatrixIndexT row_offset = Rand() % num_rows, col_offset = Rand() % num_cols;
    MatrixIndexT sub_num_rows = Rand() % (num_rows - row_offset) + 1,
      sub_num_cols = Rand() % (num_cols - col_offset) + 1;
    KALDI_VLOG(3) << "Whole matrix size: " << num_rows << "," << num_cols;
    KALDI_VLOG(3) << "Sub-matrix size: " << sub_num_rows << "," << sub_num_cols
                  << " with offsets " << row_offset << "," << col_offset;
    CompressedMatrix cmat2(cmat, row_offset, sub_num_rows,  //take a subset of
                           col_offset, sub_num_cols);  // the compressed matrix
    Matrix<Real> mat2(sub_num_rows, sub_num_cols);
    cmat2.CopyToMat(&mat2);  // uncompress the subset of the compressed matrix

    Matrix<Real> mat3(cmat);  // uncompress the whole compressed matrix
    SubMatrix<Real> sub_mat(mat3, row_offset, sub_num_rows, col_offset, sub_num_cols);
    if(!sub_mat.ApproxEqual(mat2)) {
      KALDI_ERR << "Matrices differ " << sub_mat << " vs. " << mat2;
    }
  }
}

UnitTestFactorize()

void kaldi::UnitTestFactorize

(

)

Definition at line 249 of file kaldi-math-test.cc.

Referenced by main().

                         {
  UnitTestFactorizeTpl<int>();
  UnitTestFactorizeTpl<size_t>();
  UnitTestFactorizeTpl<int16>();
}

UnitTestFactorizeTpl()

void kaldi::UnitTestFactorizeTpl

(

)

Definition at line 232 of file kaldi-math-test.cc.

References Factorize(), rnnlm::i, KALDI_ASSERT, and Rand().

                                              {
  for (int p= 0; p < 100; p++) {
    I m = Rand() % 100000;
    if (m >= 1) {
      std::vector<I> factors;
      Factorize(m, &factors);
      I m2 = 1;
      for (size_t i = 0; i < factors.size(); i++) {
        m2 *= factors[i];
        if (i+1 < factors.size())
          KALDI_ASSERT(factors[i+1] >= factors[i]);  // check sorted.
      }
      KALDI_ASSERT(m2 == m);  // check correctness.
    }
  }
}

UnitTestFeatNoKeele()

static void kaldi::UnitTestFeatNoKeele ( )

static

Definition at line 596 of file pitch-functions-test.cc.

References UnitTestDelay(), UnitTestPieces(), UnitTestSearch(), UnitTestSimple(), and UnitTestSnipEdges().

Referenced by main().

                                  {
  UnitTestSimple();
  UnitTestPieces();
  UnitTestSnipEdges();
  UnitTestDelay();
  UnitTestSearch();
}

UnitTestFeatWithKeele()

static void kaldi::UnitTestFeatWithKeele ( )

static

Definition at line 604 of file pitch-functions-test.cc.

References UnitTestComputeGPE(), UnitTestDiffSampleRate(), UnitTestKeele(), UnitTestKeeleNccfBallast(), UnitTestPenaltyFactor(), UnitTestPitchExtractionSpeed(), UnitTestPitchExtractorCompareKeele(), and UnitTestProcess().

Referenced by main().

                                    {
  UnitTestProcess();
  UnitTestKeele();
  UnitTestComputeGPE();
  UnitTestPenaltyFactor();
  UnitTestKeeleNccfBallast();
  UnitTestPitchExtractionSpeed();
  UnitTestPitchExtractorCompareKeele();
  UnitTestDiffSampleRate();
}

UnitTestFFTbasedBlockConvolution()

void kaldi::UnitTestFFTbasedBlockConvolution

(

)

Definition at line 26 of file signal-test.cc.

References AssertEqual(), VectorBase< Real >::Dim(), FFTbasedBlockConvolveSignals(), FFTbasedConvolveSignals(), rnnlm::i, Rand(), and VectorBase< Real >::SetRandn().

Referenced by main().

                                        {
  for (int32 i = 0; i < 5; i++) {
    int32 signal_length = 400000 + Rand() % 40000;
    int32 filter_length = 1000 + Rand() % 100;
    Vector<BaseFloat> signal(signal_length);
    Vector<BaseFloat> filter(filter_length);
    signal.SetRandn();
    filter.SetRandn();
    Vector<BaseFloat> signal_test(signal);
    FFTbasedConvolveSignals(filter, &signal_test);
    FFTbasedBlockConvolveSignals(filter, &signal);
    AssertEqual(signal, signal_test, 0.000001 * signal.Dim());
  }
}

UnitTestFFTbasedConvolution()

void kaldi::UnitTestFFTbasedConvolution

(

)

Definition at line 41 of file signal-test.cc.

References AssertEqual(), ConvolveSignals(), VectorBase< Real >::Dim(), FFTbasedConvolveSignals(), rnnlm::i, Rand(), and VectorBase< Real >::SetRandn().

Referenced by main().

                                   {
  for (int32 i = 0; i < 5; i++) {
    int32 signal_length = 4000 + Rand() % 400;
    int32 filter_length = 10 + Rand() % 10;
    Vector<BaseFloat> signal(signal_length);
    Vector<BaseFloat> filter(filter_length);
    signal.SetRandn();
    filter.SetRandn();
    Vector<BaseFloat> signal_test(signal);
    ConvolveSignals(filter, &signal_test);
    FFTbasedConvolveSignals(filter, &signal);
    AssertEqual(signal, signal_test, 0.0001 * signal.Dim());
  }
}

UnitTestFloorCeiling()

static void kaldi::UnitTestFloorCeiling ( )

static

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

References VectorBase< Real >::ApplyCeiling(), VectorBase< Real >::ApplyFloor(), AssertEqual(), rnnlm::d, rnnlm::i, KALDI_ASSERT, Rand(), and VectorBase< Real >::SetRandn().

                                                            {
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = 10 + Rand() % 10;
    Vector<Real> v(dimM);
    v.SetRandn();
    Real pivot = v(5);
    Vector<Real> f(v), f2(v), c(v), c2(v);
    MatrixIndexT floored2;
    f.ApplyFloor(pivot, &floored2);
    MatrixIndexT ceiled2;
    c.ApplyCeiling(pivot, &ceiled2);
    MatrixIndexT floored = 0, ceiled = 0;
    for (MatrixIndexT d = 0; d < dimM; d++) {
      if (f2(d) < pivot) { f2(d) = pivot; floored++; }
      if (c2(d) > pivot) { c2(d) = pivot; ceiled++; }
    }
    AssertEqual(f, f2);
    AssertEqual(c, c2);
    KALDI_ASSERT(floored == floored2);
    KALDI_ASSERT(ceiled == ceiled2);

    // Check that the non-counting variants are equivalent to the counting
    // variants.
    Vector<Real> f3(v);
    f3.ApplyFloor(pivot);
    AssertEqual(f2, f3);

    Vector<Real> c3(v);
    c3.ApplyCeiling(pivot);
    AssertEqual(c2, c3);
  }
}

UnitTestFloorChol()

static void kaldi::UnitTestFloorChol ( )

static

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

References SpMatrix< Real >::AddMat2(), SpMatrix< Real >::ApplyFloor(), rnnlm::i, InitRandNonsingular(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kNoTrans, Rand(), PackedMatrix< Real >::Scale(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and VecSpVec().

                                                         {
  for (MatrixIndexT i = 0;i < 10;i++) {
    MatrixIndexT dimM = 20 + Rand()%10;


    MatrixIndexT dimN = 20 + Rand()%10;
    Matrix<Real> X(dimM, dimN);
    X.SetRandn();
    SpMatrix<Real> B(dimM);
    B.AddMat2(1.0, X, kNoTrans, 0.0);  // B = X*X^T -> positive semidefinite.

    float alpha = (Rand() % 10) + 0.5;
    Matrix<Real> M(dimM, dimM);
    M.SetRandn();
    SpMatrix<Real> C(dimM);
    C.AddMat2(1.0, M, kNoTrans, 0.0);  // C:=M*M^T
    InitRandNonsingular(&M);
    C.AddMat2(1.0, M, kNoTrans, 1.0);  // C+=M*M^T (after making new random M)
    if (i%2 == 0)
      C.Scale(0.001);  // so it's not too much bigger than B (or it's trivial)
    SpMatrix<Real> BFloored(B); BFloored.ApplyFloor(C, alpha);


    for (MatrixIndexT j = 0;j < 10;j++) {
      Vector<Real> v(dimM);
      v.SetRandn();
      Real ip_b = VecSpVec(v, B, v);
      Real ip_a = VecSpVec(v, BFloored, v);
      Real ip_c = alpha * VecSpVec(v, C, v);
      if (i < 3) KALDI_LOG << "alpha = " << alpha << ", ip_a = " << ip_a << " ip_b = " << ip_b << " ip_c = " << ip_c <<'\n';
      KALDI_ASSERT(ip_a>=ip_b*0.999 && ip_a>=ip_c*0.999);
    }
  }
}

UnitTestFloorUnit()

static void kaldi::UnitTestFloorUnit ( )

static

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

References SpMatrix< Real >::AddMat2(), SpMatrix< Real >::ApplyFloor(), rnnlm::i, KALDI_ASSERT, kNoTrans, VectorBase< Real >::Min(), Rand(), MatrixBase< Real >::SetRandn(), and SpMatrix< Real >::SymPosSemiDefEig().

                                                         {
  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = 20 + Rand()%10;
    MatrixIndexT dimN = 20 + Rand()%10;
    float floor = (Rand() % 10) - 3;

    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    SpMatrix<Real> B(dimM);
    B.AddMat2(1.0, M, kNoTrans, 0.0);  // B = M*M^T -> positive semidefinite.

    SpMatrix<Real> BFloored(B);
    BFloored.ApplyFloor(floor);


    Vector<Real> s(dimM); Matrix<Real> P(dimM, dimM); B.SymPosSemiDefEig(&s, &P);
    Vector<Real> s2(dimM); Matrix<Real> P2(dimM, dimM); BFloored.SymPosSemiDefEig(&s2, &P2);

    KALDI_ASSERT ( (s.Min() >= floor && std::abs(s2.Min()-s.Min())<0.01) || std::abs(s2.Min()-floor)<0.01);
  }
}

UnitTestFmllrDiagGmm()

void kaldi::UnitTestFmllrDiagGmm

(

)

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

References FmllrDiagGmmAccs::AccumulateForGmm(), FmllrDiagGmmAccs::AccumulateFromPosteriors(), ApplyAffineTransform(), ApplyFeatureTransformToStats(), ApproxEqual(), DiagGmm::ComponentPosteriors(), count, DiagGmm::Dim(), DiagGmm::Generate(), rnnlm::i, InitRandomGmm(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, DiagGmm::NumGauss(), MatrixBase< Real >::SetUnit(), and FmllrDiagGmmAccs::Update().

Referenced by main().

                            {
  using namespace kaldi;
  DiagGmm gmm;
  InitRandomGmm(&gmm);
  int32 dim =  gmm.Dim();
  int32 npoints = dim*(dim+1)*5;
  Matrix<BaseFloat> rand_points(npoints, dim);
  for (int32 i = 0; i < npoints; i++) {
    SubVector<BaseFloat> row(rand_points, i);
    gmm.Generate(&row);
  }
  Matrix<BaseFloat> cur_xform(dim, dim+1);
  cur_xform.SetUnit();  // set diag to unit.

  int32 niters = 5;
  BaseFloat objf_change_tot = 0.0, objf_change, count;
  for (int32 j = 0; j < niters; j++) {
    FmllrOptions opts;
    FmllrDiagGmmAccs stats(dim, j % 2 == 0 ? opts : FmllrOptions());
    for (int32 i = 0; i < npoints; i++) {
      SubVector<BaseFloat> row(rand_points, i);
      if (j == 0) {  // split this case off to exercise more of the code.
        stats.AccumulateForGmm(gmm, row, 1.0);
      } else {
        Vector<BaseFloat> xformed_row(row);
        ApplyAffineTransform(cur_xform, &xformed_row);
        Vector<BaseFloat> posteriors(gmm.NumGauss());
        gmm.ComponentPosteriors(xformed_row, &posteriors);
        stats.AccumulateFromPosteriors(gmm, row, posteriors);
      }
    }
    stats.Update(opts, &cur_xform, &objf_change, &count);
    {  // Test for ApplyFeatureTransformToStats:
      BaseFloat objf_change_tmp, count_tmp;
      ApplyFeatureTransformToStats(cur_xform, &stats);
      Matrix<BaseFloat> mat(dim, dim+1);
      mat.SetUnit();
      stats.Update(opts, &mat, &objf_change_tmp, &count_tmp);
      // After we apply this transform to the stats, there should
      // be nothing to gain from further transforming the data.
      KALDI_ASSERT(objf_change_tmp/count_tmp < 0.01);
    }
    KALDI_LOG << "Objf change on iter " << j << " is " << objf_change;
    objf_change_tot += objf_change;
  }
  KALDI_ASSERT(ApproxEqual(count, npoints));
  int32 num_params = dim*(dim+1);
  BaseFloat expected_objf_change = 0.5 * num_params;
  KALDI_LOG << "Expected objf change is: not much more than " << expected_objf_change
            <<", seen: " << objf_change_tot;
  KALDI_ASSERT(objf_change_tot < 2.0 * expected_objf_change);  // or way too much.
  // This test relies on statistical laws and if it fails it does not *necessarily*
  // mean that something is wrong.
}

UnitTestFmllrDiagGmmDiagonal()

void kaldi::UnitTestFmllrDiagGmmDiagonal

(

)

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

References FmllrDiagGmmAccs::AccumulateForGmm(), FmllrDiagGmmAccs::AccumulateFromPosteriors(), ApplyAffineTransform(), ApplyModelTransformToStats(), ApproxEqual(), DiagGmm::ComponentPosteriors(), count, DiagGmm::Dim(), DiagGmm::Generate(), rnnlm::i, InitRandomGmm(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, DiagGmm::NumGauss(), MatrixBase< Real >::SetUnit(), FmllrDiagGmmAccs::Update(), and FmllrOptions::update_type.

Referenced by main().

                                    {
  using namespace kaldi;
  DiagGmm gmm;
  InitRandomGmm(&gmm);
  int32 dim =  gmm.Dim();
  int32 npoints = dim*(dim+1)*5;
  Matrix<BaseFloat> rand_points(npoints, dim);
  for (int32 i = 0; i < npoints; i++) {
    SubVector<BaseFloat> row(rand_points, i);
    gmm.Generate(&row);
  }
  Matrix<BaseFloat> cur_xform(dim, dim+1);
  cur_xform.SetUnit();  // set diag to unit.

  int32 niters = 2;
  BaseFloat objf_change_tot = 0.0, objf_change, count;
  FmllrOptions opts;
  opts.update_type = "diag";

  for (int32 j = 0; j < niters; j++) {
    FmllrDiagGmmAccs stats(dim, j % 2 == 0 ? opts : FmllrOptions());
    for (int32 i = 0; i < npoints; i++) {
      SubVector<BaseFloat> row(rand_points, i);
      if (j == 0) {  // split this case off to exercise more of the code.
        stats.AccumulateForGmm(gmm, row, 1.0);
      } else {
        Vector<BaseFloat> xformed_row(row);
        ApplyAffineTransform(cur_xform, &xformed_row);
        Vector<BaseFloat> posteriors(gmm.NumGauss());
        gmm.ComponentPosteriors(xformed_row, &posteriors);
        stats.AccumulateFromPosteriors(gmm, row, posteriors);
      }
    }

    stats.Update(opts, &cur_xform, &objf_change, &count);
    {  // Test for ApplyModelTransformToStats:
      BaseFloat objf_change_tmp, count_tmp;
      ApplyModelTransformToStats(cur_xform, &stats);
      Matrix<BaseFloat> mat(dim, dim+1);
      mat.SetUnit();
      stats.Update(opts, &mat, &objf_change_tmp, &count_tmp);
      // After we apply this transform to the stats, there should
      // be nothing to gain from further transforming the data.
      KALDI_ASSERT(objf_change_tmp/count_tmp < 0.01);
    }
    KALDI_LOG << "Objf change on iter " << j << " is " << objf_change;
    objf_change_tot += objf_change;
  }
  KALDI_ASSERT(ApproxEqual(count, npoints));
  int32 num_params = dim*2;
  BaseFloat expected_objf_change = 0.5 * num_params;
  KALDI_LOG << "Expected objf change is: not much more than " << expected_objf_change
            <<", seen: " << objf_change_tot;
  KALDI_ASSERT(objf_change_tot < 2.0 * expected_objf_change);  // or way too much.
  // This test relies on statistical laws and if it fails it does not *necessarily*
  // mean that something is wrong.
}

UnitTestFmllrDiagGmmOffset()

void kaldi::UnitTestFmllrDiagGmmOffset

(

)

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

References FmllrDiagGmmAccs::AccumulateForGmm(), FmllrDiagGmmAccs::AccumulateFromPosteriors(), ApplyAffineTransform(), ApplyModelTransformToStats(), ApproxEqual(), DiagGmm::ComponentPosteriors(), count, DiagGmm::Dim(), DiagGmm::Generate(), rnnlm::i, InitRandomGmm(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, DiagGmm::NumGauss(), MatrixBase< Real >::SetUnit(), FmllrDiagGmmAccs::Update(), and FmllrOptions::update_type.

Referenced by main().

                                  {
  using namespace kaldi;
  DiagGmm gmm;
  InitRandomGmm(&gmm);
  int32 dim =  gmm.Dim();
  int32 npoints = dim*(dim+1)*5;
  Matrix<BaseFloat> rand_points(npoints, dim);
  for (int32 i = 0; i < npoints; i++) {
    SubVector<BaseFloat> row(rand_points, i);
    gmm.Generate(&row);
  }
  Matrix<BaseFloat> cur_xform(dim, dim+1);
  cur_xform.SetUnit();  // set diag to unit.

  int32 niters = 2;
  BaseFloat objf_change_tot = 0.0, objf_change, count;
  FmllrOptions opts;
  opts.update_type = "offset";

  for (int32 j = 0; j < niters; j++) {
    FmllrDiagGmmAccs stats(dim, j % 2 == 0 ? opts : FmllrOptions());
    for (int32 i = 0; i < npoints; i++) {
      SubVector<BaseFloat> row(rand_points, i);
      if (j == 0) {  // split this case off to exercise more of the code.
        stats.AccumulateForGmm(gmm, row, 1.0);
      } else {
        Vector<BaseFloat> xformed_row(row);
        ApplyAffineTransform(cur_xform, &xformed_row);
        Vector<BaseFloat> posteriors(gmm.NumGauss());
        gmm.ComponentPosteriors(xformed_row, &posteriors);
        stats.AccumulateFromPosteriors(gmm, row, posteriors);
      }
    }

    stats.Update(opts, &cur_xform, &objf_change, &count);
    {  // Test for ApplyModelTransformToStats:
      BaseFloat objf_change_tmp, count_tmp;
      ApplyModelTransformToStats(cur_xform, &stats);
      Matrix<BaseFloat> mat(dim, dim+1);
      mat.SetUnit();
      stats.Update(opts, &mat, &objf_change_tmp, &count_tmp);
      // After we apply this transform to the stats, there should
      // be nothing to gain from further transforming the data.
      KALDI_ASSERT(objf_change_tmp/count_tmp < 0.01);
    }
    KALDI_LOG << "Objf change on iter " << j << " is " << objf_change;
    objf_change_tot += objf_change;
  }
  KALDI_ASSERT(ApproxEqual(count, npoints));
  int32 num_params = dim;
  BaseFloat expected_objf_change = 0.5 * num_params;
  KALDI_LOG << "Expected objf change is: not much more than " << expected_objf_change
            <<", seen: " << objf_change_tot;
  KALDI_ASSERT(objf_change_tot < 2.0 * expected_objf_change);  // or way too much.
  // This test relies on statistical laws and if it fails it does not *necessarily*
  // mean that something is wrong.
}

UnitTestFmllrRaw()

void kaldi::UnitTestFmllrRaw

(

bool

use_offset

)

Definition at line 50 of file fmllr-raw-test.cc.

References FmllrRawAccs::AccumulateForGmm(), ApplyAffineTransform(), count, DiagGmm::Dim(), rnnlm::i, InitRandomGmm(), KALDI_ASSERT, Rand(), MatrixBase< Real >::SetRandn(), MatrixBase< Real >::SetUnit(), FmllrRawAccs::SetZero(), and FmllrRawAccs::Update().

Referenced by main().

                                       {
  using namespace kaldi;
  DiagGmm gmm;
  InitRandomGmm(&gmm);
  int32 model_dim =  gmm.Dim();

  int32 raw_dim = 5 + Rand() % 3;
  int32 num_splice = 1 + Rand() % 5;
  while (num_splice * raw_dim < model_dim) {
    num_splice++;
  }

  int32 full_dim = num_splice * raw_dim;
  int32 npoints = raw_dim*(raw_dim+1)*10;

  Matrix<BaseFloat> rand_points(npoints, full_dim);
  rand_points.SetRandn();

  Matrix<BaseFloat> lda_mllt(full_dim, full_dim + (use_offset ? 1 : 0)); // This is the full LDA+MLLT
  // matrix.  TODO: test with offset.
  lda_mllt.SetRandn();

  FmllrRawAccs accs(raw_dim, model_dim, lda_mllt);

  BaseFloat prev_objf_impr;
  for (int32 iter = 0; iter < 4; iter++) {

    for (int32 i = 0; i < npoints; i++) {
      SubVector<BaseFloat> sample(rand_points, i);
      accs.AccumulateForGmm(gmm, sample, 1.0);
    }

    Matrix<BaseFloat> fmllr_mat(raw_dim, raw_dim + 1);
    fmllr_mat.SetUnit(); // sets diagonal elements to one.

    FmllrRawOptions opts;
    BaseFloat objf_impr, count;
    accs.Update(opts, &fmllr_mat, &objf_impr, &count);

    KALDI_ASSERT(objf_impr > 0.0);

    if (iter != 0) {
      // This is not something provable, but is always true
      // in practice.
      KALDI_ASSERT(objf_impr < prev_objf_impr);
    }
    prev_objf_impr = objf_impr;


    // Now transform the raw features.
    for (int32 splice = 0; splice < num_splice; splice++) {
      SubMatrix<BaseFloat> raw_feats(rand_points,
                                     0, npoints,
                                     splice * raw_dim, raw_dim);
      for (int32 t = 0; t < npoints; t++) {
        SubVector<BaseFloat> this_feat(raw_feats, t);
        ApplyAffineTransform(fmllr_mat, &this_feat);
      }
    }
    accs.SetZero();
  }
}

UnitTestGcdLcm()

void kaldi::UnitTestGcdLcm

(

)

Definition at line 71 of file kaldi-math-test.cc.

Referenced by main().

                      {
  UnitTestGcdLcmTpl<int>();
  UnitTestGcdLcmTpl<size_t>();
  UnitTestGcdLcmTpl<int16>();
}

UnitTestGcdLcmTpl()

void kaldi::UnitTestGcdLcmTpl

(

)

Definition at line 25 of file kaldi-math-test.cc.

References Gcd(), KALDI_ASSERT, Lcm(), and Rand().

                                           {
  for (I a = 1; a < 15; a++) {  // a is min gcd.
    I b = (I)(Rand() % 10);
    I c = (I)(Rand() % 10);
    if (std::numeric_limits<I>::is_signed) {
      if (Rand() % 2 == 0) b = -b;
      if (Rand() % 2 == 0) c = -c;
    }
    if (b == 0 && c == 0) continue;  // gcd not defined for such numbers.
    I g = Gcd(b*a, c*a);
    KALDI_ASSERT(g >= a);
    KALDI_ASSERT((b*a) % g == 0);
    KALDI_ASSERT((c*a) % g == 0);

    // test least common multiple
    if (b <= 0 || c <= 0) continue;  // lcm not defined unless both positive.
    I h = Lcm(b*a, c*a);
    KALDI_ASSERT(h != 0 && (h % (b*a)) == 0 &&
                 (h % (c*a)) == 0);
  }
}

UnitTestGeneralMatrix()

static void kaldi::UnitTestGeneralMatrix ( )

static

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

References MatrixBase< Real >::Add(), MatrixBase< Real >::AddMat(), AssertEqual(), GeneralMatrix::Clear(), GeneralMatrix::Compress(), SparseMatrix< Real >::CopyToMat(), ExtractRowRangeWithPadding(), MatrixBase< Real >::FrobeniusNorm(), GeneralMatrix::GetMatrix(), InitKaldiInputStream(), InitKaldiOutputStream(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, KALDI_WARN, kNoTrans, rnnlm::n, GeneralMatrix::NumCols(), MatrixBase< Real >::NumRows(), GeneralMatrix::NumRows(), Rand(), RandGauss(), RandInt(), GeneralMatrix::Read(), MatrixBase< Real >::Row(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), GeneralMatrix::SwapSparseMatrix(), and GeneralMatrix::Write().

                                                            {
  // This is the basic test.

  GeneralMatrix empty_pmat;  // some tests on empty matrix
  KALDI_ASSERT(empty_pmat.NumRows() == 0);
  KALDI_ASSERT(empty_pmat.NumCols() == 0);

  // could set num_tot to 10000 for more thorough testing.
  MatrixIndexT num_failure = 0, num_tot = 1000, max_failure = 1;
  for (MatrixIndexT n = 0; n < num_tot; n++) {
    MatrixIndexT num_rows = Rand() % 20, num_cols = Rand() % 15;
    if (num_rows * num_cols == 0) {
      num_rows = 0;
      num_cols = 0;
    }
    if (rand() % 2 == 0 && num_cols != 0) {
      // smaller matrices are more likely to have problems.
      num_cols = 1 + Rand() % 3;
    }
    Matrix<Real> M(num_rows, num_cols);
    if (Rand() % 3 != 0)
      M.SetRandn();
    else {
      M.Add(RandGauss());
    }
    if (Rand() % 2 == 0 && num_rows != 0) {  // set one row to all the same value,
      // which is one possible pathology.
      // Give it large dynamic range to increase chance that it
      // is the largest or smallest value in the matrix.
      M.Row(Rand() % num_rows).Set(RandGauss() * 4.0);
    }
    double rand_val = RandGauss() * 4.0;
    // set a bunch of elements to all one value: increases
    // chance of pathologies.
    MatrixIndexT modulus = 1 + Rand() % 5;
    for (MatrixIndexT r = 0; r < num_rows; r++)
      for (MatrixIndexT c = 0; c < num_cols; c++)
        if (Rand() % modulus != 0) M(r, c) = rand_val;

    GeneralMatrix pmat(M);
    if (RandInt(0, 1) == 0)
      pmat.Compress();

    if (RandInt(0, 1) == 0) {
      SparseMatrix<BaseFloat> smat(num_rows, num_cols);
      smat.SetRandn(0.1);
      pmat.Clear();
      smat.CopyToMat(&M, kNoTrans);
      pmat.SwapSparseMatrix(&smat);
    }

    KALDI_ASSERT(pmat.NumRows() == num_rows);
    KALDI_ASSERT(pmat.NumCols() == num_cols);
    GeneralMatrix pmat2(pmat);

    Matrix<Real> M2(pmat2.NumRows(), pmat2.NumCols());
    pmat2.GetMatrix(&M2);

    Matrix<Real> diff(M2);
    diff.AddMat(-1.0, M);

    if (pmat2.NumRows() > 0) {  // Test ExtractRowRangeWithPadding.
      int32 row_offset = RandInt(-3, pmat.NumRows() - 1),
          num_rows = RandInt(1, 3 + pmat.NumRows() - row_offset);
      GeneralMatrix pmat3;
      ExtractRowRangeWithPadding(pmat2, row_offset, num_rows, &pmat3);

      Matrix<Real> mat_A(num_rows, pmat.NumCols()),
          mat_B(num_rows, pmat.NumCols());
      pmat3.GetMatrix(&mat_A);
      for (int32 row_out = 0; row_out < num_rows; row_out++) {
        int32 row_in = row_out + row_offset;
        if (row_in < 0) row_in = 0;
        if (row_in >= pmat2.NumRows())
          row_in = pmat2.NumRows() - 1;
        SubVector<Real> vec_out(mat_B, row_out),
            vec_in(M2, row_in);
        vec_out.CopyFromVec(vec_in);
      }
      if (mat_A.NumRows() >= 8) {
        // there should be exact equality.
        AssertEqual(mat_A, mat_B, 0.0);
      } else {
        // If it was compressed matrix and num-rows selected is < 8 and the
        // format was the one with per-column headers, then we would have changed
        // the format to save memory, which is not completely lossless.
        mat_A.AddMat(-1.0, mat_B);
        KALDI_ASSERT(mat_A.FrobeniusNorm() /
                     (mat_A.NumRows() * mat_A.NumCols()) < 0.001);
      }
    }

    if (n < 5) {  // test I/O.
      bool binary = (n % 2 == 1);
      {
        std::ofstream outs("tmpf", std::ios_base::out |std::ios_base::binary);
        InitKaldiOutputStream(outs, binary);
        pmat.Write(outs, binary);
      }
      GeneralMatrix pmat3;
      {
        bool binary_in;
        std::ifstream ins("tmpf", std::ios_base::in | std::ios_base::binary);
        InitKaldiInputStream(ins, &binary_in);
        pmat3.Read(ins, binary_in);
      }

      Matrix<Real> M3(pmat3.NumRows(), pmat3.NumCols());
      pmat3.GetMatrix(&M3);
      AssertEqual(M, M3);
    }

    KALDI_LOG << "M = " << M;
    KALDI_LOG << "M2 = " << M2;
    double tot = M.FrobeniusNorm(), err = diff.FrobeniusNorm();
    KALDI_LOG << "Compressed matrix, tot = " << tot << ", diff = "
              << err;
    if (err > 0.015 * tot) {
      KALDI_WARN << "Failure in possibly compressed-matrix test.";
      num_failure++;
    }
  }
  if (num_failure > max_failure)
    KALDI_ERR << "Too many failures in possibly compressed matrix test " << num_failure
              << " > " << max_failure;

  unlink("tmpf");
}

UnitTestHeaviside()

static void kaldi::UnitTestHeaviside ( )

static

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

References MatrixBase< Real >::ApplyHeaviside(), KALDI_ASSERT, and Rand().

                                                        {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 10 + Rand() % 10, dimN = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), N(dimM, dimN);
    M.SetRandn();
    N = M;
    N.ApplyHeaviside();
    for (MatrixIndexT r = 0; r < dimM; r++) {
      for (MatrixIndexT c = 0; c < dimN; c++) {
        Real x = M(r, c), y = N(r, c);
        if (x < 0.0) KALDI_ASSERT(y == 0.0);
        if (x > 0.0) KALDI_ASSERT(y == 1.0);
        if (x == 0.0) { KALDI_ASSERT(y >= 0.0 && y <= 1.0); }
      }
    }
  }
}

UnitTestHtkIo()

static void kaldi::UnitTestHtkIo ( )

static

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

References AssertEqual(), rnnlm::i, KALDI_ASSERT, HtkHeader::mNSamples, HtkHeader::mSampleKind, HtkHeader::mSamplePeriod, HtkHeader::mSampleSize, Rand(), ReadHtk(), MatrixBase< Real >::SetRandn(), and WriteHtk().

                                                    {

  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = Rand()%10 + 10;
    MatrixIndexT dimN = Rand()%10 + 10;

    HtkHeader hdr;
    hdr.mNSamples = dimM;
    hdr.mSamplePeriod = 10000;  // in funny HTK units-- can set it arbitrarily
    hdr.mSampleSize = sizeof(float)*dimN;
    hdr.mSampleKind = 8;  // Mel spectrum.

    Matrix<Real> M(dimM, dimN);
    M.SetRandn();

    {
      std::ofstream os("tmpf", std::ios::out|std::ios::binary);
      WriteHtk(os, M, hdr);
    }

    Matrix<Real> N;
    HtkHeader hdr2;
    {
      std::ifstream is("tmpf", std::ios::in|std::ios::binary);
      ReadHtk(is, &N, &hdr2);
    }

    AssertEqual(M, N);
    KALDI_ASSERT(hdr.mNSamples == hdr2.mNSamples);
    KALDI_ASSERT(hdr.mSamplePeriod == hdr2.mSamplePeriod);
    KALDI_ASSERT(hdr.mSampleSize == hdr2.mSampleSize);
    KALDI_ASSERT(hdr.mSampleKind == hdr2.mSampleKind);
  }

  unlink("tmpf");
}

UnitTestInnerProd()

static void kaldi::UnitTestInnerProd ( )

static

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

References AssertEqual(), rnnlm::i, rnnlm::j, Rand(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), and VecSpVec().

                                                        {

  MatrixIndexT N = 1 + Rand() % 10;
  SpMatrix<Real> S(N);
  S.SetRandn();
  Vector<Real> v(N);
  v.SetRandn();
  Real prod = VecSpVec(v, S, v);
  Real f2=0.0;
  for (MatrixIndexT i = 0; i < N; i++)
    for (MatrixIndexT j = 0; j < N; j++) {
      f2 += v(i) * v(j) * S(i, j);
    }
  AssertEqual(prod, f2);
}

UnitTestInverse()

static void kaldi::UnitTestInverse ( )

static

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

References MatrixBase< Real >::AddMatMat(), rnnlm::i, InitRandNonsingular(), rnnlm::j, KALDI_ASSERT, kNoTrans, and Rand().

                                                      {
  for (MatrixIndexT iter = 0;iter < 10;iter++) {
    MatrixIndexT dimM = 20 + Rand()%10;
    Matrix<Real> A(dimM, dimM), B(dimM, dimM), C(dimM, dimM);
    InitRandNonsingular(&A);
    B.CopyFromMat(A);
    B.Invert();

    C.AddMatMat(1.0, A, kNoTrans, B, kNoTrans, 0.0);  // C = A * B.


    for (MatrixIndexT i = 0;i < dimM;i++)
      for (MatrixIndexT j = 0;j < dimM;j++)
        KALDI_ASSERT(std::abs(C(i, j) - (i == j?1.0:0.0)) < 0.1);
  }
}

UnitTestInvert()

static void kaldi::UnitTestInvert ( )

static

Definition at line 185 of file cu-test.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddVecVec(), AssertEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), rnnlm::i, KALDI_LOG, kNoTrans, Rand(), and CuMatrixBase< Real >::SymInvertPosDef().

                                                     {
  for (MatrixIndexT iter = 0; iter < 3; iter++) {
    MatrixIndexT dim = 500 + Rand() % 400;

    KALDI_LOG << "dim is : ";
    KALDI_LOG << dim;
    CuMatrix<Real> A(dim,dim);
    Matrix<Real> B(dim,dim);
    Vector<Real> C(dim);
    for (MatrixIndexT i = 0; i < dim; i++) {
      B(i,i) = 1;
      C(i) = (i/(1.0*dim)) + 1;
    }
    Matrix<Real> Identity(B);
    B.AddVecVec(1.0, C, C);
    // Now we have a positive-definite B (inversion would
    // fail if it were not positive definite).

    A.CopyFromMat(B);

    A.SymInvertPosDef();
    Matrix<Real> D(dim,dim);
    A.CopyToMat(&D);

    Matrix<Real> X(dim,dim);
    X.AddMatMat(1.0, B, kNoTrans, D, kNoTrans, 0.0);
    // KALDI_LOG << "X is (should be identity): " << X;
    AssertEqual(Identity, X, (sizeof(Real) == 4 ? 0.1 : 0.001));
  }
}

UnitTestIo() [1/2]

void kaldi::UnitTestIo

(

bool

binary

)

Definition at line 24 of file io-funcs-test.cc.

References AssertEqual(), ExpectToken(), rnnlm::i, InitKaldiInputStream(), InitKaldiOutputStream(), KALDI_ASSERT, Peek(), PeekToken(), Rand(), RandInt(), RandUniform(), ReadBasicType(), ReadIntegerPairVector(), ReadIntegerVector(), ReadToken(), WriteBasicType(), WriteIntegerPairVector(), WriteIntegerVector(), and WriteToken().

Referenced by main().

                             {
  {
    const char *filename = "tmpf";
    std::ofstream outfile(filename, std::ios_base::out | std::ios_base::binary);
    InitKaldiOutputStream(outfile, binary);
    if (!binary) outfile << "\t";
    int64 i1 = Rand() % 10000;
    WriteBasicType(outfile, binary, i1);
    uint16 i2 = Rand() % 10000;
    WriteBasicType(outfile, binary, i2);
    if (!binary) outfile << "\t";
    char c = Rand();
    WriteBasicType(outfile, binary, c);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<int32> vec1;
    WriteIntegerVector(outfile, binary, vec1);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<uint16> vec2;
    for (size_t i = 0; i < 10; i++) vec2.push_back(Rand()%100 - 10);
    WriteIntegerVector(outfile, binary, vec2);
    if (!binary) outfile << " \n";
    std::vector<char> vec3;

    int32 size = RandInt(0, 10);
    for (size_t i = 0; i < size; i++) vec3.push_back(Rand()%100);
    WriteIntegerVector(outfile, binary, vec3);
    std::vector<std::pair<int32, int32> > vec4;
    WriteIntegerPairVector(outfile, binary, vec4);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<std::pair<uint16, uint16> > vec5;
    for (size_t i = 0; i < size; i++) vec5.push_back(std::make_pair<uint16, uint16>(Rand()%100 - 10, Rand()%100 - 10));
    WriteIntegerPairVector(outfile, binary, vec5);
    if (!binary) outfile << " \n";
    std::vector<std::pair<char, char> > vec6;
    for (size_t i = 0; i < size; i++) vec6.push_back(std::make_pair<char, char>(Rand()%100, Rand()%100));
    WriteIntegerPairVector(outfile, binary, vec6);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    const char *token1 = "Hi";
    WriteToken(outfile, binary, token1);
    if (!binary) outfile << " \n";
    std::string token2 = "There.";
    WriteToken(outfile, binary, token2);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::string token3 = "You.";
    WriteToken(outfile, binary, token3);
    if (!binary && Rand()%2 == 0) outfile << " ";
    float f1 = RandUniform();
    WriteBasicType(outfile, binary, f1);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    float f2 = RandUniform();
    WriteBasicType(outfile, binary, f2);
    double d1 = RandUniform();
    WriteBasicType(outfile, binary, d1);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    double d2 = RandUniform();
    WriteBasicType(outfile, binary, d2);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    outfile.close();

    {
      std::ifstream infile(filename, std::ios_base::in | std::ios_base::binary);
      bool binary_in;
      InitKaldiInputStream(infile, &binary_in);
      int64 i1_in;
      ReadBasicType(infile, binary_in, &i1_in);
      KALDI_ASSERT(i1_in == i1);
      uint16 i2_in;
      ReadBasicType(infile, binary_in, &i2_in);
      KALDI_ASSERT(i2_in == i2);
      char c_in;
      ReadBasicType(infile, binary_in, &c_in);
      KALDI_ASSERT(c_in == c);
      std::vector<int32> vec1_in;
      ReadIntegerVector(infile, binary_in, &vec1_in);
      KALDI_ASSERT(vec1_in == vec1);
      std::vector<uint16> vec2_in;
      ReadIntegerVector(infile, binary_in, &vec2_in);
      KALDI_ASSERT(vec2_in == vec2);
      std::vector<char> vec3_in;
      ReadIntegerVector(infile, binary_in, &vec3_in);
      KALDI_ASSERT(vec3_in == vec3);
      std::vector<std::pair<int32, int32> > vec4_in;
      ReadIntegerPairVector(infile, binary_in, &vec4_in);
      KALDI_ASSERT(vec4_in == vec4);
      std::vector<std::pair<uint16, uint16> > vec5_in;
      ReadIntegerPairVector(infile, binary_in, &vec5_in);
      KALDI_ASSERT(vec5_in == vec5);
      std::vector<std::pair<char, char> > vec6_in;
      ReadIntegerPairVector(infile, binary_in, &vec6_in);
      KALDI_ASSERT(vec6_in == vec6);
      std::string  token1_in, token2_in;
      KALDI_ASSERT(Peek(infile, binary_in) == static_cast<int>(*token1));
      KALDI_ASSERT(PeekToken(infile, binary_in) == static_cast<int>(*token1));
      // Note:
      // the stuff with skipping over '<' is tested in ../util/kaldi-io-test.cc,
      // since we need to make sure it works with pipes.
      ReadToken(infile, binary_in, &token1_in);
      KALDI_ASSERT(token1_in == std::string(token1));
      ReadToken(infile, binary_in, &token2_in);
      KALDI_ASSERT(token2_in == std::string(token2));
      if (Rand() % 2 == 0)
        ExpectToken(infile, binary_in, token3.c_str());
      else
        ExpectToken(infile, binary_in, token3);
      float f1_in;  // same type.
      ReadBasicType(infile, binary_in, &f1_in);
      AssertEqual(f1_in, f1);
      double f2_in;  // wrong type.
      ReadBasicType(infile, binary_in, &f2_in);
      AssertEqual(f2_in, f2);
      double d1_in;  // same type.
      ReadBasicType(infile, binary_in, &d1_in);
      AssertEqual(d1_in, d1);
      float d2_in;  // wrong type.
      ReadBasicType(infile, binary_in, &d2_in);
      AssertEqual(d2_in, d2);
      KALDI_ASSERT(Peek(infile, binary_in) == -1);
      KALDI_ASSERT(PeekToken(infile, binary_in) == -1);
    }
    unlink(filename);
  }
}

UnitTestIo() [2/2]

static void kaldi::UnitTestIo ( )

static

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

References AssertEqual(), rnnlm::i, InitKaldiInputStream(), InitKaldiOutputStream(), KALDI_ERR, KALDI_LOG, Rand(), PackedMatrix< Real >::Read(), Vector< Real >::Read(), Matrix< Real >::Read(), SpMatrix< Real >::Resize(), Vector< Real >::Resize(), Matrix< Real >::Resize(), PackedMatrix< Real >::Scale(), MatrixBase< Real >::Scale(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), VectorBase< Real >::Write(), and MatrixBase< Real >::Write().

                                                 {

  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = Rand()%10 + 1;
    MatrixIndexT dimN = Rand()%10 + 1;
    bool binary = (i%2 == 0);

    if (i == 0) {
      dimM = 0;dimN = 0;  // test case when both are zero.
    }
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    Matrix<Real> N;
    Vector<Real> v1(dimM);
    v1.SetRandn();
    Vector<Real> v2(dimM);

    SpMatrix<Real> S(dimM);
    S.SetRandn();
    KALDI_LOG << "SpMatrix IO: " << S;
    SpMatrix<Real> T(dimM);

    {
      std::ofstream outs("tmpf", std::ios_base::out |std::ios_base::binary);
      InitKaldiOutputStream(outs, binary);
      M.Write(outs, binary);
      S.Write(outs, binary);
      v1.Write(outs, binary);
      M.Write(outs, binary);
      S.Write(outs, binary);
      v1.Write(outs, binary);
    }

    {
      bool binary_in;
      bool either_way = (i%2 == 0);
      std::ifstream ins("tmpf", std::ios_base::in | std::ios_base::binary);
      if (!InitKaldiInputStream(ins, &binary_in)) {
        KALDI_ERR << "Malformed input stream.";
      }
      N.Resize(0, 0);
      T.Resize(0);
      v2.Resize(0);
      N.Read(ins, binary_in, either_way);
      T.Read(ins, binary_in, either_way);
      v2.Read(ins, binary_in, either_way);
      if (i%2 == 0)
        ((MatrixBase<Real>&)N).Read(ins, binary_in, true);  // add
      else
        N.Read(ins, binary_in, true);
      T.Read(ins, binary_in, true);  // add
      if (i%2 == 0)
        ((VectorBase<Real>&)v2).Read(ins, binary_in, true);  // add
      else
        v2.Read(ins, binary_in, true);
    }
    N.Scale(0.5);
    v2.Scale(0.5);
    T.Scale(0.5);
    AssertEqual(M, N);
    AssertEqual(v1, v2);
    AssertEqual(S, T);
  }
}

UnitTestIoCross()

static void kaldi::UnitTestIoCross ( )

static

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

References AssertEqual(), MatrixBase< Real >::CopyFromMat(), SpMatrix< Real >::CopyFromSp(), VectorBase< Real >::CopyFromVec(), rnnlm::i, InitKaldiInputStream(), InitKaldiOutputStream(), KALDI_ERR, Rand(), PackedMatrix< Real >::Read(), Vector< Real >::Read(), Matrix< Real >::Read(), PackedMatrix< Real >::Scale(), MatrixBase< Real >::Scale(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), PackedMatrix< Real >::Write(), VectorBase< Real >::Write(), and MatrixBase< Real >::Write().

                                                      {  // across types.

  typedef typename OtherReal<Real>::Real Other;  // e.g. if Real == float, Other == double.
  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = Rand()%10 + 1;
    MatrixIndexT dimN = Rand()%10 + 1;
    bool binary = (i%2 == 0);
    if (i == 0) {
      dimM = 0;dimN = 0;  // test case when both are zero.
    }
    Matrix<Real> M(dimM, dimN);
    Matrix<Other> MO;
    M.SetRandn();
    Matrix<Real> N(dimM, dimN);
    Vector<Real> v(dimM);
    Vector<Other> vO;
    v.SetRandn();
    Vector<Real> w(dimM);

    SpMatrix<Real> S(dimM);
    SpMatrix<Other> SO;
    S.SetRandn();
    SpMatrix<Real> T(dimM);

    {
      std::ofstream outs("tmpf", std::ios_base::out |std::ios_base::binary);
      InitKaldiOutputStream(outs, binary);

      M.Write(outs, binary);
      S.Write(outs, binary);
      v.Write(outs, binary);
      M.Write(outs, binary);
      S.Write(outs, binary);
      v.Write(outs, binary);
    }
    {
      std::ifstream ins("tmpf", std::ios_base::in | std::ios_base::binary);
      bool binary_in;
      if (!InitKaldiInputStream(ins, &binary_in)) {
        KALDI_ERR << "Malformed input stream";
      }

      MO.Read(ins, binary_in);
      SO.Read(ins, binary_in);
      vO.Read(ins, binary_in);
      MO.Read(ins, binary_in, true);
      SO.Read(ins, binary_in, true);
      vO.Read(ins, binary_in, true);
      N.CopyFromMat(MO);
      T.CopyFromSp(SO);
      w.CopyFromVec(vO);
    }
    N.Scale(0.5);
    w.Scale(0.5);
    T.Scale(0.5);
    AssertEqual(M, N);
    AssertEqual(v, w);
    AssertEqual(S, T);
  }
}

UnitTestIoNew()

void kaldi::UnitTestIoNew

(

bool

binary

)

Definition at line 71 of file kaldi-io-test.cc.

References AssertEqual(), Output::Close(), ExpectToken(), rnnlm::i, KALDI_ASSERT, Peek(), Rand(), RandUniform(), ReadBasicType(), ReadIntegerVector(), ReadToken(), Output::Stream(), Input::Stream(), WriteBasicType(), WriteIntegerVector(), and WriteToken().

Referenced by main().

                                {
  {
    const char *filename = "tmpf";

    Output ko(filename, binary);
    std::ostream &outfile = ko.Stream();
    if (!binary) outfile << "\t";
    int64 i1 = Rand() % 10000;
    WriteBasicType(outfile, binary, i1);
    uint16 i2 = Rand() % 10000;
    WriteBasicType(outfile, binary, i2);
    if (!binary) outfile << "\t";
    char c = Rand();
    WriteBasicType(outfile, binary, c);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<int32> vec1;
    WriteIntegerVector(outfile, binary, vec1);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<uint16> vec2;
    for (size_t i = 0; i < 10; i++) vec2.push_back(Rand()%100 - 10);
    WriteIntegerVector(outfile, binary, vec2);
    if (!binary) outfile << " \n";
    std::vector<char> vec3;
    for (size_t i = 0; i < 10; i++) vec3.push_back(Rand()%100);
    WriteIntegerVector(outfile, binary, vec3);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    const char *token1 = "Hi";
    WriteToken(outfile, binary, token1);
    if (!binary) outfile << " \n";
    std::string token2 = "There.";
    WriteToken(outfile, binary, token2);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::string token3 = "You.";
    WriteToken(outfile, binary, token3);
    if (!binary && Rand()%2 == 0) outfile << " ";
    float f1 = RandUniform();
    WriteBasicType(outfile, binary, f1);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    float f2 = RandUniform();
    WriteBasicType(outfile, binary, f2);
    double d1 = RandUniform();
    WriteBasicType(outfile, binary, d1);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    double d2 = RandUniform();
    WriteBasicType(outfile, binary, d2);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    ko.Close();

    {
      bool binary_in;
      Input ki(filename, &binary_in);
      std::istream &infile = ki.Stream();
      int64 i1_in;
      ReadBasicType(infile, binary_in, &i1_in);
      KALDI_ASSERT(i1_in == i1);
      uint16 i2_in;
      ReadBasicType(infile, binary_in, &i2_in);
      KALDI_ASSERT(i2_in == i2);
      char c_in;
      ReadBasicType(infile, binary_in, &c_in);
      KALDI_ASSERT(c_in == c);
      std::vector<int32> vec1_in;
      ReadIntegerVector(infile, binary_in, &vec1_in);
      KALDI_ASSERT(vec1_in == vec1);
      std::vector<uint16> vec2_in;
      ReadIntegerVector(infile, binary_in, &vec2_in);
      KALDI_ASSERT(vec2_in == vec2);
      std::vector<char> vec3_in;
      ReadIntegerVector(infile, binary_in, &vec3_in);
      KALDI_ASSERT(vec3_in == vec3);
      std::string  token1_in, token2_in;
      KALDI_ASSERT(Peek(infile, binary_in) == static_cast<int>(*token1));
      ReadToken(infile, binary_in, &token1_in);
      KALDI_ASSERT(token1_in == (std::string)token1);
      ReadToken(infile, binary_in, &token2_in);
      KALDI_ASSERT(token2_in == token2);
      if (Rand() % 2 == 0)
        ExpectToken(infile, binary_in, token3.c_str());
      else
        ExpectToken(infile, binary_in, token3);
      float f1_in;  // same type.
      ReadBasicType(infile, binary_in, &f1_in);
      AssertEqual(f1_in, f1);
      double f2_in;  // wrong type.
      ReadBasicType(infile, binary_in, &f2_in);
      AssertEqual(f2_in, f2);
      double d1_in;  // same type.
      ReadBasicType(infile, binary_in, &d1_in);
      AssertEqual(d1_in, d1);
      float d2_in;  // wrong type.
      ReadBasicType(infile, binary_in, &d2_in);
      AssertEqual(d2_in, d2);
      KALDI_ASSERT(Peek(infile, binary_in) == -1);
    }
    unlink(filename);
  }
}

UnitTestIoPipe()

void kaldi::UnitTestIoPipe

(

bool

binary

)

Definition at line 169 of file kaldi-io-test.cc.

References AssertEqual(), Output::Close(), ExpectToken(), rnnlm::i, KALDI_ASSERT, Peek(), PeekToken(), Rand(), RandUniform(), ReadBasicType(), ReadIntegerVector(), ReadToken(), Sleep(), Output::Stream(), Input::Stream(), WriteBasicType(), WriteIntegerVector(), and WriteToken().

Referenced by main().

                                 {
  // This is as UnitTestIoNew except with different filenames.
  {
#if defined(_MSC_VER) && !defined(KALDI_CYGWIN_COMPAT)
    // self-invocation on Windows that emulates cat(1)
    const char *filename_out = "|kaldi-io-test cat > tmpf.gz",
        *filename_in = "kaldi-io-test cat tmpf.gz|";
#else
    const char *filename_out = "|gzip -c > tmpf.gz",
        *filename_in = "gunzip -c tmpf.gz |";
#endif

    Output ko(filename_out, binary);
    std::ostream &outfile = ko.Stream();
    if (!binary) outfile << "\t";
    int64 i1 = Rand() % 10000;
    WriteBasicType(outfile, binary, i1);
    uint16 i2 = Rand() % 10000;
    WriteBasicType(outfile, binary, i2);
    if (!binary) outfile << "\t";
    char c = Rand();
    WriteBasicType(outfile, binary, c);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<int32> vec1;
    WriteIntegerVector(outfile, binary, vec1);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::vector<uint16> vec2;
    for (size_t i = 0; i < 10; i++) vec2.push_back(Rand()%100 - 10);
    WriteIntegerVector(outfile, binary, vec2);
    if (!binary) outfile << " \n";
    WriteToken(outfile, binary, "<foo>");
    std::vector<char> vec3;
    for (size_t i = 0; i < 10; i++) vec3.push_back(Rand()%100);
    WriteIntegerVector(outfile, binary, vec3);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    const char *token1 = "Hi";
    WriteToken(outfile, binary, token1);
    if (!binary) outfile << " \n";
    std::string token2 = "There.";
    WriteToken(outfile, binary, token2);
    if (!binary && Rand()%2 == 0) outfile << " \n";
    std::string token3 = "You.";
    WriteToken(outfile, binary, token3);
    if (!binary && Rand()%2 == 0) outfile << " ";
    float f1 = RandUniform();
    WriteBasicType(outfile, binary, f1);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    float f2 = RandUniform();
    WriteBasicType(outfile, binary, f2);
    double d1 = RandUniform();
    WriteBasicType(outfile, binary, d1);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    double d2 = RandUniform();
    WriteBasicType(outfile, binary, d2);
    if (!binary && Rand()%2 == 0) outfile << "\t";
    bool ans = ko.Close();
    KALDI_ASSERT(ans);
#ifndef _MSC_VER
    Sleep(1);  // This test does not work without this sleep:
    // seems to be some kind of file-system latency.
#endif
    {
      bool binary_in;
      Input ki(filename_in, &binary_in);
      std::istream &infile = ki.Stream();
      int64 i1_in;
      ReadBasicType(infile, binary_in, &i1_in);
      KALDI_ASSERT(i1_in == i1);
      uint16 i2_in;
      ReadBasicType(infile, binary_in, &i2_in);
      KALDI_ASSERT(i2_in == i2);
      char c_in;
      ReadBasicType(infile, binary_in, &c_in);
      KALDI_ASSERT(c_in == c);
      std::vector<int32> vec1_in;
      ReadIntegerVector(infile, binary_in, &vec1_in);
      KALDI_ASSERT(vec1_in == vec1);
      std::vector<uint16> vec2_in;
      ReadIntegerVector(infile, binary_in, &vec2_in);
      KALDI_ASSERT(vec2_in == vec2);
      std::vector<char> vec3_in;
      KALDI_ASSERT(PeekToken(infile, binary_in) == static_cast<int>('f'));
      ExpectToken(infile, binary_in, "<foo>");
      ReadIntegerVector(infile, binary_in, &vec3_in);
      KALDI_ASSERT(vec3_in == vec3);
      std::string  token1_in, token2_in;
      KALDI_ASSERT(Peek(infile, binary_in) == static_cast<int>(*token1));
      ReadToken(infile, binary_in, &token1_in);
      KALDI_ASSERT(token1_in == (std::string)token1);
      ReadToken(infile, binary_in, &token2_in);
      KALDI_ASSERT(token2_in == token2);
      if (Rand() % 2 == 0)
        ExpectToken(infile, binary_in, token3.c_str());
      else
        ExpectToken(infile, binary_in, token3);
      float f1_in;  // same type.
      ReadBasicType(infile, binary_in, &f1_in);
      AssertEqual(f1_in, f1);
      double f2_in;  // wrong type.
      ReadBasicType(infile, binary_in, &f2_in);
      AssertEqual(f2_in, f2);
      double d1_in;  // same type.
      ReadBasicType(infile, binary_in, &d1_in);
      AssertEqual(d1_in, d1);
      float d2_in;  // wrong type.
      ReadBasicType(infile, binary_in, &d2_in);
      AssertEqual(d2_in, d2);
      KALDI_ASSERT(Peek(infile, binary_in) == -1);
    }
  }
  unlink("tmpf.txt");
  unlink("tmpf.gz");
}

UnitTestIoStandard()

void kaldi::UnitTestIoStandard

(

)

Definition at line 283 of file kaldi-io-test.cc.

References Output::Stream().

Referenced by main().

                          {
  /*
    Don't do the the following part because it requires
    to pipe from an empty file, for it to not hang.
  {
    Input inp("", NULL);  // standard input.
    KALDI_ASSERT(inp.Stream().get() == -1);
  }
  {
    Input inp("-", NULL);  // standard input.
    KALDI_ASSERT(inp.Stream().get() == -1);
    }*/

  {
    std::cout << "Should see: foo\n";
    Output out("", false);
    out.Stream() << "foo\n";
  }
  {
    std::cout << "Should see: bar\n";
    Output out("-", false);
    out.Stream() << "bar\n";
  }
}

UnitTestIvectorExtractor()

void kaldi::UnitTestIvectorExtractor

(

)

Definition at line 145 of file ivector-extractor-test.cc.

References IvectorExtractorStats::AccStatsForUtterance(), IvectorExtractorStats::AuxfPerFrame(), IvectorExtractorEstimationOptions::gaussian_min_count, kaldi::unittest::InitRandFullGmm(), IvectorExtractorOptions::ivector_dim, KALDI_ASSERT, KALDI_LOG, IvectorExtractorStatsOptions::num_samples_for_weights, Rand(), FullGmmNormal::Rand(), Matrix< Real >::Swap(), TestIvectorExtraction(), TestIvectorExtractorIO(), TestIvectorExtractorStatsIO(), IvectorExtractorStats::Update(), IvectorExtractorStatsOptions::update_variances, and IvectorExtractorOptions::use_weights.

Referenced by main().

                                {
  FullGmm fgmm;
  int32 dim = 5 + Rand() % 5, num_comp = 1 + Rand() % 5;
  KALDI_LOG << "Num Gauss = " << num_comp;
  unittest::InitRandFullGmm(dim, num_comp, &fgmm);
  FullGmmNormal fgmm_normal(fgmm);

  IvectorExtractorOptions ivector_opts;
  ivector_opts.ivector_dim = dim + 5;
  ivector_opts.use_weights = (Rand() % 2 == 0);
  KALDI_LOG << "Feature dim is " << dim
            << ", ivector dim is " << ivector_opts.ivector_dim;
  IvectorExtractor extractor(ivector_opts, fgmm);
  TestIvectorExtractorIO(extractor);

  IvectorExtractorStatsOptions stats_opts;
  if (Rand() % 2 == 0) stats_opts.update_variances = false;
  stats_opts.num_samples_for_weights = 100; // Improve accuracy
  // of estimation, since we do it with relatively few utterances,
  // and we're testing the convergence.

  int32 num_utts = 1 + Rand() % 5;
  std::vector<Matrix<BaseFloat> > all_feats(num_utts);
  for (int32 utt = 0; utt < num_utts; utt++) {
    int32 num_frames = 100 + Rand() % 200;
    if (Rand() % 2 == 0) num_frames *= 10;
    if (Rand() % 2 == 0) num_frames /= 1.0;
    Matrix<BaseFloat> feats(num_frames, dim);
    fgmm_normal.Rand(&feats);
    feats.Swap(&all_feats[utt]);
  }

  int32 num_iters = 4;
  double last_auxf_impr = 0.0, last_auxf = 0.0;
  for (int32 iter = 0; iter < num_iters; iter++) {
    IvectorExtractorStats stats(extractor, stats_opts);
      
    for (int32 utt = 0; utt < num_utts; utt++) {
      Matrix<BaseFloat> &feats = all_feats[utt];
      stats.AccStatsForUtterance(extractor, feats, fgmm);
      TestIvectorExtraction(extractor, feats, fgmm);
    }
    TestIvectorExtractorStatsIO(stats);
    
    IvectorExtractorEstimationOptions estimation_opts;
    estimation_opts.gaussian_min_count = dim + 5;
    double auxf = stats.AuxfPerFrame(),
        auxf_impr = stats.Update(estimation_opts, &extractor);

    KALDI_LOG << "Iter " << iter << ", auxf per frame was " << auxf
              << ", improvement in this update "
              << "phase was " << auxf_impr;
    if (iter > 0) {
      double auxf_change = auxf - last_auxf;
      KALDI_LOG << "Predicted auxf change from last update phase was "
                << last_auxf_impr << " versus observed change "
                << auxf_change;
      double wiggle_room = (ivector_opts.use_weights ? 5.0e-05 : 1.0e-08);
      // The weight update is (a) not exact, and (b) relies on sampling, [two
      // separate issues], so it might not always improve.  But with
      // a large number of "weight samples", it's OK.
      KALDI_ASSERT(auxf_change >= last_auxf_impr - wiggle_room);
    }
    last_auxf_impr = auxf_impr;
    last_auxf = auxf;
  }
  std::cout << "********************************************************************************************\n";
}

UnitTestKeele()

static void kaldi::UnitTestKeele ( )

static

Definition at line 366 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::nccf_ballast, WaveData::Read(), and MatrixBase< Real >::Write().

Referenced by UnitTestFeatWithKeele().

                            {
  KALDI_LOG << "=== UnitTestKeele() ===";
  for (int32 i = 1; i < 11; i++) {
    std::string wavefile;
    std::string num;
    if (i < 6) {
      num = "f" + ConvertIntToString(i) + "nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    } else {
      num = "m" + ConvertIntToString(i-5) + "nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    }
    KALDI_LOG << "--- " << wavefile << " ---";
    std::ifstream is(wavefile.c_str(), std::ios_base::binary);
    WaveData wave;
    wave.Read(is);
    KALDI_ASSERT(wave.Data().NumRows() == 1);
    SubVector<BaseFloat> waveform(wave.Data(), 0);
    // use pitch code with default configuration..
    PitchExtractionOptions op;
    op.nccf_ballast = 1;
    op.penalty_factor = 5;
    // compute pitch.
    Matrix<BaseFloat> m;
    ComputeKaldiPitch(op, waveform, &m);
    std::string outfile = "keele/tmp/+"+num+"-kaldi.txt";
    std::ofstream os(outfile.c_str());
    m.Write(os, false);
  }
}

UnitTestKeeleNccfBallast()

static void kaldi::UnitTestKeeleNccfBallast ( )

static

Definition at line 430 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::nccf_ballast, WaveData::Read(), and MatrixBase< Real >::Write().

Referenced by UnitTestFeatWithKeele().

                                       {
  KALDI_LOG << "=== UnitTestKeeleNccfBallast() ===";
  for (int32 k = 1; k < 10; k++) {
    for (int32 i = 1; i < 2; i++) {
      std::string wavefile;
      std::string num;
      if (i < 6) {
        num = "f"+ConvertIntToString(i)+"nw0000";
        wavefile = "keele/16kHz/"+num+".wav";
      } else {
        num = "m"+ConvertIntToString(i-5)+"nw0000";
        wavefile = "keele/16kHz/"+num+".wav";
      }
      KALDI_LOG << "--- " << wavefile << " ---";
      std::ifstream is(wavefile.c_str(), std::ios_base::binary);
      WaveData wave;
      wave.Read(is);
      KALDI_ASSERT(wave.Data().NumRows() == 1);
      SubVector<BaseFloat> waveform(wave.Data(), 0);
      // use pitch code with default configuration..
      PitchExtractionOptions op;
      op.nccf_ballast = 0.05 * k;
      KALDI_LOG << " nccf_ballast " << op.nccf_ballast;
      // compute pitch.
      Matrix<BaseFloat> m;
      ComputeKaldiPitch(op, waveform, &m);
      std::string nccfballast = ConvertIntToString(op.nccf_ballast);
      std::string outfile = "keele/tmp/+"+num
        +"-kaldi-nccf-ballast-"+nccfballast+".txt";
      std::ofstream os(outfile.c_str());
      m.Write(os, false);
    }
  }
}

UnitTestLbfgs()

static void kaldi::UnitTestLbfgs ( )

static

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

References VectorBase< Real >::AddSpVec(), VectorBase< Real >::AddVec(), OptimizeLbfgs< Real >::DoStep(), Exp(), g_kaldi_verbose_level, OptimizeLbfgs< Real >::GetProposedValue(), OptimizeLbfgs< Real >::GetValue(), SpMatrix< Real >::Invert(), KALDI_VLOG, LbfgsOptions::minimize, VectorBase< Real >::Norm(), Rand(), RandPosdefSpMatrix(), OptimizeLbfgs< Real >::RecentStepLength(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), VecSpVec(), and VecVec().

                                                    {
  MatrixIndexT temp = g_kaldi_verbose_level;
  g_kaldi_verbose_level = 4;
  for (MatrixIndexT iter = 0; iter < 3; iter++) {
    bool minimize = (iter % 2 == 0);
    MatrixIndexT dim = 1 + Rand() % 30;
    SpMatrix<Real> S(dim);
    RandPosdefSpMatrix(dim, &S);
    Vector<Real> v(dim);
    v.SetRandn();
    // Function will be f = exp(0.1 * [ x' v  -0.5 x' S x ])
    // This is to maximize; we negate it when minimizing.

    //Vector<Real> hessian(dim);
    //hessian.CopyDiagFromSp(S);

    SpMatrix<Real> Sinv(S);
    Sinv.Invert();
    Vector<Real> x_opt(dim);
    x_opt.AddSpVec(1.0, Sinv, v, 0.0); // S^{-1} v-- the optimum.

    Vector<Real> init_x(dim);
    init_x.SetRandn();

    LbfgsOptions opts;
    opts.minimize = minimize; // This objf has a maximum, not a minimum.
    OptimizeLbfgs<Real> opt_lbfgs(init_x, opts);
    MatrixIndexT num_iters = 0;
    Real c = 0.01;
    Real sign = (minimize ? -1.0 : 1.0); // function has a maximum not minimum..
    while (opt_lbfgs.RecentStepLength() > 1.0e-04) {
      KALDI_VLOG(2) << "Last step length is " << opt_lbfgs.RecentStepLength();
      const VectorBase<Real> &x = opt_lbfgs.GetProposedValue();
      Real logf = VecVec(x, v) - 0.5 * VecSpVec(x, S, x);
      Vector<Real> dlogf_dx(v); //  derivative of log(f) w.r.t. x.
      dlogf_dx.AddSpVec(-1.0, S, x, 1.0);
      KALDI_VLOG(2) << "Gradient magnitude is " << dlogf_dx.Norm(2.0);
      Real f = Exp(c * logf);
      Vector<Real> df_dx(dlogf_dx);
      df_dx.Scale(f * c); // comes from derivative of the exponential function.
      f *= sign;
      df_dx.Scale(sign);
      opt_lbfgs.DoStep(f, df_dx);
      num_iters++;
    }
    Vector<Real> x (opt_lbfgs.GetValue());
    Vector<Real> diff(x);
    diff.AddVec(-1.0, x_opt);
    KALDI_VLOG(2) << "L-BFGS finished after " << num_iters << " function evaluations.";
    /*
    if (sizeof(Real) == 8) {
      KALDI_ASSERT(diff.Norm(2.0) < 0.5);
    } else {
      KALDI_ASSERT(diff.Norm(2.0) < 2.0);
      } */
  }
  g_kaldi_verbose_level = temp;
}

UnitTestLimitCond()

static void kaldi::UnitTestLimitCond ( )

static

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

References rnnlm::i, KALDI_ASSERT, SpMatrix< Real >::LimitCond(), and Rand().

                                                         {
  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = 20 + Rand()%10;
    SpMatrix<Real> B(dimM);
    B(1, 1) = 10000;
    KALDI_ASSERT(B.LimitCond(1000) == (dimM-1));
    KALDI_ASSERT(std::abs(B(2, 2) - 10.0) < 0.01);
    KALDI_ASSERT(std::abs(B(3, 0)) < 0.001);
  }
}

UnitTestLimitCondInvert()

static void kaldi::UnitTestLimitCondInvert ( )

static

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

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatMat(), rnnlm::i, MatrixBase< Real >::IsUnit(), KALDI_ASSERT, kNoTrans, SpMatrix< Real >::LimitCond(), Rand(), and MatrixBase< Real >::SetRandn().

                                                               {
  for (MatrixIndexT i = 0;i < 10;i++) {
    MatrixIndexT dimM = 20 + Rand()%10;
    MatrixIndexT dimN = dimM + 1 + Rand()%10;

    SpMatrix<Real> B(dimM);
    Matrix<Real> X(dimM, dimN);
    X.SetRandn();
    B.AddMat2(1.0, X, kNoTrans, 0.0);  // B = X*X^T -> positive definite (almost certainly), since N > M.


    SpMatrix<Real> B2(B);
    B2.LimitCond(1.0e+10, true);  // Will invert.

    Matrix<Real> Bf(B), B2f(B2);
    Matrix<Real> I(dimM, dimM); I.AddMatMat(1.0, Bf, kNoTrans, B2f, kNoTrans, 0.0);
    KALDI_ASSERT(I.IsUnit(0.1));
  }
}

UnitTestLinearCgd()

static void kaldi::UnitTestLinearCgd ( )

static

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

References VectorBase< Real >::AddSpVec(), VectorBase< Real >::AddVec(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, LinearCgd(), LinearCgdOptions::max_error, LinearCgdOptions::max_iters, SpMatrix< Real >::MaxAbsEig(), VectorBase< Real >::Norm(), Rand(), RandPosdefSpMatrix(), and VectorBase< Real >::SetRandn().

                                                        {
  for (int i = 0; i < 20 ; i++) {
    MatrixIndexT M = 1 + Rand() % 20;

    SpMatrix<Real> A(M);
    RandPosdefSpMatrix(M, &A);
    Vector<Real> x(M), b(M), b2(M);

    LinearCgdOptions opts;
    if (Rand() % 2 == 0)
      opts.max_iters = 1 + Rand() % 10;
    if (Rand() % 2 == 0)
      opts.max_error = 1.0;  // note: an absolute, not relative, error.

    x.SetRandn();

    b.AddSpVec(1.0, A, x, 0.0);
    Vector<Real> x_e(M);  // x_e means x_estimated.
    x_e.SetRandn();

    int32 iters = LinearCgd(opts, A, b, &x_e);

    b2.AddSpVec(1.0, A, x_e, 0.0);

    Vector<Real> residual_error(b);
    residual_error.AddVec(-1.0, b2);

    BaseFloat error = residual_error.Norm(2.0);

    if (iters >= M) {
      // should have converged fully.
      Real max_abs = A.MaxAbsEig();
      KALDI_LOG << "error = " << error << ", b norm is " << b.Norm(2.0)
                << ", A max-abs-eig is " << max_abs;
      KALDI_ASSERT(error < 1.0e-04 * b.Norm(2.0) * max_abs);
    } else {
      BaseFloat wiggle_room = 1.1;
      if (opts.max_iters >= 0) {
        KALDI_ASSERT(iters <= opts.max_iters);
        if (iters < opts.max_iters) {
          KALDI_ASSERT(error <= wiggle_room * opts.max_error);
        }
      } else {
        KALDI_ASSERT(error <= wiggle_room * opts.max_error);
      }
    }
  }
}

UnitTestLogAddSub()

void kaldi::UnitTestLogAddSub

(

)

Definition at line 171 of file kaldi-math-test.cc.

References Exp(), rnnlm::i, KALDI_ASSERT, Log(), LogAdd(), LogSub(), and Rand().

Referenced by main().

                         {
  for (int i = 0; i < 100; i++) {
    double f1 = Rand() % 10000, f2 = Rand() % 20;
    double add1 = Exp(LogAdd(Log(f1), Log(f2)));
    double add2 = Exp(LogAdd(Log(f2), Log(f1)));
    double add = f1 + f2, thresh = add*0.00001;
    KALDI_ASSERT(std::abs(add-add1) < thresh && std::abs(add-add2) < thresh);


    try {
      double f2_check = Exp(LogSub(Log(add), Log(f1))),
             thresh = (f2*0.01)+0.001;
      KALDI_ASSERT(std::abs(f2_check-f2) < thresh);
    } catch(...) {
      KALDI_ASSERT(f2 == 0);  // It will probably crash for f2=0.
    }
  }
}

UnitTestLogSpeed()

void kaldi::UnitTestLogSpeed

(

)

Definition at line 297 of file kaldi-math-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, and Log().

                        {
  Real sum = 0.0;  // compute the sum to avoid optimizing it away.
  Real time = 0.01;  // how long this should last.
  int block_size = 10;
  int num_ops = 0;
  Timer tim;
  while (tim.Elapsed() < time) {
    for (int i = 0; i < block_size; i++) {
      sum += Log(static_cast<float>(i + 1));
    }
    num_ops += block_size;
  }
  KALDI_ASSERT(sum > 0.0);  // make it harder for the compiler to optimize Log
                            // away, as we have a conditional.
  Real flops = 1.0e-06 * num_ops / tim.Elapsed();
  KALDI_LOG << "Megaflops doing Log("
            << (sizeof(Real) == 4 ? "float" : "double") << ") is " << flops;
}

UnitTestLstmNonlinearity()

void kaldi::UnitTestLstmNonlinearity

(

)

Definition at line 213 of file cu-math-test.cc.

References CuMatrixBase< Real >::AddMat(), ApproxEqual(), kaldi::cu::BackpropLstmNonlinearity(), CuMatrixBase< Real >::ColRange(), kaldi::cu::ComputeLstmNonlinearity(), rnnlm::i, KALDI_ERR, KALDI_LOG, kTrans, RandInt(), CuMatrixBase< Real >::Row(), CuMatrixBase< Real >::Scale(), and TraceMatMat().

Referenced by CudaMathUnitTest().

                                {
  for (int32 loop = 0; loop < 10; loop++) {

    // problem dimensions.
    int32 num_rows = RandInt(5, 20),
          cell_dim = RandInt(2, 200),
        dropout_dim = (RandInt(0, 1) == 0 ? 0 : 3);

    // Pick the (input or params block), and output block, for which we'll
    // spot-check the derivative values.  This will give us test failures
    // that are fine-grained enough to assist debugging.
    int32 test_input = RandInt(0, 4),
        test_params = RandInt(0, 2),
        test_output = RandInt(0, 1);

    // set one of test_input or test_params to -1, meaning we're not testing that
    // thing.  only test one at a time.
    if (RandInt(0, 1) == 0)
      test_input = -1;
    else
      test_params = -1;


    CuMatrix<BaseFloat> input(num_rows, cell_dim * 5 + dropout_dim),
        params(3, cell_dim),
        output_deriv(num_rows, cell_dim * 2);
    input.SetRandn();
    params.SetRandn();
    // set just one block of the output deriv to a random value.
    output_deriv.ColRange(test_output * cell_dim, cell_dim).SetRandn();



    CuMatrix<BaseFloat> output(num_rows, cell_dim * 2);

    cu::ComputeLstmNonlinearity(input, params, &output);

    BaseFloat baseline_objf = TraceMatMat(output, output_deriv, kTrans);

    // not really testing self repair here... will debug it when we actually run
    // it, by looking at the diagnostics.
    CuMatrix<double> deriv_sum(5, cell_dim),
        value_sum(5, cell_dim);
    CuVector<BaseFloat> self_repair_config(10.0); // leave at zero... we don't really test this here.
    CuMatrix<BaseFloat>
        self_repair_sum(5, cell_dim),
        input_deriv(num_rows, 5 * cell_dim + dropout_dim),
        params_deriv(3, cell_dim);

    double count_in = 0.0;

    // get derivative w.r.t. input and params, which we are testing.
    cu::BackpropLstmNonlinearity(input, params, output_deriv, deriv_sum,
                                 self_repair_config, count_in,
                                 &input_deriv, &params_deriv,
                                 &value_sum, &deriv_sum, &self_repair_sum);


    int32 test_dim = 5;  // number of separate offsets we add while testing the
    // derivatives... reduces randomness in test.
    BaseFloat delta = 1.0e-03;
    Vector<BaseFloat> predicted_objf_change(test_dim),
        measured_objf_change(test_dim);

    for (int32 i = 0; i < test_dim; i++) {
      CuMatrix<BaseFloat> delta_input(num_rows, 5 * cell_dim + dropout_dim),
          delta_params(3, cell_dim);
      if (test_input >= 0) {
        delta_input.ColRange(test_input * cell_dim, cell_dim).SetRandn();
        delta_input.Scale(delta);
      }
      if (test_params >= 0) {
        delta_params.Row(test_params).SetRandn();
        delta_params.Scale(delta);
      }

      predicted_objf_change(i) = TraceMatMat(delta_input, input_deriv, kTrans) +
          TraceMatMat(delta_params, params_deriv, kTrans);

      CuMatrix<BaseFloat> perturbed_input(input);
      perturbed_input.AddMat(1.0, delta_input);

      CuMatrix<BaseFloat> perturbed_params(params);
      perturbed_params.AddMat(1.0, delta_params);

      CuMatrix<BaseFloat> perturbed_output(num_rows, 2 * cell_dim);
      cu::ComputeLstmNonlinearity(perturbed_input, perturbed_params,
                                  &perturbed_output);
      BaseFloat new_objf = TraceMatMat(perturbed_output, output_deriv, kTrans),
          objf_change = new_objf - baseline_objf;
      measured_objf_change(i) = objf_change;
    }
    KALDI_LOG << "LSTM nonlinearity test: num_rows=" << num_rows
              << ", cell_dim=" << cell_dim
              << ", dropout_dim=" << dropout_dim
              << ", test_input=" << test_input
              << ", test_params=" << test_params
              << ", test_output=" << test_output
              << ", predicted_objf_change=" << predicted_objf_change
              << ", measured_objf_change=" << measured_objf_change;

    if (!ApproxEqual(predicted_objf_change, measured_objf_change, BaseFloat(0.1F))) {
      KALDI_ERR << "LSTM nonlinearity test failed.";
    }
  }
}

UnitTestMat2Vec()

static void kaldi::UnitTestMat2Vec ( )

static

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

References SpMatrix< Real >::AddMat2(), SpMatrix< Real >::AddMat2Vec(), AssertEqual(), SpMatrix< Real >::CopyFromSp(), rnnlm::i, kNoTrans, kTrans, Rand(), PackedMatrix< Real >::Scale(), MatrixBase< Real >::SetRandn(), and SpMatrix< Real >::SymPosSemiDefEig().

                                                       {
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = 10 + Rand() % 10;

    Matrix<Real> M(dimM, dimM);
    M.SetRandn();
    SpMatrix<Real> B(dimM);
    B.AddMat2(1.0, M, kNoTrans, 0.0);  // B = M*M^T -> positive definite (since M nonsingular).

    Matrix<Real> P(dimM, dimM);
    Vector<Real> s(dimM);

    B.SymPosSemiDefEig(&s, &P);
    SpMatrix<Real> B2(dimM);
    B2.CopyFromSp(B);
    B2.Scale(0.25);

    // B2 <-- 2.0*B2 + 0.5 * P * diag(v)  * P^T
    B2.AddMat2Vec(0.5, P, kNoTrans, s, 2.0);  // 2.0 * 0.25 + 0.5 = 1.
    AssertEqual(B, B2);

    SpMatrix<Real> B3(dimM);
    Matrix<Real> PT(P, kTrans);
    B3.AddMat2Vec(1.0, PT, kTrans, s, 0.0);
    AssertEqual(B, B3);
  }
}

UnitTestMatrix()

static void kaldi::UnitTestMatrix ( )

static

Definition at line 338 of file cu-test.cc.

References CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, Rand(), MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                     {
  //operator()
  for (MatrixIndexT iter = 0; iter < 2; iter++) {
    int32 dim1 = 6 + Rand() % 10;
    int32 dim2 = 8 + Rand() % 10;
    Matrix<Real> A(dim1,dim2);
    A.SetRandn();
    CuMatrix<Real> B(A);
    KALDI_ASSERT(A(3, 4) == B(3, 4));
    B(3, 4) = 2.0;
    A(3, 4) = B(3, 4);
    KALDI_ASSERT(A(3, 4) == B(3, 4));

    SpMatrix<Real> As(dim1);
    CuSpMatrix<Real> Bs(As);
    KALDI_ASSERT(As(3, 4) == Bs(3, 4));
    Bs(3, 4) = 2.0;
    if (Rand() % 2 == 0)
      As(3, 4) = Bs(3, 4);
    else
      As(3, 4) = (const_cast<const CuSpMatrix<Real>&>(Bs))(3, 4);

    KALDI_ASSERT(As(3, 4) == Bs(3, 4));

    Vector<Real> v(dim1);
    CuVector<Real> w(v);
    KALDI_ASSERT(w(2) == v(2));
    w(2) = 3.0;
    v(2) = w(2);
    KALDI_ASSERT(w(2) == v(2));
  }

  //SetRandn
  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim1 = 15 + Rand() % 10;
    int32 dim2 = dim1;//10 + Rand() % 14;
    //KALDI_LOG << "dimension is " << dim1
    //          << " " << dim2 << '\n';
    CuMatrix<Real> A(dim1,dim2);
    A.SetRandn();
    Matrix<Real> A1(dim1,dim2);
    A.CopyToMat(&A1);
    //KALDI_LOG << "gpu sum is: " << A.Sum();
    //KALDI_LOG << "cpu sum is: " << A1.Sum();
  }
}

UnitTestMatrixAddMatSmat()

void kaldi::UnitTestMatrixAddMatSmat

(

)

Definition at line 229 of file sparse-matrix-test.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddMatSmat(), AssertEqual(), KALDI_ASSERT, kNoTrans, kTrans, rnnlm::n, RandInt(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), TraceMatMat(), and TraceMatSmat().

                                {

  for (int32 t = 0; t < 4; t++) {
    MatrixIndexT m = RandInt(10, 20), n = RandInt(10, 20), o = RandInt(10, 20);
    MatrixTransposeType Btrans = (RandInt(0, 1) == 0 ? kTrans : kNoTrans);

    // we are effectively comparing trace(A B C) computed as
    // trace((A B) C) vs. trace ((C A) B)

    BaseFloat alpha = 0.333, beta = 1.764;


    Matrix<Real> A(m, n);
    A.SetRandn();
    SparseMatrix<Real> B(Btrans  == kNoTrans ? n : o,
                         Btrans == kNoTrans ? o : n);
    B.SetRandn(0.5);

    Matrix<Real> AB(m, o);
    AB.SetRandn();  // this random extra part is used in testing the 'beta'.

    Matrix<Real> C(o, m);
    C.SetRandn();

    Matrix<Real> CA(o, n);
    CA.AddMatMat(1.0, C, kNoTrans, A, kNoTrans, 0.0);
    Real trace_abc_alpha = TraceMatSmat(CA, B, Btrans);

    Real trace_abc_beta = TraceMatMat(AB, C, kNoTrans);

    AB.AddMatSmat(alpha, A, B, Btrans, beta);

    // next line is in case I made certain mistakes like setting matrix to
    // random.
    KALDI_ASSERT(trace_abc_alpha != 0.0 && trace_abc_beta != 0.0);
    Real result1 = TraceMatMat(AB, C, kNoTrans),
        result2 = alpha * trace_abc_alpha  + beta * trace_abc_beta;
    AssertEqual(result1, result2, 0.01);
  }
}

UnitTestMatrixAddSmatMat()

void kaldi::UnitTestMatrixAddSmatMat

(

)

Definition at line 272 of file sparse-matrix-test.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddSmatMat(), AssertEqual(), KALDI_ASSERT, kNoTrans, kTrans, rnnlm::n, RandInt(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), TraceMatMat(), and TraceMatSmat().

                                {

  for (int32 t = 0; t < 4; t++) {
    MatrixIndexT m = RandInt(10, 20), n = RandInt(10, 20), o = RandInt(10, 20);
    MatrixTransposeType Btrans = (RandInt(0, 1) == 0 ? kTrans : kNoTrans);

    // we are effectively comparing trace(A B C) computed as
    // trace((A B) C) vs. trace ((C A) B)

    BaseFloat alpha = 0.333, beta = 1.764;

    Matrix<Real> A(m, n);
    A.SetRandn();
    SparseMatrix<Real> B(Btrans  == kNoTrans ? n : o,
                         Btrans == kNoTrans ? o : n);
    B.SetRandn(0.5);

    Matrix<Real> C(o, m);
    C.SetRandn();

    Matrix<Real> BC(n, m);
    BC.SetRandn();  // this random extra part is used in testing the 'beta'.

    Matrix<Real> CA(o, n);
    CA.AddMatMat(1.0, C, kNoTrans, A, kNoTrans, 0.0);
    Real trace_abc_alpha = TraceMatSmat(CA, B, Btrans);

    Real trace_abc_beta = TraceMatMat(A, BC, kNoTrans);

    BC.AddSmatMat(alpha, B, Btrans, C, beta);

    // next line is in case I made certain mistakes like setting matrix to
    // random.
    KALDI_ASSERT(trace_abc_alpha != 0.0 && trace_abc_beta != 0.0);
    Real result1 = TraceMatMat(A, BC, kNoTrans),
        result2 = alpha * trace_abc_alpha  + beta * trace_abc_beta;
    AssertEqual(result1, result2, 0.01);
  }
}

UnitTestMax2()

static void kaldi::UnitTestMax2 ( )

static

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

References AssertEqual(), MatrixBase< Real >::CopyFromMat(), rnnlm::i, MatrixBase< Real >::Max(), and Rand().

                                                   {
  for (MatrixIndexT i = 0; i < 2; i++) {
    MatrixIndexT M = 1 + Rand() % 10, N = 1 + Rand() % 10;
    Matrix<Real> A(M, N), B(M, N), C(M, N), D(M, N);
    A.SetRandn();
    B.SetRandn();
    for (MatrixIndexT r = 0; r < M; r++)
      for (MatrixIndexT c = 0; c < N; c++)
        C(r, c) = std::max(A(r, c), B(r, c));
    D.CopyFromMat(A);
    D.Max(B);
    AssertEqual(C, D);
  }
}

UnitTestMaxAbsEig()

static void kaldi::UnitTestMaxAbsEig ( )

static

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

References AssertEqual(), SpMatrix< Real >::Eig(), rnnlm::i, VectorBase< Real >::Max(), SpMatrix< Real >::MaxAbsEig(), VectorBase< Real >::Min(), and PackedMatrix< Real >::SetRandn().

                                                        {
  for (MatrixIndexT i = 0; i < 1; i++) {
    SpMatrix<Real> M(10);
    M.SetRandn();
    Matrix<Real> P(10, 10);
    Vector<Real> s(10);
    M.Eig(&s, (i == 0 ? static_cast<Matrix<Real>*>(NULL) : &P));
    Real max_eig = std::max(-s.Min(), s.Max());
    AssertEqual(max_eig, M.MaxAbsEig());
  }
}

UnitTestMaxMin()

static void kaldi::UnitTestMaxMin ( )

static

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

References AssertEqual(), rnnlm::i, rnnlm::j, PackedMatrix< Real >::Max(), MatrixBase< Real >::Max(), VectorBase< Real >::Max(), PackedMatrix< Real >::Min(), MatrixBase< Real >::Min(), VectorBase< Real >::Min(), Rand(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                                     {

  MatrixIndexT M = 1 + Rand() % 10, N = 1 + Rand() % 10;
  {
    Vector<Real> v(N);
    v.SetRandn();
    Real min = 1.0e+10, max = -1.0e+10;
    for (MatrixIndexT i = 0; i< N; i++) {
      min = std::min(min, v(i));
      max = std::max(max, v(i));
    }
    AssertEqual(min, v.Min());
    AssertEqual(max, v.Max());
  }
  {
    SpMatrix<Real> S(N);
    S.SetRandn();
    Real min = 1.0e+10, max = -1.0e+10;
    for (MatrixIndexT i = 0; i< N; i++) {
      for (MatrixIndexT j = 0; j <= i; j++) {
        min = std::min(min, S(i, j));
        max = std::max(max, S(i, j));
      }
    }
    AssertEqual(min, S.Min());
    AssertEqual(max, S.Max());
  }
  {
    Matrix<Real> mat(M, N);
    mat.SetRandn();
    Real min = 1.0e+10, max = -1.0e+10;
    for (MatrixIndexT i = 0; i< M; i++) {
      for (MatrixIndexT j = 0; j < N; j++) {
        min = std::min(min, mat(i, j));
        max = std::max(max, mat(i, j));
      }
    }
    AssertEqual(min, mat.Min());
    AssertEqual(max, mat.Max());
  }
}

UnitTestMmul()

static void kaldi::UnitTestMmul ( )

static

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

References MatrixBase< Real >::AddMatMat(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kNoTrans, and Rand().

                                                   {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 20 + Rand()%10, dimN = 20 + Rand()%10, dimO = 20 + Rand()%10;  // dims between 10 and 20.
    // MatrixIndexT dimM = 2, dimN = 3, dimO = 4;
    Matrix<Real> A(dimM, dimN), B(dimN, dimO), C(dimM, dimO);
    A.SetRandn();
    B.SetRandn();
    //
    // KALDI_LOG <<"a = " << A;
    // KALDI_LOG<<"B = " << B;
    C.AddMatMat(1.0, A, kNoTrans, B, kNoTrans, 0.0);  // C = A * B.
    //     KALDI_LOG << "c = " << C;
    for (MatrixIndexT i = 0;i < dimM;i++) {
      for (MatrixIndexT j = 0;j < dimO;j++) {
        double sum = 0.0;
        for (MatrixIndexT k = 0;k < dimN;k++) {
          sum += A(i, k) * B(k, j);
        }
        KALDI_ASSERT(std::abs(sum - C(i, j)) < 0.0001);
      }
    }
  }
}

UnitTestMmulSym()

static void kaldi::UnitTestMmulSym ( )

static

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

References MatrixBase< Real >::AddSpSp(), AssertEqual(), kNoTrans, kTrans, and Rand().

                                                      {

  // Test matrix multiplication on symmetric matrices.
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 20 + Rand()%10;

    Matrix<Real> A(dimM, dimM), B(dimM, dimM), C(dimM, dimM), tmp(dimM, dimM), tmp2(dimM, dimM);
    SpMatrix<Real> sA(dimM), sB(dimM), sC(dimM), stmp(dimM);

    A.SetRandn();
    B.SetRandn();
    C.SetRandn();
    // Make A, B, C symmetric.
    tmp.CopyFromMat(A); A.AddMat(1.0, tmp, kTrans);
    tmp.CopyFromMat(B); B.AddMat(1.0, tmp, kTrans);
    tmp.CopyFromMat(C); C.AddMat(1.0, tmp, kTrans);

    sA.CopyFromMat(A);
    sB.CopyFromMat(B);
    sC.CopyFromMat(C);


    tmp.AddMatMat(1.0, A, kNoTrans, B, kNoTrans, 0.0);  // tmp = A * B.
    tmp2.AddSpSp(1.0, sA, sB, 0.0);  // tmp = sA*sB.
    AssertEqual(tmp, tmp2);
    tmp2.AddSpSp(1.0, sA, sB, 0.0);  // tmp = sA*sB.
    AssertEqual(tmp, tmp2);
  }
}

UnitTestMul()

static void kaldi::UnitTestMul ( )

static

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

References VectorBase< Real >::AddMatVec(), VectorBase< Real >::AddSpVec(), VectorBase< Real >::AddTpVec(), AssertEqual(), MatrixBase< Real >::CopyFromTp(), rnnlm::i, kNoTrans, kTrans, Rand(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                                  {
  for (MatrixIndexT x = 0; x<=1; x++) {
    MatrixTransposeType trans = (x == 1 ? kTrans: kNoTrans);
    for (MatrixIndexT i = 0;i < 5;i++) {
      float alpha = 1.0, beta =0;
      if (i%3 == 0) beta = 0.5;
      if (i%5 == 0) alpha = 0.7;
      MatrixIndexT dimM = (Rand()%10) + 10;
      Vector<Real> v(dimM);
      v.SetRandn();
      TpMatrix<Real> T(dimM);
      T.SetRandn();
      Matrix<Real> M(dimM, dimM);
      if (i%2 == 1)
        M.CopyFromTp(T, trans);
      else
        M.CopyFromTp(T, kNoTrans);
      Vector<Real> v2(v);
      Vector<Real> v3(v);
      v2.AddTpVec(alpha, T, trans, v, beta);
      if (i%2 == 1)
        v3.AddMatVec(alpha, M, kNoTrans, v, beta);
      else
        v3.AddMatVec(alpha, M, trans, v, beta);

      v.AddTpVec(alpha, T, trans, v, beta);
      AssertEqual(v2, v3);
      AssertEqual(v, v2);
    }

    for (MatrixIndexT i = 0;i < 5;i++) {
      float alpha = 1.0, beta =0;
      if (i%3 == 0) beta = 0.5;
      if (i%5 == 0) alpha = 0.7;

      MatrixIndexT dimM = (Rand()%10) + 10;
      Vector<Real> v(dimM);
      v.SetRandn();
      SpMatrix<Real> T(dimM);
      T.SetRandn();
      Matrix<Real> M(T);
      Vector<Real> v2(dimM);
      Vector<Real> v3(dimM);
      v2.AddSpVec(alpha, T, v, beta);
      v3.AddMatVec(alpha, M, i%2 ? kNoTrans : kTrans, v, beta);
      AssertEqual(v2, v3);
    }
  }
}

UnitTestMulElements()

static void kaldi::UnitTestMulElements ( )

static

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

References MatrixBase< Real >::CopyFromMat(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::MulElements(), and Rand().

                                                          {
  for (MatrixIndexT iter = 0; iter < 5; iter++) {
    MatrixIndexT dimM = 20 + Rand()%10, dimN = 20 + Rand()%10;
    Matrix<Real> A(dimM, dimN), B(dimM, dimN), C(dimM, dimN);
    A.SetRandn();
    B.SetRandn();

    C.CopyFromMat(A);
    C.MulElements(B);  // C = A .* B (in Matlab, for example).

    for (MatrixIndexT i = 0;i < dimM;i++)
      for (MatrixIndexT j = 0;j < dimN;j++)
        KALDI_ASSERT(std::abs(C(i, j) - (A(i, j)*B(i, j))) < 0.0001);
  }
}

UnitTestMulTp()

static void kaldi::UnitTestMulTp ( )

static

Definition at line 385 of file cu-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyToVec(), kNoTrans, kTrans, CuVectorBase< Real >::MulTp(), VectorBase< Real >::MulTp(), Rand(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                                    {
  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 1 + Rand() % 30;
    Vector<Real> v(dim);
    v.SetRandn();
    TpMatrix<Real> M(dim);
    M.SetRandn();
    CuVector<Real> cv(v);
    CuTpMatrix<Real> cM(M);

    Vector<Real> v2(dim);
    cv.CopyToVec(&v2);
    AssertEqual(v, v2);
    v.MulTp(M, iter % 2 == 0 ? kTrans:kNoTrans);
    cv.MulTp(cM, iter % 2 == 0 ? kTrans:kNoTrans);
    cv.CopyToVec(&v2);
    // KALDI_LOG << "v is " << v << ", v2 is " << v2;
    AssertEqual(v, v2);
  }
}

UnitTestNativeFilename()

void kaldi::UnitTestNativeFilename

(

)

Definition at line 309 of file kaldi-io-test.cc.

References KALDI_ASSERT, and MapCygwinPath().

Referenced by main().

                              {
#ifdef KALDI_CYGWIN_COMPAT
  extern std::string MapCygwinPath(const std::string &filename);

  KALDI_ASSERT(MapCygwinPath("") == "");
  KALDI_ASSERT(MapCygwinPath(".") == ".");
  KALDI_ASSERT(MapCygwinPath("..") == "..");
  KALDI_ASSERT(MapCygwinPath("/dev/null")[0] != '/');
  KALDI_ASSERT(MapCygwinPath("/tmp")[1] == ':');
  KALDI_ASSERT(MapCygwinPath("/tmp/")[1] == ':');
  KALDI_ASSERT(MapCygwinPath("/tmp/foo")[1] == ':');
  KALDI_ASSERT(MapCygwinPath("/cygdrive/c") == "c:/");
  KALDI_ASSERT(MapCygwinPath("/cygdrive/c/") == "c:/");
  KALDI_ASSERT(MapCygwinPath("/cygdrive/c/foo") == "c:/foo");
#endif
}

UnitTestNonsymmetricPower()

void kaldi::UnitTestNonsymmetricPower

(

)

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

References MatrixBase< Real >::AddMatMat(), AssertEqual(), InitRandNonsingular(), MatrixBase< Real >::Invert(), KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kNoTrans, MatrixBase< Real >::Power(), Rand(), and MatrixBase< Real >::SetRandn().

                                 {

  for (MatrixIndexT iter = 0; iter < 30; iter++) {
    MatrixIndexT dimM = 1 + Rand() % 20;
    Matrix<Real> M(dimM, dimM);
    M.SetRandn();

    Matrix<Real> MM(dimM, dimM);
    MM.AddMatMat(1.0, M, kNoTrans, M, kNoTrans, 0.0);  // MM = M M.
    Matrix<Real> MMMM(dimM, dimM);
    MMMM.AddMatMat(1.0, MM, kNoTrans, MM, kNoTrans, 0.0);

    Matrix<Real> MM2(MM);
    bool b = MM2.Power(1.0);
    KALDI_ASSERT(b);
    AssertEqual(MM2, MM);
    Matrix<Real> MMMM2(MM);
    b = MMMM2.Power(2.0);
    KALDI_ASSERT(b);
    AssertEqual(MMMM2, MMMM);
  }
  for (MatrixIndexT iter = 0; iter < 30; iter++) {
    MatrixIndexT dimM = 1 + Rand() % 20;
    Matrix<Real> M(dimM, dimM);
    InitRandNonsingular(&M);

    Matrix<Real> MM(dimM, dimM);
    MM.AddMatMat(1.0, M, kNoTrans, M, kNoTrans, 0.0);  // MM = M M.
    // This ensures there are no real, negative eigenvalues.

    Matrix<Real> MMMM(dimM, dimM);
    MMMM.AddMatMat(1.0, MM, kNoTrans, MM, kNoTrans, 0.0);

    Matrix<Real> MM2(M);
    if (!MM2.Power(2.0)) {  // possibly had negative eigenvalues
      KALDI_LOG << "Could not take matrix to power (not an error)";
    } else {
      AssertEqual(MM2, MM);
    }
    Matrix<Real> MMMM2(M);
    if (!MMMM2.Power(4.0)) {  // possibly had negative eigenvalues
      KALDI_LOG << "Could not take matrix to power (not an error)";
    } else {
      AssertEqual(MMMM2, MMMM);
    }
    Matrix<Real> MMMM3(MM);
    if (!MMMM3.Power(2.0)) {
      KALDI_ERR << "Could not take matrix to power (should have been able to)";
    } else {
      AssertEqual(MMMM3, MMMM);
    }

    Matrix<Real> MM4(MM);
    if (!MM4.Power(-1.0))
      KALDI_ERR << "Could not take matrix to power (should have been able to)";
    MM4.Invert();
    AssertEqual(MM4, MM);
  }
}

UnitTestNorm()

static void kaldi::UnitTestNorm ( )

static

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

References VectorBase< Real >::ApproxEqual(), ApproxEqual(), SpMatrix< Real >::ApproxEqual(), MatrixBase< Real >::ApproxEqual(), SpMatrix< Real >::FrobeniusNorm(), MatrixBase< Real >::FrobeniusNorm(), KALDI_ASSERT, VectorBase< Real >::Norm(), Rand(), RandGauss(), PackedMatrix< Real >::Scale(), MatrixBase< Real >::Scale(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                           {  // test some simple norm properties: scaling.  also ApproxEqual test.

  for (MatrixIndexT p = 0; p < 10; p++) {
    Real scalar = RandGauss();
    if (scalar == 0.0) continue;
    if (scalar < 0) scalar *= -1.0;
    MatrixIndexT dimM = 10 + Rand() % 10, dimN = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    SpMatrix<Real> S(dimM);
    S.SetRandn();
    Vector<Real> V(dimN);
    V.SetRandn();

    Real Mnorm = M.FrobeniusNorm(),
        Snorm = S.FrobeniusNorm(),
        Vnorm1 = V.Norm(1.0),
        Vnorm2 = V.Norm(2.0),
        Vnorm3 = V.Norm(3.0);
    M.Scale(scalar);
    S.Scale(scalar);
    V.Scale(scalar);
    KALDI_ASSERT(ApproxEqual(M.FrobeniusNorm(), Mnorm*scalar));
    KALDI_ASSERT(ApproxEqual(S.FrobeniusNorm(), Snorm*scalar));
    KALDI_ASSERT(ApproxEqual(V.Norm(1.0), Vnorm1 * scalar));
    KALDI_ASSERT(ApproxEqual(V.Norm(2.0), Vnorm2 * scalar));
    KALDI_ASSERT(ApproxEqual(V.Norm(3.0), Vnorm3 * scalar));

    KALDI_ASSERT(V.ApproxEqual(V));
    KALDI_ASSERT(M.ApproxEqual(M));
    KALDI_ASSERT(S.ApproxEqual(S));
    SpMatrix<Real> S2(S); S2.Scale(1.1);  KALDI_ASSERT(!S.ApproxEqual(S2));  KALDI_ASSERT(S.ApproxEqual(S2, 0.15));
    Matrix<Real> M2(M); M2.Scale(1.1);  KALDI_ASSERT(!M.ApproxEqual(M2));  KALDI_ASSERT(M.ApproxEqual(M2, 0.15));
    Vector<Real> V2(V); V2.Scale(1.1);  KALDI_ASSERT(!V.ApproxEqual(V2));  KALDI_ASSERT(V.ApproxEqual(V2, 0.15));
  }
}

UnitTestOnlineCmvn()

void kaldi::UnitTestOnlineCmvn

(

)

Definition at line 32 of file feature-functions-test.cc.

References SlidingWindowCmnOptions::center, SlidingWindowCmnOptions::cmn_window, rnnlm::d, rnnlm::i, KALDI_ERR, SlidingWindowCmnOptions::min_window, SlidingWindowCmnOptions::normalize_variance, Rand(), and SlidingWindowCmn().

Referenced by main().

                          {
  for (int32 i = 0; i < 1000; i++) {
    int32 num_frames = 1 + (Rand() % 10 * 10);
    int32 dim = 1 + Rand() % 10;
    SlidingWindowCmnOptions opts;
    opts.center = (Rand() % 2 == 0);
    opts.normalize_variance = (Rand() % 2 == 0);
    opts.cmn_window = 5 + Rand() % 50;
    opts.min_window = 1 + Rand() % 100;
    if (opts.min_window > opts.cmn_window)
      opts.min_window = opts.cmn_window;

    Matrix<BaseFloat> feats(num_frames, dim),
        output_feats(num_frames, dim),
        output_feats2(num_frames, dim);
    feats.SetRandn();
    SlidingWindowCmn(opts, feats, &output_feats);

    for (int32 t = 0; t < num_frames; t++) {
      int32 window_begin, window_end;
      if (opts.center) {
        window_begin = t - (opts.cmn_window / 2),
            window_end = window_begin + opts.cmn_window;
        int32 shift = 0;
        if (window_begin < 0)
          shift = -window_begin;
        else if (window_end > num_frames)
          shift = num_frames - window_end;
        window_end += shift;
        window_begin += shift;
      } else {
        window_begin = t - opts.cmn_window;
        window_end = t + 1;
        if (window_end < opts.min_window)
            window_end = opts.min_window;
      }
      if (window_begin < 0) window_begin = 0;
      if (window_end > num_frames) window_end = num_frames;
      int32 window_size = window_end - window_begin;
      for (int32 d = 0; d < dim; d++) {
        double sum = 0.0, sumsq = 0.0;
        for (int32 t2 = window_begin; t2 < window_end; t2++) {
          sum += feats(t2, d);
          sumsq += feats(t2, d) * feats(t2, d);
        }
        double mean = sum / window_size, uncentered_covar = sumsq / window_size,
            covar = uncentered_covar - mean * mean;
        covar = std::max(covar, 1.0e-20);
        double data = feats(t, d),
            norm_data = data - mean;
        if (opts.normalize_variance) {
          if (window_size == 1) norm_data = 0.0;
          else norm_data /= sqrt(covar);
        }
        output_feats2(t, d) = norm_data;
      }
    }
    if (! output_feats.ApproxEqual(output_feats2, 0.0001)) {
      KALDI_ERR << "Features differ " << output_feats << " vs. " << output_feats2;
    }
  }
}

UnitTestOrthogonalizeRows()

static void kaldi::UnitTestOrthogonalizeRows ( )

static

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

References MatrixBase< Real >::AddMatMat(), rnnlm::i, MatrixBase< Real >::IsUnit(), KALDI_ASSERT, kNoTrans, kTrans, Rand(), and MatrixBase< Real >::SetRandn().

                                        {
  for (MatrixIndexT iter = 0; iter < 100; iter++) {
    MatrixIndexT dimM = 4 + Rand() % 5, dimN = dimM + (Rand() % 2);
    Matrix<Real> M(dimM, dimN);
    for (MatrixIndexT i = 0; i < dimM; i++) {
      if (Rand() % 5 != 0) M.Row(i).SetRandn();
    }
    if (Rand() % 2 != 0) { // Multiply by a random square matrix;
      // keeps it low rank but will be correlated.  Harder
      // test case.
      Matrix<Real> N(dimM, dimM);
      N.SetRandn();
      Matrix<Real> tmp(dimM, dimN);
      tmp.AddMatMat(1.0, N, kNoTrans, M, kNoTrans, 0.0);
      M.CopyFromMat(tmp);
    }
    M.OrthogonalizeRows();
    Matrix<Real> I(dimM, dimM);
    I.AddMatMat(1.0, M, kNoTrans, M, kTrans, 0.0);
    KALDI_ASSERT(I.IsUnit(1.0e-05));
  }
}

UnitTestParseOptions()

void kaldi::UnitTestParseOptions

(

)

Definition at line 46 of file parse-options-test.cc.

References ParseOptions::GetArg(), KALDI_ASSERT, KALDI_LOG, DummyOptions::my_bool, DummyOptions::my_string, ParseOptions::NumArgs(), ParseOptions::PrintUsage(), ParseOptions::Read(), DummyOptions::Register(), and ParseOptions::Register().

Referenced by main().

                            {
  int argc = 7;
  std::string str="default_for_str";
  int32 num = 1;
  uint32 unum = 2;
  const char *argv[7] = { "program_name", "--unum=5", "--num=3", "--i=boo",
    "a", "b", "c" };
  ParseOptions po("my usage msg");
  po.Register("i", &str, "My variable");
  po.Register("num", &num, "My int32 variable");
  po.Register("unum", &unum, "My uint32 variable");
  po.Read(argc, argv);
  KALDI_ASSERT(po.NumArgs() == 3);
  KALDI_ASSERT(po.GetArg(1) == "a");
  KALDI_ASSERT(po.GetArg(2) == "b");
  KALDI_ASSERT(po.GetArg(3) == "c");
  KALDI_ASSERT(unum == 5);
  KALDI_ASSERT(num == 3);
  KALDI_ASSERT(str == "boo");

  ParseOptions po2("my another msg");
  int argc2 = 4;
  const char *argv2[4] = { "program_name", "--i=foo",
    "--to-be-NORMALIZED=test", "c" };
  std::string str2 = "default_for_str2";
  po2.Register("To_Be_Normalized", &str2,
               "My variable (name has to be normalized)");
  po2.Register("i", &str, "My variable");
  po2.Read(argc2, argv2);
  KALDI_ASSERT(po2.NumArgs() == 1);
  KALDI_ASSERT(po2.GetArg(1) == "c");
  KALDI_ASSERT(str2 == "test");
  KALDI_ASSERT(str == "foo");

  ParseOptions po3("now checking options with prefix");
  ParseOptions ro3("prefix", &po3);  // to register with prefix
  ParseOptions so3("prefix2", &ro3);  // to register with prefix, recursively.
  DummyOptions dummy_opts;
  po3.Register("str", &str, "My string variable");
  po3.Register("num", &num, "My int32 variable");
  // Now register with prefix
  ro3.Register("unum", &unum, "My uint32 variable");
  ro3.Register("str", &str2, "My other string variable");
  uint32 unum2 = 0;
  so3.Register("unum", &unum2, "Another uint32 variable");

  int argc3 = 10;
  const char *argv3[10] = {
    "program_name", "--prefix.unum=5", "--num=3",
    "--prefix.str=foo", "--str=bar", "--prefix.my-bool=false",
    "--prefix.my-str=baz", "--prefix.prefix2.unum=42", "a", "b" };

  dummy_opts.Register(&ro3);
  po3.PrintUsage(false);

  po3.Read(argc3, argv3);
  KALDI_ASSERT(po3.NumArgs() == 2);
  KALDI_ASSERT(po3.GetArg(1) == "a");
  KALDI_ASSERT(po3.GetArg(2) == "b");
  KALDI_ASSERT(unum == 5);
  KALDI_ASSERT(unum2 == 42);
  KALDI_ASSERT(num == 3);
  KALDI_ASSERT(str2 == "foo");
  KALDI_ASSERT(str == "bar");
  KALDI_ASSERT(dummy_opts.my_bool == false);
  KALDI_ASSERT(dummy_opts.my_string == "baz");


  try {   // test error with --option=, which is not a valid way to set
          // boolean options.
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option="};
    ParseOptions po4("my usage msg");
    bool val = false;
    po4.Register("option", &val, "My boolean");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }

  { // test that --option sets "option" to true, if bool.
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option"};
    ParseOptions po4("my usage msg");
    bool val = false;
    po4.Register("option", &val, "My boolean");
    po4.Read(argc4, argv4);
    KALDI_ASSERT(val == true);
  }


  try {   // test error with --option, which is not a valid way to set
          // string-valued options.
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option"};
    ParseOptions po4("my usage msg");
    std::string val;
    po4.Register("option", &val, "My string");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }

  { // test that --option= sets "option" to empty, if string.
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option="};
    ParseOptions po4("my usage msg");
    std::string val = "foo";
    po4.Register("option", &val, "My boolean");
    po4.Read(argc4, argv4);
    KALDI_ASSERT(val.empty());
  }

  { // integer options test
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=8"};
    ParseOptions po4("my usage msg");
    int32 val = 32;
    po4.Register("option", &val, "My int");
    po4.Read(argc4, argv4);
    KALDI_ASSERT(val == 8);
  }

  { // float
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=8.5"};
    ParseOptions po4("my usage msg");
    BaseFloat val = 32.0;
    po4.Register("option", &val, "My float");
    po4.Read(argc4, argv4);
    KALDI_ASSERT(val == 8.5);
  }
  { // string options test
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=bar"};
    ParseOptions po4("my usage msg");
    std::string val = "foo";
    po4.Register("option", &val, "My string");
    po4.Read(argc4, argv4);
    KALDI_ASSERT(val == "bar");
  }
  
  try {   // test error with --float=string
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=foo"};
    ParseOptions po4("my usage msg");
    BaseFloat val = 32.0;
    po4.Register("option", &val, "My float");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }


  try {   // test error with --int=string
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=foo"};
    ParseOptions po4("my usage msg");
    int32 val = 32;
    po4.Register("option", &val, "My int");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }

  try {   // test error with --int=int+garbage
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=12xyz"};
    ParseOptions po4("my usage msg");
    int32 val = 32;
    po4.Register("option", &val, "My int");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }

  try {   // test error with --unsigned-int=negative-number.
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=-13"};
    ParseOptions po4("my usage msg");
    uint32 val = 32;
    po4.Register("option", &val, "My int");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected)xxx.";
  }

  try {   // test error with --bool=string
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--option=foo"};
    ParseOptions po4("my usage msg");
    bool val = false;
    po4.Register("option", &val, "My bool");
    po4.Read(argc4, argv4);
    assert(false); // Should not reach this part of code.
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }


  // test error with --=
  try {
    int argc4 = 2;
    const char *argv4[2] = { "program_name", "--=8"};
    int32 num = 0;
    ParseOptions po4("my usage msg");
    po4.Register("num", &num, "My int32 variable");
    po4.Read(argc4, argv4);
    KALDI_ASSERT(num == 0);
  } catch(std::exception e) {
    KALDI_LOG << "Failed to read option (this is expected).";
  }

  // test "--" (no more options)
  int argc4 = 5;
  unum = 2;
  const char *argv4[5] = { "program_name", "--unum=6", "--",  "a", "b" };
  ParseOptions po4("my usage msg");
  po4.Register("unum", &unum, "My uint32 variable");
  po4.Read(argc4, argv4);
  KALDI_ASSERT(po4.NumArgs() == 2);
  KALDI_ASSERT(po4.GetArg(1) == "a");
  KALDI_ASSERT(po4.GetArg(2) == "b");
  KALDI_ASSERT(unum == 6);

  // test obsolete "--" (no more options)
  int argc5 = 3;
  unum = 2;
  const char *argv5[3] = { "program_name", "--unum=7", "--" };
  ParseOptions po5("my usage msg");
  po5.Register("unum", &unum, "My uint32 variable");
  po5.Read(argc5, argv5);
  KALDI_ASSERT(po5.NumArgs() == 0);
  KALDI_ASSERT(unum == 7);

  // test that "--foo=bar" after "--" is interpreted as argument
  int argc6 = 4;
  unum = 2;
  const char *argv6[5] = { "program_name", "--unum=8", "--", "--foo=8" };
  ParseOptions po6("my usage msg");
  po6.Register("unum", &unum, "My uint32 variable");
  po6.Read(argc6, argv6);
  KALDI_ASSERT(po6.NumArgs() == 1);
  KALDI_ASSERT(po6.GetArg(1) == "--foo=8");
}

UnitTestPca()

static void kaldi::UnitTestPca ( bool  full_test )

static

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

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatMat(), AssertEqual(), ComputePca(), rnnlm::i, SpMatrix< Real >::IsUnit(), MatrixBase< Real >::IsUnit(), KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, NonUnitness(), Rand(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::Sum().

                                        {
  // We'll test that we can exactly reconstruct the vectors, if
  // the PCA dim is <= the "real" dim that the vectors live in.
  for (MatrixIndexT i = 0; i < 10; i++) {
    bool exact = i % 2 == 0;
    MatrixIndexT true_dim = (full_test ? 200 : 50) + Rand() % 5, //dim of subspace points live in
        feat_dim = true_dim + Rand() % 5,  // dim of feature space
        num_points = true_dim + Rand() % 5, // number of training points.
        G = std::min(feat_dim,
                     std::min(num_points,
                              static_cast<MatrixIndexT>(true_dim + Rand() % 5)));

    Matrix<Real> Proj(feat_dim, true_dim);
    Proj.SetRandn();
    Matrix<Real> true_X(num_points, true_dim);
    true_X.SetRandn();
    Matrix<Real> X(num_points, feat_dim);
    X.AddMatMat(1.0, true_X, kNoTrans, Proj, kTrans, 0.0);

    Matrix<Real> U(G, feat_dim); // the basis
    Matrix<Real> A(num_points, G); // projection of points into the basis..
    ComputePca(X, &U, &A, true, exact);
    {
      SpMatrix<Real> I(G);
      I.AddMat2(1.0, U, kNoTrans, 0.0);
      KALDI_LOG << "Non-unit-ness of U is " << NonUnitness(I);
      KALDI_ASSERT(I.IsUnit(0.001));
    }
    Matrix<Real> X2(num_points, feat_dim);
    X2.AddMatMat(1.0, A, kNoTrans, U, kNoTrans, 0.0);
    // Check reproduction.
    KALDI_LOG << "A.Sum() " << A.Sum() << ", U.Sum() " << U.Sum();
    AssertEqual(X, X2, 0.01);
    // Check basis is orthogonal.
    Matrix<Real> tmp(G, G);
    tmp.AddMatMat(1.0, U, kNoTrans, U, kTrans, 0.0);
    KALDI_ASSERT(tmp.IsUnit(0.01));
  }
}

UnitTestPca2()

static void kaldi::UnitTestPca2 ( bool  full_test )

static

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

References SpMatrix< Real >::AddMat2(), SpMatrix< Real >::AddMat2Sp(), AssertEqual(), ComputePca(), MatrixBase< Real >::CopyFromMat(), SpMatrix< Real >::Eig(), rnnlm::i, SpMatrix< Real >::IsDiagonal(), KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, NonDiagonalness(), NonOrthogonality(), MatrixBase< Real >::SetRandn(), SortSvd(), and SpMatrix< Real >::Trace().

                                         {
  for (MatrixIndexT i = 0; i < 5; i++) {
    // MatrixIndexT feat_dim = 600, num_points = 300;
    MatrixIndexT feat_dim = (full_test ? 600 : 100),
        num_points = (i%2 == 0 ? feat_dim * 2 : feat_dim / 2); // test
    // both branches of PCA code,  inner + outer.

    Matrix<Real> X(num_points, feat_dim);
    X.SetRandn();

    MatrixIndexT pca_dim = 30;

    Matrix<Real> U(pca_dim, feat_dim); // rows PCA directions.
    bool print_eigs = true, exact = false;
    ComputePca(X, &U, static_cast<Matrix<Real>*>(NULL), print_eigs, exact);

    Real non_orth = NonOrthogonality(U, kNoTrans);
    KALDI_ASSERT(non_orth < 0.001);
    KALDI_LOG << "Non-orthogonality of U is " << non_orth;
    Matrix<Real> U2(pca_dim, feat_dim);

    {
      SpMatrix<Real> Scatter(feat_dim);
      Scatter.AddMat2(1.0, X, kTrans, 0.0);
      Matrix<Real> V(feat_dim, feat_dim);
      Vector<Real> l(feat_dim);
      Scatter.Eig(&l, &V); // cols of V are eigenvectors.
      SortSvd(&l, &V);  // Get top dims.
      U2.CopyFromMat(SubMatrix<Real>(V, 0, feat_dim, 0, pca_dim), kTrans);
      Real non_orth = NonOrthogonality(U2, kNoTrans);
      KALDI_ASSERT(non_orth < 0.001);
      KALDI_LOG << "Non-orthogonality of U2 is " << non_orth;

      SpMatrix<Real> ScatterProjU(pca_dim), ScatterProjU2(pca_dim);
      ScatterProjU.AddMat2Sp(1.0, U, kNoTrans, Scatter, 0.0);
      ScatterProjU2.AddMat2Sp(1.0, U2, kNoTrans, Scatter, 0.0);
      KALDI_LOG << "Non-diagonality of proj with U is "
                << NonDiagonalness(ScatterProjU);
      KALDI_LOG << "Non-diagonality of proj with U2 is "
                << NonDiagonalness(ScatterProjU2);
      KALDI_ASSERT(ScatterProjU.IsDiagonal(0.01)); // Algorithm is statistical,
      // so it ends up being less accurate.
      KALDI_ASSERT(ScatterProjU2.IsDiagonal());
      KALDI_LOG << "Trace proj with U is " << ScatterProjU.Trace()
                << " with U2 is " << ScatterProjU2.Trace();
      AssertEqual(ScatterProjU.Trace(), ScatterProjU2.Trace(), 0.1);// Algorithm is
      // statistical so give it some leeway.
    }
  }
}

UnitTestPenaltyFactor()

static void kaldi::UnitTestPenaltyFactor ( )

static

Definition at line 397 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::penalty_factor, WaveData::Read(), and MatrixBase< Real >::Write().

Referenced by UnitTestFeatWithKeele().

                                    {
  KALDI_LOG << "=== UnitTestPenaltyFactor() ===";
  for (int32 k = 1; k < 5; k++) {
    for (int32 i = 1; i < 4; i++) {
      std::string wavefile;
      std::string num;
      if (i < 6) {
        num = "f"+ConvertIntToString(i)+"nw0000";
        wavefile = "keele/16kHz/"+num+".wav";
      } else {
        num = "m"+ConvertIntToString(i-5)+"nw0000";
        wavefile = "keele/16kHz/"+num+".wav";
      }
      KALDI_LOG << "--- " << wavefile << " ---";
      std::ifstream is(wavefile.c_str(), std::ios_base::binary);
      WaveData wave;
      wave.Read(is);
      KALDI_ASSERT(wave.Data().NumRows() == 1);
      SubVector<BaseFloat> waveform(wave.Data(), 0);
      // use pitch code with default configuration..
      PitchExtractionOptions op;
      op.penalty_factor = k * 0.05;
      op.nccf_ballast = 0.1;
      // compute pitch.
      Matrix<BaseFloat> m;
      ComputeKaldiPitch(op, waveform, &m);
      std::string penaltyfactor = ConvertIntToString(k);
      std::string outfile = "keele/tmp/+"+num+"-kaldi-penalty-"+penaltyfactor+".txt";
      std::ofstream os(outfile.c_str());
      m.Write(os, false);
    }
  }
}

UnitTestPieces()

static void kaldi::UnitTestPieces ( )

static

Definition at line 154 of file pitch-functions-test.cc.

References OnlinePitchFeature::AcceptWaveform(), ApproxEqual(), AssertEqual(), ComputeKaldiPitch(), ProcessPitchOptions::delta_pitch_noise_stddev, VectorBase< Real >::Dim(), OnlineProcessPitch::Dim(), OnlinePitchFeature::GetFrame(), OnlineProcessPitch::GetFrame(), rnnlm::i, OnlinePitchFeature::InputFinished(), KALDI_ERR, KALDI_LOG, M_2PI, rnnlm::n, PitchExtractionOptions::nccf_ballast_online, OnlinePitchFeature::NumFramesReady(), ProcessPitch(), RandGauss(), Matrix< Real >::Resize(), and PitchExtractionOptions::samp_freq.

Referenced by UnitTestFeatNoKeele().

                             {
  KALDI_LOG << "=== UnitTestPieces() ===\n";
  for (int32 n = 0; n < 10; n++) {
    // the parametrization object
    PitchExtractionOptions op1;
    ProcessPitchOptions op2;
    op2.delta_pitch_noise_stddev = 0.0;  // to avoid mismatch of delta_log_pitch
                                         // brought by rand noise.
    op1.nccf_ballast_online = true;  // this is necessary for the computation
    // to be identical regardless how many pieces we break the signal into.

    int32 size = 10000 + rand() % 50000;

    Vector<BaseFloat> v(size);
    // init with noise plus a sine-wave whose frequency is changing randomly.

    double cur_freq = 200.0, normalized_time = 0.0;

    for (int32 i = 0; i < size; i++) {
      v(i) = RandGauss() + cos(normalized_time * M_2PI);
      cur_freq += RandGauss();  // let the frequency wander a little.
      if (cur_freq < 100.0) cur_freq = 100.0;
      if (cur_freq > 300.0) cur_freq = 300.0;
      normalized_time += cur_freq / op1.samp_freq;
    }

    Matrix<BaseFloat> m1, m1p;

    // trying to have same opts as baseline.
    ComputeKaldiPitch(op1, v, &m1);
    ProcessPitch(op2, m1, &m1p);

    Matrix<BaseFloat> m2, m2p;

    { // compute it online with multiple pieces.
      OnlinePitchFeature pitch_extractor(op1);
      OnlineProcessPitch process_pitch(op2, &pitch_extractor);
      int32 start_samp = 0;
      while (start_samp < v.Dim()) {
        int32 num_samp = rand() % (v.Dim() + 1 - start_samp);
        SubVector<BaseFloat> v_part(v, start_samp, num_samp);
        pitch_extractor.AcceptWaveform(op1.samp_freq, v_part);
        start_samp += num_samp;
      }
      pitch_extractor.InputFinished();
      int32 num_frames = pitch_extractor.NumFramesReady();
      m2.Resize(num_frames, 2);
      m2p.Resize(num_frames, process_pitch.Dim());
      for (int32 frame = 0; frame < num_frames; frame++) {
        SubVector<BaseFloat> row(m2, frame);
        pitch_extractor.GetFrame(frame, &row);
        SubVector<BaseFloat> rowp(m2p, frame);
        process_pitch.GetFrame(frame, &rowp);
      }
    }
    AssertEqual(m1, m2);
    if (!ApproxEqual(m1p, m2p)) {
      KALDI_ERR << "Post-processed pitch differs: " << m1p << " vs. " << m2p;
    }
    KALDI_LOG << "Test passed :)\n";
  }
}

UnitTestPitchExtractionSpeed()

static void kaldi::UnitTestPitchExtractionSpeed ( )

static

Definition at line 465 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), Timer::Elapsed(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::lowpass_cutoff, PitchExtractionOptions::nccf_ballast, and WaveData::Read().

Referenced by UnitTestFeatWithKeele().

                                           {
  KALDI_LOG << "=== UnitTestPitchExtractionSpeed() ===";
  // use pitch code with default configuration..
  PitchExtractionOptions op;
  op.nccf_ballast = 0.1;
  op.lowpass_cutoff = 1000;
  for (int32 i = 1; i < 2; i++) {
    std::string wavefile;
    std::string num;
    if (i < 6) {
      num = "f"+ConvertIntToString(i)+"nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    } else {
      num = "m"+ConvertIntToString(i-5)+"nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    }
    KALDI_LOG << "--- " << wavefile << " ---";
    std::ifstream is(wavefile.c_str(), std::ios_base::binary);
    WaveData wave;
    wave.Read(is);
    KALDI_ASSERT(wave.Data().NumRows() == 1);
    SubVector<BaseFloat> waveform(wave.Data(), 0);
    // compute pitch.
    int test_num = 10;
    Matrix<BaseFloat> m;
    Timer timer;
    for (int32 t = 0; t < test_num; t++)
      ComputeKaldiPitch(op, waveform, &m);
    double tot_time = timer.Elapsed(),
        speech_time = test_num * waveform.Dim() / wave.SampFreq();
    KALDI_LOG << " Pitch extraction time per second of speech is "
              << (tot_time / speech_time) << " seconds.";
  }
}

UnitTestPitchExtractorCompareKeele()

static void kaldi::UnitTestPitchExtractorCompareKeele ( )

static

Definition at line 499 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::nccf_ballast, and WaveData::Read().

Referenced by UnitTestFeatWithKeele().

                                                 {
  KALDI_LOG << "=== UnitTestPitchExtractorCompareKeele() ===";
  // use pitch code with default configuration..
  PitchExtractionOptions op;
  op.nccf_ballast = 0.1;
  for (int32 i = 1; i < 11; i++) {
    std::string wavefile;
    std::string num;
    if (i < 6) {
      num = "f"+ConvertIntToString(i)+"nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    } else {
      num = "m"+ConvertIntToString(i-5)+"nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    }
    KALDI_LOG << "--- " << wavefile << " ---";
    std::ifstream is(wavefile.c_str(), std::ios_base::binary);
    WaveData wave;
    wave.Read(is);
    KALDI_ASSERT(wave.Data().NumRows() == 1);
    SubVector<BaseFloat>  waveform(wave.Data(), 0);
    // compute pitch.
    Matrix<BaseFloat> m;
    ComputeKaldiPitch(op, waveform, &m);
    std::string outfile = "keele/tmp/+"+num+"-speedup-kaldi1.txt";
    std::ofstream os(outfile.c_str());
    m.Write(os, false);
  }
}

UnitTestPldaEstimation()

void kaldi::UnitTestPldaEstimation

(

int32

dim

)

Definition at line 25 of file plda-test.cc.

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::AddMatVec(), PldaStats::AddSamples(), SpMatrix< Real >::AddTp2Sp(), MatrixBase< Real >::AddVecToRows(), TpMatrix< Real >::Cholesky(), MatrixBase< Real >::Cond(), VectorBase< Real >::Data(), VectorBase< Real >::Dim(), SpMatrix< Real >::Eig(), PldaEstimator::Estimate(), TpMatrix< Real >::Invert(), KALDI_LOG, kNoTrans, kTrans, rnnlm::n, Rand(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), PldaStats::Sort(), and SpMatrix< Real >::Trace().

Referenced by main().

                                       {
  int32 num_classes = 1000 + Rand() % 10;
  Matrix<double> between_proj(dim, dim);
  while (between_proj.Cond() > 100)
    between_proj.SetRandn();
  Matrix<double> within_proj(dim, dim);
  while (within_proj.Cond() > 100)
    within_proj.SetRandn();


  Vector<double> global_mean(dim);
  global_mean.SetRandn();
  global_mean.Scale(10.0);

  PldaStats stats;

  for (int32 n = 0; n < num_classes; n++) {
    int32 num_egs = 1 + Rand() % 30;
    Vector<double> rand_vec(dim);
    rand_vec.SetRandn();
    Vector<double> class_mean(global_mean);
    class_mean.AddMatVec(1.0, between_proj, kNoTrans, rand_vec, 1.0);

    Matrix<double> rand_mat(num_egs, dim);
    rand_mat.SetRandn();
    Matrix<double> offset_mat(num_egs, dim);
    offset_mat.AddMatMat(1.0, rand_mat, kNoTrans, within_proj,
                         kTrans, 0.0);
    offset_mat.AddVecToRows(1.0, class_mean);

    double weight = 1.0 + (0.1 * (Rand() % 30));
    stats.AddSamples(weight,
                     offset_mat);
  }



  SpMatrix<double> between_var(dim), within_var(dim);
  between_var.AddMat2(1.0, between_proj, kNoTrans, 0.0);
  within_var.AddMat2(1.0, within_proj, kNoTrans, 0.0);

  stats.Sort();
  PldaEstimator estimator(stats);
  Plda plda;
  PldaEstimationConfig config;
  estimator.Estimate(config, &plda);

  KALDI_LOG << "Trace of true within-var is " << within_var.Trace();
  KALDI_LOG << "Trace of true between-var is " << between_var.Trace();

  {
    TpMatrix<double> C(dim);
    C.Cholesky(within_var);
    C.Invert();
    SpMatrix<double> between_var_proj(dim);
    between_var_proj.AddTp2Sp(1.0, C, kNoTrans, between_var, 0.0);
    Vector<double> s(dim);
    between_var_proj.Eig(&s);
    s.Scale(-1.0);
    std::sort(s.Data(), s.Data() + s.Dim());
    s.Scale(-1.0);
    KALDI_LOG << "Diagonal of between-class variance in normalized space "
              << "should be: " << s;
  }

}

UnitTestPosteriors()

void kaldi::UnitTestPosteriors

(

)

Definition at line 25 of file logistic-regression-test.cc.

References VectorBase< Real >::ApplyExp(), ApproxEqual(), MatrixBase< Real >::ApproxEqual(), VectorBase< Real >::CopyRowFromMat(), LogisticRegression::GetLogPosteriors(), rnnlm::i, KALDI_ASSERT, LogisticRegressionConfig::max_steps, LogisticRegressionConfig::normalizer, MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::Row(), MatrixBase< Real >::SetRandn(), LogisticRegression::SetWeights(), and VectorBase< Real >::Sum().

Referenced by main().

                          {
  int32 n_features = Rand() % 600 + 10,
        n_xs = Rand() % 200 + 100,
        n_labels = Rand() % 20 + 10;

  LogisticRegressionConfig conf;
  conf.max_steps = 20;
  conf.normalizer = 0.001;

  Matrix<BaseFloat> xs(n_xs, n_features);
  xs.SetRandn();
  Matrix<BaseFloat> weights(n_labels, n_features + 1);
  weights.SetRandn();
  LogisticRegression classifier = LogisticRegression();
  std::vector<int32> classes;
  for (int32 i = 0; i < weights.NumRows(); i++) {
    classes.push_back(i);
  }
  classifier.SetWeights(weights, classes);

  // Get posteriors for the xs using batch and serial methods.
  Matrix<BaseFloat> batch_log_posteriors;
  classifier.GetLogPosteriors(xs, &batch_log_posteriors);
  Matrix<BaseFloat> log_posteriors(n_xs, n_labels);
  for (int32 i = 0; i < n_xs; i++) {
    Vector<BaseFloat> x(n_features);
    x.CopyRowFromMat(xs, i);
    Vector<BaseFloat> log_post;
    classifier.GetLogPosteriors(x, &log_post);

    // Verify that sum_y p(y|x) = 1.0.
    Vector<BaseFloat> post(log_post);
    post.ApplyExp();
    KALDI_ASSERT(ApproxEqual(post.Sum(), 1.0));
    log_posteriors.Row(i).CopyFromVec(log_post);
  }

  // Verify equivalence of batch and serial methods.
  float tolerance = 0.01;
  KALDI_ASSERT(log_posteriors.ApproxEqual(batch_log_posteriors, tolerance));
}

UnitTestPower()

static void kaldi::UnitTestPower ( )

static

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

References MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::ApplyPow(), VectorBase< Real >::ApplyPow(), AssertEqual(), SpMatrix< Real >::CopyFromMat(), VectorBase< Real >::CopyFromVec(), kNoTrans, kTrans, and Rand().

                                                    {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    // this is for matrix-pow
    MatrixIndexT dimM = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimM), N(dimM, dimM);
    M.SetRandn();
    N.AddMatMat(1.0, M, kNoTrans, M, kTrans, 0.0);  // N:=M*M^T.
    SpMatrix<Real> S(dimM);
    S.CopyFromMat(N);  // symmetric so should not crash.
    S.ApplyPow(0.5);
    S.ApplyPow(2.0);
    M.CopyFromSp(S);
    AssertEqual(M, N);

    // this is for vector-pow
    MatrixIndexT dimV = 10 + Rand() % 10;
    Vector<Real> V(dimV), V1(dimV), V2(dimV);
    V.SetRandn();
    V1.AddVecVec(1.0, V, V, 0.0);  // V1:=V.*V.
    V2.CopyFromVec(V1);
    V2.ApplyPow(0.5);
    V2.ApplyPow(2.0);
    AssertEqual(V1, V2);
  }
}

UnitTestPowerAbs()

static void kaldi::UnitTestPowerAbs ( )

static

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

References VectorBase< Real >::ApplyPowAbs(), AssertEqual(), VectorBase< Real >::CopyFromVec(), KALDI_LOG, and Rand().

                                                       {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimV = 10 + Rand() % 10;
    Vector<Real> V(dimV), V1(dimV), V2(dimV);
    V.SetRandn();
    V1.AddVecVec(1.0, V, V, 0.0);  // V1:=V.*V.
    V2.CopyFromVec(V1);
    KALDI_LOG << V1;
    V2.ApplyPowAbs(0.5);
    KALDI_LOG << V2;
    V2.ApplyPowAbs(2.0);
    KALDI_LOG << V2;
    AssertEqual(V1, V2);
  }
}

UnitTestProcess()

void kaldi::UnitTestProcess

(

)

Definition at line 561 of file pitch-functions-test.cc.

References ComputeKaldiPitch(), ConvertIntToString(), ProcessPitchOptions::delta_pitch_noise_stddev, rnnlm::i, KALDI_ASSERT, KALDI_LOG, PitchExtractionOptions::lowpass_cutoff, ProcessPitch(), WaveData::Read(), and MatrixBase< Real >::Write().

Referenced by UnitTestFeatWithKeele().

                       {
  for (int32 i = 1; i < 11; i++) {
    std::string wavefile;
    std::string num;
    if (i < 6) {
      num = "f"+ConvertIntToString(i)+"nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    } else {
      num = "m"+ConvertIntToString(i-5)+"nw0000";
      wavefile = "keele/16kHz/"+num+".wav";
    }
    KALDI_LOG << "--- " << wavefile << " ---";
    std::ifstream is(wavefile.c_str(), std::ios_base::binary);
    WaveData wave;
    wave.Read(is);
    KALDI_ASSERT(wave.Data().NumRows() == 1);
    SubVector<BaseFloat> waveform(wave.Data(), 0);
    PitchExtractionOptions op;
    op.lowpass_cutoff = 1000;
    op.nccf_ballast = 0.1;
    op.max_f0 = 400;
    Matrix<BaseFloat> m, m2;
    ComputeKaldiPitch(op, waveform, &m);
    ProcessPitchOptions postprop_op;
    // postprop_op.pov_nonlinearity = 2;
    // Use zero noise, or the features won't be identical.
    postprop_op.delta_pitch_noise_stddev = 0.0;
    ProcessPitch(postprop_op, m, &m2);

    std::string outfile = "keele/tmp/+"+num+"-processed-kaldi.txt";
    std::ofstream os(outfile.c_str());
    m2.Write(os, false);
  }
}

UnitTestRand()

void kaldi::UnitTestRand

(

)

Definition at line 77 of file kaldi-math-test.cc.

References rnnlm::i, rnnlm::j, KALDI_ASSERT, rnnlm::n, Rand(), RandGauss(), RandGauss2(), RandInt(), RandPoisson(), RandPrune(), RandUniform(), and WithProb().

Referenced by main().

                    {
  // Testing random-number generation.
  std::cout << "Testing random-number generation.  "
            << "If there is an error this may not terminate.\n";
  std::cout << "If this does not terminate, look more closely.  "
            << "There might be a problem [but might not be]\n";
  for (int i = 1; i < 10; i++) {
    {  // test RandUniform.
      std::cout << "Test RandUniform\n";
      KALDI_ASSERT(RandUniform() >= 0 && RandUniform() <= 1);
      float sum = RandUniform()-0.5;
      for (int j = 0; ; j++) {
        sum += RandUniform()-0.5;
        if (std::abs(sum) < 0.5*sqrt(static_cast<double>(j))) break;
      }
    }
    {  // test RandGauss.
      float sum = RandGauss();
      for (int j = 0; ; j++) {
        sum += RandGauss();
        if (std::abs(sum) < 0.5*sqrt(static_cast<double>(j))) break;
      }
    }
    {  // test RandGauss.
      float sum = RandGauss();
      for (int j = 0; ; j++) {
        float a, b;
        RandGauss2(&a, &b);
        if (i % 2 == 0) sum += a;
        else
          sum += b;
        if (std::abs(sum) < 0.5*sqrt(static_cast<double>(j))) break;
      }
    }
    {  // test poisson_Rand().
      KALDI_ASSERT(RandPoisson(3.0) >= 0);
      KALDI_ASSERT(RandPoisson(0.0) == 0);
      std::cout << "Test RandPoisson\n";
      float lambda = RandUniform() * 3.0;  // between 0 and 3.
      double sum = RandPoisson(lambda) - lambda;  // expected value is zero.
      for (int j = 0; ; j++) {
        sum += RandPoisson(lambda) - lambda;
        if (std::abs(sum) < 0.5*sqrt(static_cast<double>(j))) break;
      }
    }

    { // test WithProb().
      for (int32 i = 0; i < 10; i++) {
        KALDI_ASSERT((WithProb(0.0) == false) && (WithProb(1.0) == true));
      }
      {
        int32 tot = 0, n = 10000;
        BaseFloat p = 0.5;
        for (int32 i = 0; i < n; i++)
          tot += WithProb(p);
        KALDI_ASSERT(tot > (n * p * 0.8) && tot < (n * p * 1.2));
      }
      {
        int32 tot = 0, n = 10000;
        BaseFloat p = 0.25;
        for (int32 i = 0; i < n; i++)
          tot += WithProb(p);
        KALDI_ASSERT(tot > (n * p * 0.8) && tot < (n * p * 1.2));
      }
    }
    {  // test RandInt().
      KALDI_ASSERT(RandInt(0, 3) >= 0 && RandInt(0, 3) <= 3);

      std::cout << "Test RandInt\n";
      int minint = Rand() % 200;
      int maxint = minint + 1 + Rand()  % 20;

      float sum = RandInt(minint, maxint) +  0.5*(minint+maxint);
      for (int j = 0; ; j++) {
        sum += RandInt(minint, maxint) - 0.5*(minint+maxint);
        if (std::abs(static_cast<float>(sum)) <
            0.5*sqrt(static_cast<double>(j))*(maxint-minint)) break;
      }
    }
    { // test RandPrune in basic way.
      KALDI_ASSERT(RandPrune(1.1, 1.0) == 1.1);
      KALDI_ASSERT(RandPrune(0.0, 0.0) == 0.0);
      KALDI_ASSERT(RandPrune(-1.1, 1.0) == -1.1);
      KALDI_ASSERT(RandPrune(0.0, 1.0) == 0.0);
      KALDI_ASSERT(RandPrune(0.5, 1.0) >= 0.0);
      KALDI_ASSERT(RandPrune(-0.5, 1.0) <= 0.0);
      BaseFloat f = RandPrune(-0.5, 1.0);
      KALDI_ASSERT(f == 0.0 || f == -1.0);
      f = RandPrune(0.5, 1.0);
      KALDI_ASSERT(f == 0.0 || f == 1.0);
    }
  }
}

UnitTestRandCategorical()

static void kaldi::UnitTestRandCategorical ( )

static

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

References rnnlm::i, KALDI_ASSERT, KALDI_LOG, rnnlm::n, Rand(), VectorBase< Real >::RandCategorical(), and VectorBase< Real >::Sum().

                                      {
  int32 N = 1 + Rand()  % 10;
  Vector<Real> vec(N);
  for (int32 n = 0; n < N; n++)
    vec(n) = Rand() % 3;
  if (vec.Sum() == 0)
    vec(0) = 2.0;
  Real sum = vec.Sum();
  int32 num_samples = 100000;
  std::vector<int32> counts(N, 0);
  for (int32 i = 0; i < num_samples; i++)
    counts[vec.RandCategorical()]++;
  for (int32 n = 0; n < N; n++) {
    Real a = counts[n] / (1.0 * num_samples),
        b = vec(n) / sum;
    KALDI_LOG << "a = " << a << ", b = " << b;
    KALDI_ASSERT(fabs(a - b) <= 0.1); // pretty arbitrary.  Will increase #samp if fails.
  }
}

UnitTestRange()

static void kaldi::UnitTestRange ( )

static

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

References ApproxEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), VectorBase< Real >::Range(), MatrixBase< Real >::Range(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), MatrixBase< Real >::Sum(), and VectorBase< Real >::Sum().

                                                    {  // Testing SubMatrix class.

  // this is for matrix-range
  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = (Rand()%10) + 10;
    MatrixIndexT dimN = (Rand()%10) + 10;

    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    MatrixIndexT dimMStart = Rand() % 5;
    MatrixIndexT dimNStart = Rand() % 5;

    MatrixIndexT dimMEnd = dimMStart + 1 + (Rand()%10); if (dimMEnd > dimM) dimMEnd = dimM;
    MatrixIndexT dimNEnd = dimNStart + 1 + (Rand()%10); if (dimNEnd > dimN) dimNEnd = dimN;


    SubMatrix<Real> sub(M, dimMStart, dimMEnd-dimMStart, dimNStart, dimNEnd-dimNStart);

    KALDI_ASSERT(sub.Sum() == M.Range(dimMStart, dimMEnd-dimMStart, dimNStart, dimNEnd-dimNStart).Sum());

    for (MatrixIndexT i = dimMStart;i < dimMEnd;i++)
      for (MatrixIndexT j = dimNStart;j < dimNEnd;j++)
        KALDI_ASSERT(M(i, j) == sub(i-dimMStart, j-dimNStart));

    sub.SetRandn();

    KALDI_ASSERT(sub.Sum() == M.Range(dimMStart, dimMEnd-dimMStart, dimNStart, dimNEnd-dimNStart).Sum());

    for (MatrixIndexT i = dimMStart;i < dimMEnd;i++)
      for (MatrixIndexT j = dimNStart;j < dimNEnd;j++)
        KALDI_ASSERT(M(i, j) == sub(i-dimMStart, j-dimNStart));
  }

  // this if for vector-range
  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT length = (Rand()%10) + 10;

    Vector<Real> V(length);
    V.SetRandn();
    MatrixIndexT lenStart = Rand() % 5;

    MatrixIndexT lenEnd = lenStart + 1 + (Rand()%10); if (lenEnd > length) lenEnd = length;

    SubVector<Real> sub(V, lenStart, lenEnd-lenStart);

    KALDI_ASSERT(ApproxEqual(sub.Sum(), V.Range(lenStart, lenEnd-lenStart).Sum()));

    for (MatrixIndexT i = lenStart;i < lenEnd;i++)
      KALDI_ASSERT(V(i) == sub(i-lenStart));

    sub.SetRandn();

    KALDI_ASSERT(ApproxEqual(sub.Sum(), V.Range(lenStart, lenEnd-lenStart).Sum()));

    for (MatrixIndexT i = lenStart;i < lenEnd;i++)
      KALDI_ASSERT(V(i) == sub(i-lenStart));
  }
}

UnitTestRangesMatrix()

void kaldi::UnitTestRangesMatrix

(

bool

binary

)

Definition at line 842 of file kaldi-table-test.cc.

References SequentialTableReader< Holder >::Done(), RandomAccessTableReader< Holder >::HasKey(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), rnnlm::n, SequentialTableReader< Holder >::Next(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), RandInt(), Output::Stream(), Input::Stream(), Trim(), RandomAccessTableReader< Holder >::Value(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                       {
  int32 archive_size = RandInt(1, 10);
  std::vector<std::pair<std::string, Matrix<BaseFloat> > > archive_contents(
      archive_size);
  for (int32 i = 0; i < archive_size; i++) {
    char key_buf[2];
    key_buf[0] = 'A' + i;
    key_buf[1] = '\0';
    std::string key(key_buf);
    archive_contents[i].first = key;
    archive_contents[i].second.Resize(RandInt(1, 5), RandInt(1, 5));
    archive_contents[i].second.SetRandn();
  }
  if (RandInt(0, 1) == 0)
    std::random_shuffle(archive_contents.begin(), archive_contents.end());

  std::ostringstream writer_name;
  writer_name << "ark,scp";
  if (binary) writer_name << ",b";
  else writer_name << ",t";
  writer_name << ":tmpf,tmpf.scp";

  {
    BaseFloatMatrixWriter writer(writer_name.str());
    for (int32 i = 0; i < archive_size; i++)
      writer.Write(archive_contents[i].first, archive_contents[i].second);
  }

  std::vector<std::string> scp_lines;
  {
    bool binary;
    Input scp_input("tmpf.scp", &binary);
    KALDI_ASSERT(!binary);
    std::string line;
    while (getline(scp_input.Stream(), line)) {
      Trim(&line);  // remove trailing and beginning whitespace.
      scp_lines.push_back(line);
    }
    KALDI_ASSERT(scp_lines.size() == archive_contents.size());
  }

  int32 scp_length = RandInt(0, 10);
  std::vector<std::pair<std::string, Matrix<BaseFloat> > >
      scp_intended_contents(scp_length);

  {
    Output output("tmpf_ranges.scp", false);

    for (int32 i = 0; i < scp_length; i++) {
      int32 src_i = RandInt(0, archive_size - 1);
      std::string scp_line_str = scp_lines[src_i];  // a line like "A tmpf:1043", without newline.
      scp_line_str[0] = 'a' + i;  // now scp_line_str looks like "a tmpf:1043".
      std::string key("x");
      key[0] = 'a' + i;
      scp_intended_contents[i].first = key;
      output.Stream() << scp_line_str;
      const Matrix<BaseFloat> &src_mat = archive_contents[src_i].second;
      if (RandInt(0, 1) == 0) {  // Use a range.
        int32 tot_rows = src_mat.NumRows(), tot_cols = src_mat.NumCols();
        int32 row_offset = RandInt(0, tot_rows - 1),
            num_rows = RandInt(1, tot_rows - row_offset),
            col_offset = RandInt(0, tot_cols - 1),
            num_cols = RandInt(1, tot_cols - col_offset);
        SubMatrix<BaseFloat> sub_mat(src_mat, row_offset, num_rows,
                                     col_offset, num_cols);
        scp_intended_contents[i].second = sub_mat;
        output.Stream() << "[";
        if (row_offset != 0 || num_rows != tot_rows)
          output.Stream() << row_offset << ":"
                          << (row_offset + num_rows - 1);
        else
          output.Stream() << ":";
        if (col_offset != 0 || num_cols != tot_cols) {
          output.Stream() << "," << col_offset
                          << ":" << (col_offset + num_cols - 1);
        } else {
          if (RandInt(0, 1) == 0) {
            output.Stream() << ",:";
          }
        }
        output.Stream() << "]";
      } else {  // no range.
        scp_intended_contents[i].second = src_mat;
      }
      output.Stream() << "\n";
    }
  }

  {  // test random-access reading.
    bool permissive = (RandInt(0, 1) == 0);
    RandomAccessDoubleMatrixReader reader(permissive ?
                                          "scp,p:tmpf_ranges.scp" :
                                          "scp:tmpf_ranges.scp");

    int32 num_queries = RandInt(0, 10);
    for (int32 n = 0; n < num_queries; n++) {
      int32 i = RandInt(0, scp_length);
      if (i == scp_length) { // fake "bad" query.
        KALDI_ASSERT(!reader.HasKey("foobar"));
      } else {
        std::string key = scp_intended_contents[i].first;
        if (RandInt(0, 1) == 0)
          KALDI_ASSERT(reader.HasKey(key));
        Matrix<BaseFloat> value (reader.Value(key));
        KALDI_ASSERT(value.ApproxEqual(scp_intended_contents[i].second));
      }
    }
  }


  {  // test sequential reading.
    bool permissive = (RandInt(0, 1) == 0);
    SequentialBaseFloatMatrixReader reader(permissive ?
                                           "scp,p:tmpf_ranges.scp" :
                                           "scp:tmpf_ranges.scp");

    int32 i = 0;
    for (; !reader.Done(); reader.Next(), i++) {
      KALDI_ASSERT(reader.Key() == scp_intended_contents[i].first);
      KALDI_ASSERT(reader.Value().ApproxEqual(scp_intended_contents[i].second));
    }
    KALDI_ASSERT(i == scp_length);
  }


  unlink("tmpf");
  unlink("tmpf.scp");
  unlink("tmpf_ranges.scp");
}

UnitTestRankNUpdate()

static void kaldi::UnitTestRankNUpdate ( )

static

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

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatMat(), AssertEqual(), kNoTrans, kTrans, Rand(), and MatrixBase< Real >::SetRandn().

                                  {
  for (MatrixIndexT iter = 0;iter < 10;iter++) {
    MatrixIndexT dimA = 10 + Rand()%3;
    MatrixIndexT dimO = 10 + Rand()%3;
    Matrix<Real>   Af(dimA, dimA);
    SpMatrix<Real> Ap(dimA);
    SpMatrix<Real> Ap2(dimA);
    Matrix<Real>   M(dimO, dimA);
    M.SetRandn();
    Matrix<Real>   N(M, kTrans);
    Af.AddMatMat(1.0, M, kTrans, M, kNoTrans, 0.0);
    Ap.AddMat2(1.0, M, kTrans, 0.0);
    Ap2.AddMat2(1.0, N, kNoTrans, 0.0);
    Matrix<Real> Ap_f(Ap);
    Matrix<Real> Ap2_f(Ap2);
    AssertEqual(Ap_f, Af);
    AssertEqual(Ap2_f, Af);
  }
}

UnitTestReadConfig()

void kaldi::UnitTestReadConfig

(

)

Definition at line 479 of file text-utils-test.cc.

References ApproxEqual(), rnnlm::i, KALDI_ASSERT, and ReadConfigLines().

Referenced by main().

                          {
  std::string str = "a-b alpha=aa beta=\"b b\"# String test\n"
      "a-b beta2='b c' beta3=bd # \n"
      "a-b gamma=1:2:3:4  # Int Vector test\n"
      " a-b de1ta=f  # Bool + Integer in key Comment test delta=t  \n"
      "a-b _epsilon=-1  # Int Vector test _epsilon=1 \n"
      "a-b zet-_a=0.15   theta=1.1# Float, -, _ test\n"
      "a-b quoted='a b c' # quoted string\n"
      "a-b quoted2=\"d e 'a b=c' f\" # string quoted with double quotes";

  std::istringstream is(str);
  std::vector<std::string> lines;
  ReadConfigLines(is, &lines);
  KALDI_ASSERT(lines.size() == 8);

  ConfigLine cfl;
  for (size_t i = 0; i < lines.size(); i++) {
    KALDI_ASSERT(cfl.ParseLine(lines[i]) && cfl.FirstToken() == "a-b");
    if (i == 1) {
        KALDI_ASSERT(cfl.GetValue("beta2", &str) && str == "b c");
    }
    if (i == 4) {
      KALDI_ASSERT(cfl.GetValue("_epsilon", &str) && str == "-1");
    }
    if (i == 5) {
      BaseFloat float_val = 0;
      KALDI_ASSERT(cfl.GetValue("zet-_a", &float_val) && ApproxEqual(float_val, 0.15));
    }
    if (i == 6) {
      KALDI_ASSERT(cfl.GetValue("quoted", &str) && str == "a b c");
    }
    if (i == 7) {
      KALDI_ASSERT(cfl.GetValue("quoted2", &str) && str == "d e 'a b=c' f");
    }
  }
}

UnitTestReadScriptFile()

void kaldi::UnitTestReadScriptFile

(

)

Definition at line 28 of file kaldi-table-test.cc.

References Output::Close(), KALDI_ASSERT, ReadScriptFile(), Sleep(), and Output::Stream().

Referenced by main().

                              {
  typedef std::pair<std::string, std::string>  pr;
  {
    std::stringstream ss;
    ss << " a b\n";
    ss << "c d \n";
    ss << "c d e \n";
    std::vector<pr> script;
    bool ans = ReadScriptFile(ss, true, &script);
    KALDI_ASSERT(ans);
    std::vector<pr> script2;
    script2.push_back(std::pair<std::string, std::string>("a", "b"));
    script2.push_back(std::pair<std::string, std::string>("c", "d"));
    script2.push_back(std::pair<std::string, std::string>("c", "d e"));
    KALDI_ASSERT(script == script2);
  }
  {
    typedef std::pair<std::string, std::string>  pr;
    std::stringstream ss;
    ss << " a \n";
    std::vector<pr> script;
    // suppress the warning since I already checked it's OK.
    KALDI_ASSERT(!ReadScriptFile(ss, false, &script));
  }
  {
    typedef std::pair<std::string, std::string>  pr;
    std::stringstream ss;
    ss << "\n";
    std::vector<pr> script;
    // suppress the warning since I already checked it's OK.
    KALDI_ASSERT(!ReadScriptFile(ss, false, &script));
  }
#if !defined(_MSC_VER) || defined(KALDI_CYGWIN_COMPAT)
  {
    Output ko("| gzip -c > tmpf.gz", false);  // text mode.
    ko.Stream() << "a b\n";
    ko.Close();
    std::vector<pr> script;
    Sleep(1);  // This test does not work without this sleep:
    bool ans = ReadScriptFile("gunzip -c tmpf.gz |", true, &script);
    KALDI_ASSERT(ans);
    std::vector<pr> script2;
    script2.push_back(std::pair<std::string, std::string>("a", "b"));
    KALDI_ASSERT(script == script2);
  }

  {
    Output ko("| gzip -c > tmpf.gz", true);  // binary mode w/ header:
    // should fail, because script files should not have binary header.
    ko.Stream() << "a b\n";
    bool ans = ko.Close();
    KALDI_ASSERT(ans);
    Sleep(1);  // This test does not work without this sleep:
    // seems to be some kind of file-system latency.
    std::vector<pr> script;
    ans = ReadScriptFile("gunzip -c tmpf.gz |", false, &script);
    KALDI_ASSERT(!ans);
  }
  unlink("tmpf.gz");
#endif
}

UnitTestRealFft()

static void kaldi::UnitTestRealFft ( )

static

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

References AssertEqual(), VectorBase< Real >::CopyFromVec(), Rand(), RealFft(), RealFftInefficient(), and VectorBase< Real >::Scale().

                                                      {

  // First, test RealFftInefficient.
  for (MatrixIndexT N_ = 2; N_ < 100; N_ += 6) {
    MatrixIndexT N = N_;
    if (N >90) N *= Rand() % 60;
    Vector<Real> v(N), w(N), x(N), y(N);
    v.SetRandn();
    w.CopyFromVec(v);
    RealFftInefficient(&w, true);
    y.CopyFromVec(v);
    RealFft(&y, true);  // test efficient one.
    // KALDI_LOG <<"v = "<<v;
    // KALDI_LOG << "Inefficient real fft of v is: "<< w;
    // KALDI_LOG << "Efficient real fft of v is: "<< y;
    AssertEqual(w, y, 0.01*N);
    x.CopyFromVec(w);
    RealFftInefficient(&x, false);
    RealFft(&y, false);
    // KALDI_LOG << "Inefficient real fft of v twice is: "<< x;
    if (N != 0) x.Scale(1.0/N);
    if (N != 0) y.Scale(1.0/N);
    AssertEqual(v, x, 0.001*N);
    AssertEqual(v, y, 0.001*N);  // ?
  }
}

UnitTestRealFftSpeed() [1/2]

static void kaldi::UnitTestRealFftSpeed ( )

static

Definition at line 38 of file matrix-lib-speed-test.cc.

References Timer::Elapsed(), rnnlm::i, KALDI_LOG, and RealFft().

                                                           {
  // First, test RealFftInefficient.
  Timer t;
  MatrixIndexT sz = 512;  // fairly typical size.
  for (MatrixIndexT i = 0; i < 3000; i++) {
    if (i % 1000 == 0) KALDI_LOG << "done 1000 [ == ten seconds of speech]";
    Vector<Real> v(sz);
    RealFft(&v, true);
  }
  CsvResult<Real>(__func__, 512, t.Elapsed(), "seconds");
}

UnitTestRealFftSpeed() [2/2]

static void kaldi::UnitTestRealFftSpeed ( )

static

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

References rnnlm::i, KALDI_LOG, and RealFft().

                                                           {

  // First, test RealFftInefficient.
  KALDI_LOG << "starting. ";
  MatrixIndexT sz = 512;  // fairly typical size.
  for (MatrixIndexT i = 0; i < 3000; i++) {
    if (i % 1000 == 0) KALDI_LOG << "done 1000 [ == ten seconds of speech]";
    Vector<Real> v(sz);
    RealFft(&v, true);
  }
}

UnitTestRegtreeFmllrDiagGmm()

void kaldi::UnitTestRegtreeFmllrDiagGmm	(	cova_type	feature_type,
		size_t	max_bclass
	)

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

References AccumAmDiagGmm::AccumulateForGmm(), RegtreeFmllrDiagGmmAccs::AccumulateForGmm(), AmDiagGmm::AddPdf(), RegressionTree::BuildTree(), DiagGmm::ComputeGconsts(), MatrixBase< Real >::Cond(), MatrixBase< Real >::CopyFromMat(), VectorBase< Real >::CopyFromVec(), rnnlm::d, DeletePointers(), generate_features(), RegtreeFmllrDiagGmm::GetLogDets(), rnnlm::i, AccumAmDiagGmm::Init(), RegtreeFmllrDiagGmmAccs::Init(), MatrixBase< Real >::InvertElements(), rnnlm::j, kGmmAll, RegtreeFmllrOptions::min_count, MleAmDiagGmmUpdate(), rnnlm::n, RegressionTree::NumBaseclasses(), RegtreeFmllrDiagGmm::NumBaseClasses(), AmDiagGmm::NumGaussInPdf(), RegtreeFmllrDiagGmm::NumRegClasses(), Rand(), RandUniform(), RegtreeFmllrDiagGmm::Read(), DiagGmm::Resize(), Vector< Real >::Resize(), DiagGmm::SetInvVarsAndMeans(), MatrixBase< Real >::SetRandn(), DiagGmm::SetWeights(), RegtreeFmllrDiagGmmAccs::SetZero(), AmDiagGmm::SplitPdf(), Input::Stream(), RegtreeFmllrDiagGmm::TransformFeature(), RegtreeFmllrDiagGmmAccs::Update(), RegtreeFmllrOptions::use_regtree, RegtreeFmllrDiagGmm::Validate(), and RegtreeFmllrDiagGmm::Write().

Referenced by main().

                                                                            {
  // dimension of the feature space
  size_t dim = 5 + Rand() % 3;

  // number of components in the data
  size_t n_gaussians = 8;

  // number of data points to generate for every gaussian
  size_t frames_per_gaussian = 100;

  // generate random transformation matrix trans_mat
  Matrix<BaseFloat> trans_mat(dim, dim);
  int i = 0;
  while (i < 10000) {
    trans_mat.SetRandn();
    if (trans_mat.Cond() < 100) break;
    i++;
  }
  std::cout << "Condition of original Trans_Mat: " << trans_mat.Cond() << '\n';

  // generate many feature vectors for each of the mixture components
  std::vector<Vector<BaseFloat>*>
      train_feats(n_gaussians * frames_per_gaussian);
  std::vector<Vector<BaseFloat>*>
      adapt_feats(n_gaussians * frames_per_gaussian);

  generate_features(feature_type,
                    n_gaussians,
                    dim,
                    trans_mat,
                    frames_per_gaussian,
                    train_feats,
                    adapt_feats);

  // initial values for a GMM
  Vector<BaseFloat> weights(1);
  Matrix<BaseFloat> means(1, dim), vars(1, dim), invvars(1, dim);
  for (size_t d= 0; d < dim; d++) {
    means(0, d) = 0.0F;
    vars(0, d) = 1.0F;
  }
  weights(0) = 1.0F;
  invvars.CopyFromMat(vars);
  invvars.InvertElements();

  // new HMM with 1 state
  DiagGmm *gmm = new DiagGmm();
  gmm->Resize(1, dim);
  gmm->SetWeights(weights);
  gmm->SetInvVarsAndMeans(invvars, means);
  gmm->ComputeGconsts();
  GmmFlagsType flags = kGmmAll;
  MleDiagGmmOptions opts;

  AmDiagGmm *am = new AmDiagGmm();
  am->AddPdf(*gmm);
  AccumAmDiagGmm *est_am = new AccumAmDiagGmm();

  // train HMM
  size_t iteration = 0;
  size_t maxiterations = 10;
  int32 maxcomponents = n_gaussians;
  BaseFloat loglike = 0;
  while (iteration < maxiterations) {
    est_am->Init(*am, flags);

    loglike = 0;
    for (size_t j = 0; j < train_feats.size(); j++) {
      loglike += est_am->AccumulateForGmm(*am, *train_feats[j], 0, 1.0);
    }
    MleAmDiagGmmUpdate(opts, *est_am, flags, am, NULL, NULL);

    std::cout << "Loglikelihood before iteration " << iteration << " : "
              << std::scientific << loglike << " number of components: "
              << am->NumGaussInPdf(0) << '\n';

    if ((iteration % 3 == 1) &&
        (am->NumGaussInPdf(0) * 2 <= maxcomponents)) {
      size_t n = am->NumGaussInPdf(0)*2;
      am->SplitPdf(0, n, 0.001);
    }
    iteration++;
  }

  // adapt HMM to the transformed feature vectors
  iteration = 0;
  RegtreeFmllrDiagGmmAccs * fmllr_accs = new RegtreeFmllrDiagGmmAccs();
  RegressionTree regtree;

  RegtreeFmllrOptions xform_opts;
  xform_opts.min_count = 100 * (1 + Rand() % 10);
  xform_opts.use_regtree = (RandUniform() < 0.5)? false : true;

  size_t num_pdfs = 1;
  Vector<BaseFloat> occs(num_pdfs);
  for (int32 i = 0; i < static_cast<int32>(num_pdfs); i++) {
    occs(i) = 1.0/static_cast<BaseFloat>(num_pdfs);
  }
  std::vector<int32> silphones;
  regtree.BuildTree(occs, silphones, *am, max_bclass);
  maxiterations = 10;
  std::vector<Vector<BaseFloat>*> logdet(adapt_feats.size());
  for (size_t j = 0; j < adapt_feats.size(); j++) {
    logdet[j] = new Vector<BaseFloat>(1);
    logdet[j]->operator()(0) = 0.0;
  }
  while (iteration < maxiterations) {
    fmllr_accs->Init(regtree.NumBaseclasses(), dim);
    fmllr_accs->SetZero();
    RegtreeFmllrDiagGmm *new_fmllr = new RegtreeFmllrDiagGmm();
    loglike = 0;
    for (size_t j = 0; j < adapt_feats.size(); j++) {
      loglike += fmllr_accs->AccumulateForGmm(regtree, *am, *adapt_feats[j], 0, 1.0);
      loglike += logdet[j]->operator()(0);
    }
    std::cout << "FMLLR: Loglikelihood before iteration " << iteration << " : "
              << std::scientific << loglike << '\n';

    fmllr_accs->Update(regtree, xform_opts, new_fmllr, NULL, NULL);
    std::cout << "Got " << new_fmllr->NumBaseClasses() << " baseclasses\n";
    bool binary = (RandUniform() < 0.5)? true : false;
    std::cout << "Writing the transform to disk.\n";
    new_fmllr->Write(Output("tmpf", binary).Stream(), binary);
    RegtreeFmllrDiagGmm *fmllr_read = new RegtreeFmllrDiagGmm();
    bool binary_in;
    Input ki("tmpf", &binary_in);
    std::cout << "Reading the transform from disk.\n";
    fmllr_read->Read(ki.Stream(), binary_in);
    fmllr_read->Validate();

    // transform features
    std::vector<Vector<BaseFloat> > trans_feats(1);
    Vector<BaseFloat> trans_logdet;
//    new_fmllr->ComputeLogDets();
    trans_logdet.Resize(fmllr_read->NumRegClasses());
    fmllr_read->GetLogDets(&trans_logdet);
    for (size_t j = 0; j < adapt_feats.size(); j++) {
      fmllr_read->TransformFeature(*adapt_feats[j], &trans_feats);
      logdet[j]->operator()(0) += trans_logdet(0);
      adapt_feats[j]->CopyFromVec(trans_feats[0]);
    }
    iteration++;
    delete new_fmllr;
    delete fmllr_read;
    
    unlink("tmpf");
  }

//  // transform features with empty transform
//  std::vector<Vector<BaseFloat> > trans_feats(1);
//  RegtreeFmllrDiagGmm *empty_fmllr = new RegtreeFmllrDiagGmm();
//  empty_fmllr->Init(0, 0);
//  for (size_t j = 0; j < adapt_feats.size(); j++) {
//    empty_fmllr->TransformFeature(*adapt_feats[j], &trans_feats);
//  }
//  delete empty_fmllr;

  // clean up
  delete fmllr_accs;
  delete est_am;
  delete am;
  delete gmm;
  DeletePointers(&logdet);
  DeletePointers(&train_feats);
  DeletePointers(&adapt_feats);
}

UnitTestRemoveRow()

static void kaldi::UnitTestRemoveRow ( )

static

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

References rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), Vector< Real >::RemoveElement(), Matrix< Real >::RemoveRow(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::SetRandn().

                                                        {

  // this is for matrix
  for (MatrixIndexT p = 0;p< 10;p++) {
    MatrixIndexT dimM = 10+Rand()%10, dimN = 10+Rand()%10;
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    MatrixIndexT i = Rand() % dimM;  // Row to remove.
    Matrix<Real> N(M);
    N.RemoveRow(i);
    for (MatrixIndexT j = 0;j < i;j++) {
      for (MatrixIndexT k = 0;k < dimN;k++) {
        KALDI_ASSERT(M(j, k) == N(j, k));
      }
    }
    for (MatrixIndexT j = i+1;j < dimM;j++) {
      for (MatrixIndexT k = 0;k < dimN;k++) {
        KALDI_ASSERT(M(j, k) == N(j-1, k));
      }
    }
  }

  // this is for vector
  for (MatrixIndexT p = 0;p< 10;p++) {
    MatrixIndexT dimM = 10+Rand()%10;
    Vector<Real> V(dimM);
    V.SetRandn();
    MatrixIndexT i = Rand() % dimM;  // Element to remove.
    Vector<Real> N(V);
    N.RemoveElement(i);
    for (MatrixIndexT j = 0;j < i;j++) {
      KALDI_ASSERT(V(j) == N(j));
    }
    for (MatrixIndexT j = i+1;j < dimM;j++) {
      KALDI_ASSERT(V(j) == N(j-1));
    }
  }

}

UnitTestReplaceValue()

static void kaldi::UnitTestReplaceValue ( )

static

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

References AssertEqual(), VectorBase< Real >::Dim(), rnnlm::i, Rand(), VectorBase< Real >::ReplaceValue(), and VectorBase< Real >::SetRandn().

                                  {
  // for vector
  MatrixIndexT dim = 10 + Rand() % 2;
  Real orig = 0.1 * (Rand() % 100), changed = 0.1 * (Rand() % 50);
  Vector<Real> V(dim);
  V.SetRandn();
  V(dim / 2) = orig;
  Vector<Real> V1(V);
  for (MatrixIndexT i = 0; i < V1.Dim(); i ++) {
    if (V1(i) == orig) V1(i) = changed;
  }
  V.ReplaceValue(orig, changed);
  AssertEqual(V, V1);
}

UnitTestResize()

static void kaldi::UnitTestResize ( )

static

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

References AssertEqual(), rnnlm::i, SpMatrix< Real >::IsZero(), MatrixBase< Real >::IsZero(), rnnlm::j, KALDI_ASSERT, kCopyData, kSetZero, Rand(), SpMatrix< Real >::Resize(), Vector< Real >::Resize(), Matrix< Real >::Resize(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::Sum().

                             {
  for (size_t i = 0; i < 10; i++) {
    MatrixIndexT dimM1 = Rand() % 10, dimN1 = Rand() % 10,
        dimM2 = Rand() % 10, dimN2 = Rand() % 10;
    if (dimM1*dimN1 == 0) dimM1 = dimN1 = 0;
    if (dimM2*dimN2 == 0) dimM2 = dimN2 = 0;
    for (MatrixIndexT j = 0; j < 3; j++) {
      MatrixResizeType resize_type = static_cast<MatrixResizeType>(j);
      Matrix<Real> M(dimM1, dimN1);
      M.SetRandn();
      Matrix<Real> Mcopy(M);
      Vector<Real> v(dimM1);
      v.SetRandn();
      Vector<Real> vcopy(v);
      SpMatrix<Real> S(dimM1);
      S.SetRandn();
      SpMatrix<Real> Scopy(S);
      M.Resize(dimM2, dimN2, resize_type);
      v.Resize(dimM2, resize_type);
      S.Resize(dimM2, resize_type);
      if (resize_type == kSetZero) {
        KALDI_ASSERT(S.IsZero());
        KALDI_ASSERT(v.Sum() == 0.0);
        KALDI_ASSERT(M.IsZero());
      } else if (resize_type == kCopyData) {
        for (MatrixIndexT i = 0; i < dimM2; i++) {
          if (i < dimM1) AssertEqual(v(i), vcopy(i));
          else KALDI_ASSERT(v(i) == 0);
          for (MatrixIndexT j = 0; j < dimN2; j++) {
            if (i < dimM1 && j < dimN1) AssertEqual(M(i, j), Mcopy(i, j));
            else AssertEqual(M(i, j), 0.0);
          }
          for (MatrixIndexT i2 = 0; i2 < dimM2; i2++) {
            if (i < dimM1 && i2 < dimM1) AssertEqual(S(i, i2), Scopy(i, i2));
            else AssertEqual(S(i, i2), 0.0);
          }
        }
      }
    }
  }
}

UnitTestResizeCopyDataDifferentStrideType()

static void kaldi::UnitTestResizeCopyDataDifferentStrideType ( )

static

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).

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

References AssertEqual(), rnnlm::i, kCopyData, kDefaultStride, kSetZero, kStrideEqualNumCols, PlaceNansInGaps(), Rand(), and Matrix< Real >::Resize().

                                                        {
  for (size_t i = 0; i < 10; i++) {
    MatrixIndexT num_rows = Rand() % 10, num_cols = Rand() % 10;
    if (num_rows * num_cols == 0) num_rows = num_cols = 0;
    MatrixStrideType src_stride_type = (Rand() % 2 == 0) ?
      kDefaultStride : kStrideEqualNumCols;
    // Always pick the other stride type.
    MatrixStrideType resize_stride_type = (src_stride_type == kDefaultStride) ?
      kStrideEqualNumCols : kDefaultStride;
    Matrix<Real> src(num_rows, num_cols, kSetZero, src_stride_type);
    Matrix<Real> clone(src);
    PlaceNansInGaps(&clone);
    src.Resize(num_rows, num_cols, kCopyData, resize_stride_type);
    PlaceNansInGaps(&src);
    AssertEqual(src, clone);
  }
}

UnitTestRoundUpToNearestPowerOfTwo()

void kaldi::UnitTestRoundUpToNearestPowerOfTwo

(

)

Definition at line 47 of file kaldi-math-test.cc.

References KALDI_ASSERT, and RoundUpToNearestPowerOfTwo().

Referenced by main().

                                          {
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(1) == 1);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(2) == 2);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(3) == 4);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(4) == 4);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(7) == 8);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(8) == 8);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(255) == 256);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(256) == 256);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(257) == 512);
  KALDI_ASSERT(RoundUpToNearestPowerOfTwo(1073700000) == 1073741824);
}

UnitTestRow()

static void kaldi::UnitTestRow ( )

static

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

References AssertEqual(), VectorBase< Real >::CopyColFromMat(), VectorBase< Real >::CopyRowFromMat(), rnnlm::i, InitRandNonsingular(), rnnlm::j, and Rand().

                                                  {

  for (MatrixIndexT p = 0;p< 10;p++) {
    MatrixIndexT dimM = 10+Rand()%10, dimN = 10+Rand()%10;
    Matrix<Real> M(dimM, dimN);
    InitRandNonsingular(&M);

    MatrixIndexT i = Rand() % dimM;  // Row to get.

    Vector<Real> V(dimN);
    V.CopyRowFromMat(M, i);  // get row.
    for (MatrixIndexT k = 0;k < dimN;k++) {
      AssertEqual(M(i, k), V(k));
    }

    {
      SpMatrix<Real> S(dimN);
      InitRandNonsingular(&S);
      Vector<Real> v1(dimN), v2(dimN);
      Matrix<Real> M(S);
      MatrixIndexT dim2 = Rand() % dimN;
      v1.CopyRowFromSp(S, dim2);
      v2.CopyRowFromMat(M, dim2);
      AssertEqual(v1, v2);
    }

    MatrixIndexT j = Rand() % dimN;  // Col to get.
    Vector<Real> W(dimM);
    W.CopyColFromMat(M, j);  // get row.
    for (MatrixIndexT k = 0;k < dimM;k++) {
      AssertEqual(M(k, j), W(k));
    }

  }
}

UnitTestScale()

static void kaldi::UnitTestScale ( )

static

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

References MatrixBase< Real >::CopyFromMat(), rnnlm::i, rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::MulColsVec(), MatrixBase< Real >::MulRowsVec(), Rand(), MatrixBase< Real >::Scale(), VectorBase< Real >::SetRandn(), and MatrixBase< Real >::Sum().

                                                    {

  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = (Rand()%10) + 10;
    MatrixIndexT dimN = (Rand()%10) + 10;

    Matrix<Real> M(dimM, dimN);

    Matrix<Real> N(M);
    float f = (float)((Rand()%10)-5);
    M.Scale(f);
    KALDI_ASSERT(M.Sum() == f * N.Sum());

    {
      // now test scale_rows
      M.CopyFromMat(N);  // make same.
      Vector<Real> V(dimM);
      V.SetRandn();
      M.MulRowsVec(V);
      for (MatrixIndexT i = 0; i < dimM;i++)
        for (MatrixIndexT j = 0;j < dimN;j++)
          KALDI_ASSERT(M(i, j) - N(i, j)*V(i) < 0.0001);
    }

    {
      // now test scale_cols
      M.CopyFromMat(N);  // make same.
      Vector<Real> V(dimN);
      V.SetRandn();
      M.MulColsVec(V);
      for (MatrixIndexT i = 0; i < dimM;i++)
        for (MatrixIndexT j = 0;j < dimN;j++)
          KALDI_ASSERT(M(i, j) - N(i, j)*V(j) < 0.0001);
    }

  }
}

UnitTestScaleDiag()

static void kaldi::UnitTestScaleDiag ( )

static

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

References AssertEqual(), rnnlm::i, Rand(), PackedMatrix< Real >::ScaleDiag(), and PackedMatrix< Real >::SetRandn().

                                                        {

  MatrixIndexT N = 1 + Rand() % 10;
  SpMatrix<Real> S(N);
  S.SetRandn();
  SpMatrix<Real> S2(S);
  S.ScaleDiag(0.5);
  for (MatrixIndexT i = 0; i  < N; i++) S2(i, i) *= 0.5;
  AssertEqual(S, S2);
}

UnitTestSearch()

static void kaldi::UnitTestSearch ( )

static

Definition at line 289 of file pitch-functions-test.cc.

References AssertEqual(), ComputeKaldiPitch(), rnnlm::i, KALDI_LOG, M_2PI, rnnlm::n, PitchExtractionOptions::nccf_ballast_online, RandGauss(), and PitchExtractionOptions::samp_freq.

Referenced by UnitTestFeatNoKeele().

                             {
  KALDI_LOG << "=== UnitTestSearch() ===\n";
  for (int32 n = 0; n < 3; n++) {
    // the parametrization object
    PitchExtractionOptions op;
    op.nccf_ballast_online = true;  // this is necessary for the computation
    // to be identical regardless how many pieces we break the signal into.

    int32 size = 1000 + rand() % 1000;

    Vector<BaseFloat> v(size);
    // init with noise plus a sine-wave whose frequency is changing randomly.

    double cur_freq = 200.0, normalized_time = 0.0;

    for (int32 i = 0; i < size; i++) {
      v(i) = RandGauss() + cos(normalized_time * M_2PI);
      cur_freq += RandGauss();  // let the frequency wander a little.
      if (cur_freq < 100.0) cur_freq = 100.0;
      if (cur_freq > 300.0) cur_freq = 300.0;
      normalized_time += cur_freq / op.samp_freq;
    }

    Matrix<BaseFloat> m1;
    ComputeKaldiPitch(op, v, &m1);

    pitch_use_naive_search = true;

    Matrix<BaseFloat> m2;
    ComputeKaldiPitch(op, v, &m2);

    pitch_use_naive_search = false;

    AssertEqual(m1, m2, 1.0e-08);  // should be identical.
  }
  KALDI_LOG << "Test passed :)\n";
}

UnitTestSetDiag()

static void kaldi::UnitTestSetDiag ( )

static

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

References AssertEqual(), Rand(), and PackedMatrix< Real >::SetDiag().

                                                      {

  MatrixIndexT N = 1 + Rand() % 10;
  SpMatrix<Real> S(N), T(N);
  S.SetUnit();
  S.ScaleDiag(0.5);
  T.SetDiag(0.5);
  AssertEqual(S, T);

}

UnitTestSetRandn()

static void kaldi::UnitTestSetRandn ( )

static

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

References MatrixBase< Real >::ApplyPow(), DoubleFactorial(), rnnlm::i, KALDI_ASSERT, Rand(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::Sum().

                               {
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT rows = 100 + Rand() % 50, cols = 100 + Rand() % 50;
    Matrix<Real> M(rows, cols);
    M.SetRandn();

    for (MatrixIndexT pow = 1; pow < 5; pow++) {
      // test moments 1 through 4 of
      // the distribution.
      Matrix<Real> Mpow(M);
      Mpow.ApplyPow(pow);
      Real observed_moment = Mpow.Sum() / (rows * cols);
      // see http://en.wikipedia.org/wiki/Normal_distribution#Moments,
      // note that mu = 0 and sigma = 1.
      Real expected_moment = (pow % 2 == 1 ? 0 : DoubleFactorial(pow - 1));
      Real k = 10.0; // This is just a constant we use to give us some wiggle
                     // room before rejecting the distribution... e.g. 10 sigma,
                     // quite approximately.
      Real allowed_deviation = k * pow / sqrt(static_cast<Real>(rows * cols));
      // give it a bit more wiggle room for higher powers.. this is quite
      // unscientific, it would be better to involve the absolute moments or
      // something like that, and use one of those statistical inequalities,
      // but it involves the gamma function and it's too much hassle to implement.
      Real lower_bound = expected_moment - allowed_deviation,
          upper_bound = expected_moment + allowed_deviation;
      KALDI_ASSERT(observed_moment >= lower_bound && observed_moment <= upper_bound);
    }
  }
}

UnitTestSetRandUniform()

static void kaldi::UnitTestSetRandUniform ( )

static

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

References MatrixBase< Real >::Add(), MatrixBase< Real >::ApplyPow(), VectorBase< Real >::Dim(), rnnlm::i, KALDI_ASSERT, Rand(), MatrixBase< Real >::SetRandUniform(), and MatrixBase< Real >::Sum().

                                     {
  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT rows = 200 + Rand() % 50, cols = 200 + Rand() % 50;
    Matrix<Real> M(rows, cols);
    M.SetRandUniform();

    M.Add(-0.5); // we'll be testing the central moments, so
    // center it around zero first.
    // Got these moments from http://mathworld.wolfram.com/UniformDistribution.html
    Vector<Real> central_moments(5);
    central_moments(0) = 0.0;
    central_moments(1) = 0.0;
    central_moments(2) = 1.0 / 12; // times (b - a)^2, which equals 1.
    central_moments(3) = 0.0;
    central_moments(4) = 1.0 / 80; // times (b - a)^4, which equals 1.

    for (MatrixIndexT pow = 1; pow < central_moments.Dim(); pow++) {
      Matrix<Real> Mpow(M);
      Mpow.ApplyPow(pow);
      Real observed_moment = Mpow.Sum() / (rows * cols);
      // see http://en.wikipedia.org/wiki/Normal_distribution#Moments,
      // note that mu = 0 and sigma = 1.
      Real expected_moment = central_moments(pow);
      Real k = 10.0; // This is just a constant we use to give us some wiggle
                     // room before rejecting the distribution... e.g. 10 sigma,
                     // quite approximately.
      Real allowed_deviation = k / sqrt(static_cast<Real>(rows * cols));
      Real lower_bound = expected_moment - allowed_deviation,
          upper_bound = expected_moment + allowed_deviation;
      KALDI_ASSERT(observed_moment >= lower_bound && observed_moment <= upper_bound);
    }
  }
}

UnitTestSetZeroAboveDiag()

static void kaldi::UnitTestSetZeroAboveDiag ( )

static

Definition at line 60 of file cu-test.cc.

References CuMatrixBase< Real >::CopyToMat(), rnnlm::i, rnnlm::j, KALDI_LOG, MatrixBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetZeroAboveDiag().

                                       {
  for (MatrixIndexT i = 1; i < 10; i++) {
    MatrixIndexT dim = 10 * i;
    Matrix<Real> A(dim,dim);
    A.SetRandn();
    CuMatrix<Real> B(A);

    B.SetZeroAboveDiag();

    Real sum = 0.0;
    for (MatrixIndexT i = 0; i < dim; i++) {
      for (MatrixIndexT j = i + 1; j < dim; j++)
        sum += A(i,j);
    }

    KALDI_LOG << "the upper diaganoal sum for A is : " << sum;
    B.CopyToMat(&A);
    sum = 0.0;
    for (MatrixIndexT i = 0; i < dim; i++) {
      for (MatrixIndexT j = i + 1; j < dim; j++)
        sum += A(i,j);
    }
    KALDI_LOG << "the upper diaganoal sum for B is : " << sum;
  }
}

UnitTestSger()

static void kaldi::UnitTestSger ( )

static

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

References MatrixBase< Real >::AddVecVec(), KALDI_ASSERT, rnnlm::n, Rand(), and VectorBase< Real >::SetRandn().

                                                   {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixIndexT dimM = 10 + Rand() % 10;
    MatrixIndexT dimN = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), M2(dimM, dimN);
    Vector<Real> v1(dimM); v1.SetRandn();
    Vector<Real> v2(dimN); v2.SetRandn();
    Vector<double> v1d(v1), v2d(v2);
    M.AddVecVec(1.0f, v1, v2);
    M2.AddVecVec(1.0f, v1, v2);
    for (MatrixIndexT m = 0;m < dimM;m++)
      for (MatrixIndexT n = 0;n < dimN;n++) {
        KALDI_ASSERT(M(m, n) - v1(m)*v2(n) < 0.01);
        KALDI_ASSERT(M(m, n) - M2(m, n) < 0.01);
      }
  }
}

UnitTestSigmoid()

static void kaldi::UnitTestSigmoid ( )

static

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

References AssertEqual(), MatrixBase< Real >::DiffSigmoid(), Exp(), rnnlm::i, Rand(), and MatrixBase< Real >::Sigmoid().

                                                       {
  for (MatrixIndexT i = 0; i < 10; i++) {
    MatrixIndexT dimM = 5 + Rand() % 10, dimN = 5 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), P(dimM, dimN), Q(dimM, dimN), R(dimM, dimN);
    M.SetRandn();
    P.SetRandn();
    Matrix<Real> N(M);
    for(int32 r = 0; r < dimM; r++) {
      for (int32 c = 0; c < dimN; c++) {
        Real x = N(r, c),
            y = 1.0 / (1 + Exp(-x));
        N(r, c) = y;
        Real out_diff = P(r, c), in_diff = out_diff * y * (1.0 - y);
        Q(r, c) = in_diff;
      }
    }
    M.Sigmoid(M);
    R.DiffSigmoid(N, P);
    AssertEqual(M, N);
    AssertEqual(Q, R);
  }
}

UnitTestSimple() [1/2]

static void kaldi::UnitTestSimple ( )

static

Definition at line 52 of file pitch-functions-test.cc.

References ComputeAndProcessKaldiPitch(), VectorBase< Real >::Dim(), rnnlm::i, and KALDI_LOG.

                             {
  KALDI_LOG << "=== UnitTestSimple() ===";
  Vector<BaseFloat> v(1000);
  Matrix<BaseFloat> m1, m2;
  // init with noise
  for (int32 i = 0; i < v.Dim(); i++) {
    v(i) = (abs(i * 433024253) % 65535) - (65535 / 2);
  }
  KALDI_LOG << "<<<=== Just make sure it runs... Nothing is compared";
  // trying to compute and process pitch with same opts as baseline.
  PitchExtractionOptions op1;
  ProcessPitchOptions op2;
  ComputeAndProcessKaldiPitch(op1, op2, v, &m1);
  KALDI_LOG << "Test passed :)";
}

UnitTestSimple() [2/2]

static void kaldi::UnitTestSimple ( )

static

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

References MatrixBase< Real >::ApplyExp(), VectorBase< Real >::ApplyLogAndCopy(), AssertEqual(), VectorBase< Real >::Dim(), Exp(), rnnlm::i, MatrixBase< Real >::IsDiagonal(), MatrixBase< Real >::IsSymmetric(), MatrixBase< Real >::IsUnit(), MatrixBase< Real >::IsZero(), rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::SetUnit(), and MatrixBase< Real >::SetZero().

Referenced by UnitTestFeat(), and UnitTestFeatNoKeele().

                                                      {
  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = 20 + Rand()%10, dimN = 20 + Rand()%20;
    Matrix<Real> M(dimM, dimN);
    M.SetUnit();
    KALDI_ASSERT(M.IsUnit());
    KALDI_ASSERT(!M.IsZero());
    KALDI_ASSERT(M.IsDiagonal());

    SpMatrix<Real> S(dimM);
    S.SetRandn();
    Matrix<Real> N(S);
    KALDI_ASSERT(!N.IsDiagonal());  // technically could be diagonal, but almost infinitely unlikely.
    KALDI_ASSERT(N.IsSymmetric());
    KALDI_ASSERT(!N.IsUnit());
    KALDI_ASSERT(!N.IsZero());

    M.SetZero();
    KALDI_ASSERT(M.IsZero());
    Vector<Real> V(dimM*dimN);
    V.SetRandn();
    Vector<Real> V2(V), V3(dimM*dimN);
    V2.ApplyExp();
    AssertEqual(V.Sum(), V2.SumLog());
    V3.ApplyLogAndCopy(V2);
    V2.ApplyLog();
    AssertEqual(V, V2);
    AssertEqual(V3, V2);

    {
      Vector<Real> V2(V);
      for (MatrixIndexT i = 0; i < V2.Dim(); i++)
        V2(i) = Exp(V2(i));
      V.ApplyExp();
      AssertEqual(V, V2);
    }
    {
      Matrix<Real> N2(N), N3(N);
      for (MatrixIndexT i = 0; i < N.NumRows(); i++)
        for (MatrixIndexT j = 0; j < N.NumCols(); j++)
          N2(i, j) = Exp(N2(i, j));
      N3.ApplyExp();
      AssertEqual(N2, N3);
    }
    KALDI_ASSERT(!S.IsDiagonal());
    KALDI_ASSERT(!S.IsUnit());
    N.SetUnit();
    S.CopyFromMat(N);
    KALDI_ASSERT(S.IsDiagonal());
    KALDI_ASSERT(S.IsUnit());
    N.SetZero();
    S.CopyFromMat(N);
    KALDI_ASSERT(S.IsZero());
    KALDI_ASSERT(S.IsDiagonal());
  }
}

UnitTestSimpleForMat()

static void kaldi::UnitTestSimpleForMat ( )

static

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

References MatrixBase< Real >::Add(), SpMatrix< Real >::AddVec2(), MatrixBase< Real >::ApplySoftMax(), AssertEqual(), VectorBase< Real >::Data(), rnnlm::i, InitRandNonsingular(), rnnlm::j, KALDI_ASSERT, MatrixBase< Real >::LogDet(), MatrixBase< Real >::LogSumExp(), MatrixBase< Real >::MulElements(), rnnlm::n, Rand(), MatrixBase< Real >::RowData(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), PackedMatrix< Real >::SetZero(), and MatrixBase< Real >::Sum().

                                   {  // test some simple operates on all kinds of matrix

  for (MatrixIndexT p = 0; p < 10; p++) {
    // for FrobeniousNorm() function
    MatrixIndexT dimM = 10 + Rand() % 10, dimN = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    {
      Matrix<Real> N(M);
      Real a = M.LogSumExp(), b = N.ApplySoftMax();
      AssertEqual(a, b);
      AssertEqual(1.0, N.Sum());
    }
    {
      Matrix<Real> N(M);
      N.Add(2.0);
      for (MatrixIndexT m = 0; m < dimM; m++)
        for (MatrixIndexT n = 0; n < dimN; n++)
          N(m, n) -= 2.0;
      AssertEqual(M, N);
    }

    Matrix<Real> N(M), M1(M);
    M1.MulElements(M);
    Real tmp1 = sqrt(M1.Sum());
    Real tmp2 = N.FrobeniusNorm();
    KALDI_ASSERT(std::abs(tmp1 - tmp2) < 0.00001);

    // for LargestAbsElem() function
    Vector<Real> V(dimM);
    for (MatrixIndexT i = 0; i < dimM; i++) {
      for (MatrixIndexT j = 0; j < dimN; j++) {
        M(i, j) = std::abs(M(i, j));
      }
      std::sort(M.RowData(i), M.RowData(i) + dimN);
      V(i) = M(i, dimN - 1);
    }
    std::sort(V.Data(), V.Data() + dimM);
    KALDI_ASSERT(std::abs(V(dimM - 1) - N.LargestAbsElem()) < 0.00001);
  }

  SpMatrix<Real> x(3);
  x.SetZero();

  std::stringstream ss;

  ss << "DP 3\n";
  ss << "4.6863" << '\n';
  ss << "3.7062 4.6032" << '\n';
  ss << "3.4160 3.7256  5.2474" << '\n';

  ss >> x;
  KALDI_ASSERT(x.IsPosDef() == true);  // test IsPosDef() function

  TpMatrix<Real> y(3);
  y.SetZero();
  y.Cholesky(x);


  // test sp-matrix's LogPosDefDet() function
  Matrix<Real> B(x);
  Real tmp;
  Real *DetSign = &tmp;
  KALDI_ASSERT(std::abs(B.LogDet(DetSign) - x.LogPosDefDet()) < 0.00001);

  for (MatrixIndexT p = 0; p < 10; p++) {  // test for sp and tp matrix's AddSp() and AddTp() function
    MatrixIndexT dimM = 10 + Rand() % 10;
    SpMatrix<Real> S(dimM), S1(dimM);
    TpMatrix<Real> T(dimM), T1(dimM);
    S.SetRandn();
    S1.SetRandn();
    T.SetRandn();
    T1.SetRandn();
    Matrix<Real> M(S), M1(S1), N(T), N1(T1);

    S.AddSp(1.0, S1);
    T.AddTp(1.0, T1);
    M.AddMat(1.0, M1);
    N.AddMat(1.0, N1);
    Matrix<Real> S2(S);
    Matrix<Real> T2(T);

    AssertEqual(S2, M);
    AssertEqual(T2, N);
  }

  for (MatrixIndexT i = 0; i < 10; i++) {  // test for sp matrix's AddVec2() function
    MatrixIndexT dimM = 10 + Rand() % 10;
    SpMatrix<Real> M(dimM);
    Vector<Real> V(dimM);

    InitRandNonsingular(&M);
    SpMatrix<double> Md(M);
    V.SetRandn();
    SpMatrix<Real> Sorig(M);
    M.AddVec2(0.5, V);
    Md.AddVec2(static_cast<Real>(0.5), V);
    for (MatrixIndexT i = 0; i < dimM; i++)
      for (MatrixIndexT j = 0; j < dimM; j++) {
        KALDI_ASSERT(std::abs(M(i, j) - (Sorig(i, j)+0.5*V(i)*V(j))) < 0.001);
        KALDI_ASSERT(std::abs(Md(i, j) - (Sorig(i, j)+0.5*V(i)*V(j))) < 0.001);
      }
  }
}

UnitTestSimpleForVec()

static void kaldi::UnitTestSimpleForVec ( )

static

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

References VectorBase< Real >::AddColSumMat(), VectorBase< Real >::AddVecDivVec(), VectorBase< Real >::ApplyLogSoftMax(), AssertEqual(), VectorBase< Real >::CopyColFromMat(), VectorBase< Real >::CopyFromVec(), Exp(), rnnlm::i, VectorBase< Real >::IsZero(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, VectorBase< Real >::MulElements(), VectorBase< Real >::Norm(), Rand(), RandUniform(), VectorBase< Real >::Scale(), VectorBase< Real >::Set(), MatrixBase< Real >::SetRandn(), and VectorBase< Real >::Sum().

                                   {  // testing some simple operators on vector

  for (MatrixIndexT i = 0; i < 5; i++) {
    Vector<Real> V(100), V1(100), V2(100), V3(100), V4(100);
    V.SetRandn();
    if (i % 2 == 0) {
      V1.SetZero();
      V1.Add(1.0);
    } else {
      V1.Set(1.0);
    }

    V2.CopyFromVec(V);
    V3.CopyFromVec(V1);
    V2.InvertElements();
    V3.DivElements(V);
    V4.CopyFromVec(V3);
    V4.AddVecDivVec(1.0, V1, V, 0.0);
    AssertEqual(V3, V2);
    AssertEqual(V4, V3);
    V4.MulElements(V);
    AssertEqual(V4, V1);
    V3.AddVecVec(1.0, V, V2, 0.0);
    AssertEqual(V3, V1);

    Vector<Real> V5(V), V6(V1), V7(V1), V8(V);
    V5.AddVec(1.0, V);
    V8.Scale(2.0);
    V6.AddVec2(1.0, V);
    V7.AddVecVec(1.0, V, V, 1.0);
    AssertEqual(V6, V7);
    AssertEqual(V5, V8);
  }

  for (MatrixIndexT i = 0; i < 5; i++) {
    std::vector<MatrixIndexT> sizes;
    sizes.push_back(16);
    sizes.push_back(128);
    for(int i = 0; i < sizes.size(); i++) {
      MatrixIndexT dimM = sizes[i] + Rand() % 10, dimN = sizes[i] + Rand() % 10;
      Matrix<Real> M(dimM, dimN);
      M.SetRandn();
      Vector<Real> Vr(dimN), Vc(dimM);
      Vr.AddRowSumMat(0.4, M);
      Vr.AddRowSumMat(0.3, M, 0.5); // note: 0.3 + 0.4*0.5 = 0.5.
      Vc.AddColSumMat(0.4, M);
      Vc.AddColSumMat(0.3, M, 0.5); // note: 0.3 + 0.4*0.5 = 0.5.
      Vr.Scale(2.0);
      Vc.Scale(2.0);
      KALDI_LOG << Vr;
      KALDI_LOG << Vc;

      Vector<Real> V2r(dimN), V2c(dimM);
      for (MatrixIndexT k = 0; k < dimM; k++) {
        V2r.CopyRowFromMat(M, k);
        KALDI_ASSERT(fabs(V2r.Sum() - Vc(k)) < 0.01);
      }
      for (MatrixIndexT j = 0; j < dimN; j++) {
        V2c.CopyColFromMat(M, j);
        KALDI_ASSERT(fabs(V2c.Sum() - Vr(j)) < 0.01);
      }
    }
  }

  for (MatrixIndexT i = 0; i < 5; i++) {
    Vector<Real> V(100), V1(100), V2(100);
    V.SetRandn();

    V1.CopyFromVec(V);
    V1.ApplyExp();
    Real a = V.LogSumExp();
    V2.Set(Exp(V.LogSumExp()));
    V1.DivElements(V2);
    V2.CopyFromVec(V);

    Real b = V.ApplySoftMax();
    AssertEqual(V1, V);
    AssertEqual(a, b);

    V.ApplyLog();
    Real c = V2.ApplyLogSoftMax();
    AssertEqual(V2, V);
    AssertEqual(a, c);
  }

  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimV = 10 + Rand() % 10;
    Real p = 0.5 + RandUniform() * 4.5;
    Vector<Real> V(dimV), V1(dimV), V2(dimV);
    V.SetRandn();
    V1.AddVecVec(1.0, V, V, 0.0);  // V1:=V.*V.
    V2.CopyFromVec(V1);
    AssertEqual(V1.Norm(p), V2.Norm(p));
    AssertEqual(sqrt(V1.Sum()), V.Norm(2.0));
  }

  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimV = 10 + Rand() % 10;
    Real p = RandUniform() * 1.0e-5;
    Vector<Real> V(dimV);
    V.Set(p);
    KALDI_ASSERT(V.IsZero(p));
    KALDI_ASSERT(!V.IsZero(p*0.9));
  }

  // Test ApplySoftMax() for matrix.
  Matrix<Real> M(10, 10);
  M.SetRandn();
  M.ApplySoftMax();
  KALDI_ASSERT( fabs(1.0 - M.Sum()) < 0.01);

}

UnitTestSimpleOptions()

void kaldi::UnitTestSimpleOptions

(

)

Definition at line 24 of file simple-options-test.cc.

References SimpleOptions::GetOptionType(), KALDI_ASSERT, SimpleOptions::kInt32, SimpleOptions::Register(), and SimpleOptions::SetOption().

Referenced by main().

                             {
  std::string str="default_for_str";
  int32 num = 1;
  uint32 unum = 2;
  float realnum = 0.1;
  bool flag = false;
  bool rval;
  SimpleOptions so;

  so.Register("num", &num, "Description of num");
  so.Register("unum", &unum, "Description of unum");
  so.Register("str", &str, "Description of str");
  so.Register("flag", &flag, "Description of flag");
  so.Register("realnum", &realnum, "Description of realnum");

  rval = so.SetOption("num", 42);
  KALDI_ASSERT(rval);
  so.SetOption("unum", static_cast<uint32>(43));
  KALDI_ASSERT(rval);
  rval = so.SetOption("str", (std::string)"foo");
  KALDI_ASSERT(rval);
  rval = so.SetOption("flag", false);
  KALDI_ASSERT(rval);

  KALDI_ASSERT(num == 42);
  KALDI_ASSERT(unum == 43);
  KALDI_ASSERT(str == "foo");
  KALDI_ASSERT(flag == false);

  rval = so.SetOption("str", "foo2");
  KALDI_ASSERT(rval);
  KALDI_ASSERT(str == "foo2");

  // test automatic conversion between int and uint
  rval = so.SetOption("unum", 44);
  KALDI_ASSERT(rval);
  KALDI_ASSERT(unum == 44);

  // test automatic conversion between float and double
  rval = so.SetOption("realnum", static_cast<float>(0.2));
  KALDI_ASSERT(rval);
  KALDI_ASSERT(realnum - 0.2 < 0.000001);
  rval = so.SetOption("realnum", static_cast<double>(0.3));
  KALDI_ASSERT(rval);
  KALDI_ASSERT(realnum - 0.3 < 0.000001);

  SimpleOptions::OptionType type;
  rval = so.GetOptionType("num", &type);
  KALDI_ASSERT(rval);
  KALDI_ASSERT(type == SimpleOptions::kInt32);

  rval = so.GetOptionType("xxxx", &type);
  KALDI_ASSERT(rval == false);
}

UnitTestSnipEdges()

static void kaldi::UnitTestSnipEdges ( )

static

Definition at line 71 of file pitch-functions-test.cc.

References ApproxEqual(), AssertEqual(), ComputeAndProcessKaldiPitch(), VectorBase< Real >::CopyColFromMat(), WaveData::Data(), PitchExtractionOptions::frame_length_ms, PitchExtractionOptions::frame_shift_ms, KALDI_ASSERT, KALDI_ERR, KALDI_LOG, KALDI_WARN, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), WaveData::Read(), WaveData::SampFreq(), PitchExtractionOptions::snip_edges, and VecVec().

Referenced by UnitTestFeatNoKeele().

                                {
  KALDI_LOG << "=== UnitTestSnipEdges() ===\n";
  PitchExtractionOptions op_SnipEdges, op_NoSnipEdges;
  Matrix<BaseFloat> m1, m2;
  ProcessPitchOptions opp;
  int nbad = 0;

  // Load test wave file
  WaveData wave;
  {
    std::ifstream is("test_data/test.wav");
    wave.Read(is);
  }
  KALDI_ASSERT(wave.Data().NumRows() == 1);
  SubVector<BaseFloat> waveform(wave.Data(), 0);

  // Process files with snip edge enabled or disabled, on various
  // frame shifts and frame lengths
  for (int fs = 4; fs <= 10; fs += 2) {
    for (int wl = 20; wl <= 100; wl += 20) {
      // Rather dirty way to round, but works fine
      int32 ms_fs = (int32)(wave.SampFreq() * 0.001 * fs + 0.5);
      int32 ms_wl = (int32)(wave.SampFreq() * 0.001 * wl + 0.5);
      op_SnipEdges.snip_edges = true;
      op_SnipEdges.frame_shift_ms = fs;
      op_SnipEdges.frame_length_ms = wl;
      op_NoSnipEdges.snip_edges = false;
      op_NoSnipEdges.frame_shift_ms = fs;
      op_NoSnipEdges.frame_length_ms = wl;
      ComputeAndProcessKaldiPitch(op_SnipEdges, opp, waveform, &m1);
      ComputeAndProcessKaldiPitch(op_NoSnipEdges, opp, waveform, &m2);

      // Check the output differ in a predictable manner:
      // 1. The length of the output should only depend on the window size & window shift
      KALDI_LOG << "Output: " << m1.NumRows() << " ; " << m2.NumRows();
      //   - with snip edges disabled, depends on file size and frame shift only */
      AssertEqual(m2.NumRows(), ((int)(wave.Data().NumCols() + ms_fs / 2)) / ms_fs);
      //   - with snip edges disabled, depend on file size, frame shift, frame length */
      AssertEqual(m1.NumRows(), ((int)(wave.Data().NumCols() - ms_wl + ms_fs)) / ms_fs);
      // 2. The signal should be delayed in a predictable manner
      Vector<BaseFloat> f0_1(m1.NumRows());
      f0_1.CopyColFromMat(m1, 1);
      Vector<BaseFloat> f0_2(m2.NumRows());
      f0_2.CopyColFromMat(m2, 1);

      BaseFloat bcorr = -1;
      int32 blag = -1;
      int32 max_lag =  wl / fs * 2;
      int num_frames_f0 = m1.NumRows() - max_lag;

      /* Looks for the best correlation between the output signals,
         identify the lag, compares it with theoretical value */
      SubVector<BaseFloat> sub_vec1(f0_1, 0, num_frames_f0);
      for (int32 lag = 0; lag < max_lag + 1; lag++) {
        SubVector<BaseFloat> sub_vec2(f0_2, lag, num_frames_f0);
        BaseFloat corr = VecVec(sub_vec1, sub_vec2);
        if (corr > bcorr) {
          bcorr = corr;
          blag = lag;
        }
      }
      KALDI_LOG << "Best lag: " << blag * fs << "ms with value: " << bcorr <<
        "; expected lag: " << wl / 2 + 10 - fs / 2 << " ± " << fs;
      // BP: the lag should in theory be equal to wl / 2 - fs / 2, but it seems
      // to be: wl / 2 + 10 - fs / 2! It appears the 10 ms comes from the nccf_lag which
      // is 82 samples with the default settings => nccf_lag / resample_freq / 2 => 10.25ms
      // We should really be using the full_frame_length of the algorithm for accurate results,
      // but there is no method to obtain it (and it is potentially variable), so that makes
      // the pitch value *with snip edge* particularly unreliable.
      if (!ApproxEqual(blag * fs, (BaseFloat)(wl / 2 + 10 - fs / 2), (BaseFloat)fs / wl)) {
        KALDI_WARN << "Bad lag for window size " << wl << " and frame shift " << fs;
        nbad++;
      }
      /*AssertEqual(blag * fs, (BaseFloat)(wl / 2 + 10 - fs / 2), (BaseFloat)fs / wl);*/
    }
  }
  /* If more than 10% of tests fail, crash */
  if (nbad > 9) KALDI_ERR << "Too many bad lags: " << nbad;

}

UnitTestSoftHinge()

static void kaldi::UnitTestSoftHinge ( )

static

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

References AssertEqual(), Exp(), rnnlm::i, Log1p(), Rand(), and MatrixBase< Real >::SoftHinge().

                                                         {
  for (MatrixIndexT i = 0; i < 10; i++) {
    MatrixIndexT dimM = 5 + Rand() % 10, dimN = 5 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), N(dimM, dimN), O(dimM, dimN);
    M.SetRandn();
    M.Scale(20.0);

    for(int32 r = 0; r < dimM; r++) {
      for (int32 c = 0; c < dimN; c++) {
        Real x = M(r, c);
        Real &y = N(r, c);
        if (x > 10.0) y = x;
        else y = Log1p(Exp(x));
      }
    }
    O.SoftHinge(M);
    AssertEqual(N, O);
  }
}

UnitTestSolve()

static void kaldi::UnitTestSolve ( )

static

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

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatSp(), VectorBase< Real >::AddSpVec(), AssertEqual(), SolverOptions::diagonal_precondition, rnnlm::i, SpMatrix< Real >::Invert(), KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, SolverOptions::optimize_delta, Rand(), RandPosdefSpMatrix(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), SolveDoubleQuadraticMatrixProblem(), SolveQuadraticMatrixProblem(), SolveQuadraticProblem(), TraceMatMat(), TraceMatSpMat(), TraceMatSpMatSp(), VecSpVec(), and VecVec().

                                                    {

  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = (Rand()%10) + 10;
    MatrixIndexT dimN = dimM - (Rand()%3);  // slightly lower-dim.

    SpMatrix<Real> H(dimM);
    Matrix<Real> M(dimM, dimN);
    M.SetRandn();
    H.AddMat2(1.0, M, kNoTrans, 0.0);  // H = M M^T

    Vector<Real> x(dimM);
    x.SetRandn();
    Vector<Real> tmp(dimM);
    tmp.SetRandn();
    Vector<Real> g(dimM);
    g.AddSpVec(1.0, H, tmp, 0.0); // Limit to subspace that H is in.
    Vector<Real> x2(x), x3(x);
    SolverOptions opts2, opts3;
    opts2.diagonal_precondition = Rand() % 2;
    opts2.optimize_delta = Rand() % 2;
    opts3.diagonal_precondition = Rand() % 2;
    opts3.optimize_delta = Rand() % 2;

    double ans2 =  SolveQuadraticProblem(H, g, opts2, &x2),
        ans3 = SolveQuadraticProblem(H, g, opts3, &x3);

    double observed_impr2 = (VecVec(x2, g) -0.5* VecSpVec(x2, H, x2)) -
        (VecVec(x, g) -0.5* VecSpVec(x, H, x)),
        observed_impr3 =  (VecVec(x3, g) -0.5* VecSpVec(x3, H, x3)) -
        (VecVec(x, g) -0.5* VecSpVec(x, H, x));
    AssertEqual(observed_impr2, ans2);
    AssertEqual(observed_impr3, ans3);
    KALDI_ASSERT(ans2 >= 0);
    KALDI_ASSERT(ans3 >= 0);
    KALDI_ASSERT(std::abs(ans2 - ans3) / std::max(ans2, ans3) < 0.01);
    //AssertEqual(x2, x3);
    //AssertEqual(ans1, ans2);
  }


  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = (Rand() % 10) + 10;
    MatrixIndexT dimN = dimM - (Rand() % 3); // slightly lower-dim.
    MatrixIndexT dimO = (Rand() % 10) + 10;

    SpMatrix<Real> Q(dimM), SigmaInv(dimO);
    Matrix<Real> Mtmp(dimM, dimN);
    Mtmp.SetRandn();
    Q.AddMat2(1.0, Mtmp, kNoTrans, 0.0); // H = M M^T

    Matrix<Real> Ntmp(dimO, dimN);
    Ntmp.SetRandn();
    SigmaInv.AddMat2(1.0, Ntmp, kNoTrans, 0.0); // H = M M^T

    Matrix<Real> M(dimO, dimM), Y(dimO, dimM);
    M.SetRandn();
    Y.SetRandn();

    Matrix<Real> M2(M);

    SpMatrix<Real> Qinv(Q);
    if (Q.Cond() < 1000.0) Qinv.Invert();

    SolverOptions opts;
    opts.optimize_delta = Rand() % 2;
    opts.diagonal_precondition = Rand() % 2;
    double ans = SolveQuadraticMatrixProblem(Q, Y, SigmaInv, opts, &M2);

    Matrix<Real> M3(M);
    M3.AddMatSp(1.0, Y, kNoTrans, Qinv, 0.0);
    if (Q.Cond() < 1000.0) {
      AssertEqual(M2, M3);  // This equality only holds if SigmaInv full-rank,
      // which is overwhelmingly likely if dimO > dimM
    }

    {
      Real a1 = TraceMatSpMat(M2, kTrans, SigmaInv, Y, kNoTrans),
          a2 = TraceMatSpMatSp(M2, kNoTrans, Q, M2, kTrans, SigmaInv),
          b1 = TraceMatSpMat(M, kTrans, SigmaInv, Y, kNoTrans),
          b2 = TraceMatSpMatSp(M, kNoTrans, Q, M, kTrans, SigmaInv),
          a3 = a1 - 0.5 * a2,
          b3 = b1 - 0.5 * b2;
      KALDI_ASSERT(a3 >= b3);
      AssertEqual(a3 - b3, ans);
      // KALDI_LOG << "a3 = " << a3 << ", b3 = " << b3 << ", c3 = " << c3;
    }  // Check objf not decreased.
  }

  for (MatrixIndexT i = 0; i < 5; i++) {
    MatrixIndexT dimM = (Rand() % 10) + 10;
    MatrixIndexT dimO = (Rand() % 10) + 10;

    SpMatrix<Real> Q1(dimM), Q2(dimM), P1(dimO), P2(dimO);
    RandPosdefSpMatrix(dimM, &Q1);
    RandPosdefSpMatrix(dimM, &Q2);
    RandPosdefSpMatrix(dimO, &P1);
    RandPosdefSpMatrix(dimO, &P1);

    Matrix<Real> M(dimO, dimM), G(dimO, dimM);
    M.SetRandn();
    G.SetRandn();
    //    InitRandNonsingular(&M);
    //    InitRandNonsingular(&G);

    Matrix<Real> M2(M);

    SolverOptions opts;
    opts.optimize_delta = Rand() % 2;
    SolveDoubleQuadraticMatrixProblem(G, P1, P2, Q1, Q2, opts, &M2);

    {
      Real a1 = TraceMatMat(M2, G, kTrans),
          a2 = TraceMatSpMatSp(M2, kNoTrans, Q1, M2, kTrans, P1),
          a3 = TraceMatSpMatSp(M2, kNoTrans, Q2, M2, kTrans, P2),
          b1 = TraceMatMat(M, G, kTrans),
          b2 = TraceMatSpMatSp(M, kNoTrans, Q1, M, kTrans, P1),
          b3 = TraceMatSpMatSp(M, kNoTrans, Q2, M, kTrans, P2),
          a4 = a1 - 0.5 * a2 - 0.5 * a3,
          b4 = b1 - 0.5 * b2 - 0.5 * b3;
      KALDI_LOG << "a4 = " << a4 << ", b4 = " << b4;
      KALDI_ASSERT(a4 >= b4);
    }  // Check objf not decreased.
  }
}

UnitTestSpAddDiagVec()

static void kaldi::UnitTestSpAddDiagVec ( )

static

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

References SpMatrix< Real >::AddDiagVec(), AssertEqual(), rnnlm::i, Rand(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                   {
  for (MatrixIndexT i = 0;i< 10;i++) {
    BaseFloat alpha = (i<5 ? 1.0 : 0.5);
    MatrixIndexT dimM = 10+Rand()%10;
    SpMatrix<Real> S(dimM);
    S.SetRandn();
    SpMatrix<Real> T(S);
    Vector<OtherReal> v(dimM);
    v.SetRandn();
    S.AddDiagVec(alpha, v);
    for (MatrixIndexT i = 0; i < dimM; i++)
      T(i, i) += alpha * v(i);
    AssertEqual(S, T);
  }
}

UnitTestSpAddVecVec()

static void kaldi::UnitTestSpAddVecVec ( )

static

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

References SpMatrix< Real >::AddVecVec(), MatrixBase< Real >::AddVecVec(), AssertEqual(), rnnlm::i, Rand(), VectorBase< Real >::SetRandn(), and PackedMatrix< Real >::SetRandn().

                                  {
  for (MatrixIndexT i = 0;i< 10;i++) {
    BaseFloat alpha = (i<5 ? 1.0 : 0.5);
    MatrixIndexT dimM = 10+Rand()%10;
    SpMatrix<Real> S(dimM);
    S.SetRandn();
    Matrix<Real> T(S);

    Vector<Real> v(dimM), w(dimM);
    v.SetRandn();
    w.SetRandn();
    S.AddVecVec(alpha, v, w);
    T.AddVecVec(alpha, v, w);
    T.AddVecVec(alpha, w, v);
    Matrix<Real> U(S);
    AssertEqual(U, T);
  }
}

UnitTestSparseMatrixAddToMat()

void kaldi::UnitTestSparseMatrixAddToMat

(

)

Definition at line 152 of file sparse-matrix-test.cc.

References MatrixBase< Real >::AddMat(), SparseMatrix< Real >::AddToMat(), AssertEqual(), SparseMatrix< Real >::CopyToMat(), rnnlm::i, Rand(), MatrixBase< Real >::SetRandn(), and SparseMatrix< Real >::SetRandn().

                                    {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    SparseMatrix<Real> smat(row, col);
    smat.SetRandn(0.8);

    Matrix<Real> mat(row, col);
    mat.SetRandn();
    smat.CopyToMat(&mat);

    Matrix<Real> other_mat1(row, col);
    other_mat1.SetRandn();
    Matrix<Real> other_mat2 = other_mat1;

    smat.AddToMat(0.7, &other_mat1);
    other_mat2.AddMat(0.7, mat);
    AssertEqual(other_mat1, other_mat2, 0.00001);
  }
}

UnitTestSparseMatrixConstructor()

void kaldi::UnitTestSparseMatrixConstructor

(

)

Definition at line 175 of file sparse-matrix-test.cc.

References AssertEqual(), SparseMatrix< Real >::CopyToMat(), RandGauss(), RandInt(), and MatrixBase< Real >::SetRandn().

                                       {
  int32 num_rows = RandInt(1, 10),
      num_cols = RandInt(0, 10);
  if (num_cols == 0)
    num_rows = 0;

  Matrix<Real> mat(num_rows, num_cols);

  for (int32 r = 0; r < num_rows; r++) {
    for (int32 c = 0; c < num_cols; c++) {
      if (RandInt(0, 5) == 0)
        mat(r, c) = RandGauss();
    }
  }
  SparseMatrix<Real> smat(mat);

  Matrix<Real> mat2(num_rows, num_cols);
  mat2.SetRandn();
  smat.CopyToMat(&mat2);
  AssertEqual(mat, mat2);
}

UnitTestSparseMatrixFrobeniusNorm()

void kaldi::UnitTestSparseMatrixFrobeniusNorm

(

)

Definition at line 133 of file sparse-matrix-test.cc.

References AssertEqual(), SparseMatrix< Real >::CopyToMat(), SparseMatrix< Real >::FrobeniusNorm(), MatrixBase< Real >::FrobeniusNorm(), rnnlm::i, Rand(), MatrixBase< Real >::SetRandn(), and SparseMatrix< Real >::SetRandn().

                                         {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    SparseMatrix<Real> smat(row, col);
    smat.SetRandn(0.8);

    Matrix<Real> mat(row, col);
    mat.SetRandn();
    smat.CopyToMat(&mat);

    Real norm1 = smat.FrobeniusNorm();
    Real norm2 = mat.FrobeniusNorm();
    AssertEqual(norm1, norm2, 0.00001);
  }
}

UnitTestSparseMatrixSum()

void kaldi::UnitTestSparseMatrixSum

(

)

Definition at line 114 of file sparse-matrix-test.cc.

References AssertEqual(), SparseMatrix< Real >::CopyToMat(), rnnlm::i, Rand(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), SparseMatrix< Real >::Sum(), and MatrixBase< Real >::Sum().

                               {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    SparseMatrix<Real> smat(row, col);
    smat.SetRandn(0.8);

    Matrix<Real> mat(row, col);
    mat.SetRandn();
    smat.CopyToMat(&mat);

    Real sum1 = smat.Sum();
    Real sum2 = mat.Sum();
    AssertEqual(sum1, sum2, 0.00001);
  }
}

UnitTestSparseMatrixTraceMatSmat()

void kaldi::UnitTestSparseMatrixTraceMatSmat

(

)

Definition at line 198 of file sparse-matrix-test.cc.

References AssertEqual(), SparseMatrix< Real >::CopyToMat(), rnnlm::i, kNoTrans, kTrans, Rand(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), TraceMatMat(), and TraceMatSmat().

                                        {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT row = 10 + Rand() % 40;
    MatrixIndexT col = 10 + Rand() % 50;

    Matrix<Real> mat1(row, col);
    Matrix<Real> mat2(col, row);
    Matrix<Real> mat3(row, col);
    mat1.SetRandn();
    mat2.SetRandn();
    mat3.SetRandn();

    SparseMatrix<Real> smat1(row, col);
    SparseMatrix<Real> smat2(col, row);
    smat1.SetRandn(0.8);
    smat2.SetRandn(0.8);

    smat1.CopyToMat(&mat1);
    smat2.CopyToMat(&mat2);

    Real trace1 = TraceMatMat(mat3, mat1, kTrans);
    Real trace2 = TraceMatSmat(mat3, smat1, kTrans);
    AssertEqual(trace1, trace2, 0.00001);

    trace1 = TraceMatMat(mat3, mat2, kNoTrans);
    trace2 = TraceMatSmat(mat3, smat2, kNoTrans);
    AssertEqual(trace1, trace2, 0.00001);
  }
}

UnitTestSparseVectorAddToVec()

void kaldi::UnitTestSparseVectorAddToVec

(

)

Definition at line 44 of file sparse-matrix-test.cc.

References SparseVector< Real >::AddToVec(), VectorBase< Real >::AddVec(), AssertEqual(), SparseVector< Real >::CopyElementsToVec(), rnnlm::i, Rand(), VectorBase< Real >::SetRandn(), and SparseVector< Real >::SetRandn().

                                    {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT dim = 10 + Rand() % 40;

    SparseVector<Real> svec(dim);
    svec.SetRandn(0.8);

    Vector<Real> vec(dim);
    vec.SetRandn();
    svec.CopyElementsToVec(&vec);

    Vector<Real> other_vec1(dim);
    other_vec1.SetRandn();
    Vector<Real> other_vec2 = other_vec1;

    svec.AddToVec(0.7, &other_vec1);
    other_vec2.AddVec(0.7, vec);
    AssertEqual(other_vec1, other_vec2, 0.00001);
  }
}

UnitTestSparseVectorMax()

void kaldi::UnitTestSparseVectorMax

(

)

Definition at line 66 of file sparse-matrix-test.cc.

References AssertEqual(), SparseVector< Real >::CopyElementsToVec(), rnnlm::i, SparseVector< Real >::Max(), VectorBase< Real >::Max(), Rand(), RandInt(), VectorBase< Real >::SetRandn(), and SparseVector< Real >::SetRandn().

                               {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT dim = 10 + Rand() % 40;
    if (RandInt(0, 3) == 0)
      dim = RandInt(1, 5);

    SparseVector<Real> svec(dim);
    if (RandInt(0, 3) != 0)
      svec.SetRandn(0.8);

    Vector<Real> vec(dim);
    vec.SetRandn();
    svec.CopyElementsToVec(&vec);

    int32 index1, index2;
    Real max1, max2;

    max1 = svec.Max(&index1);
    max2 = vec.Max(&index2);

    AssertEqual(max1, max2, 0.00001);
    AssertEqual(index1, index2, 0.00001);
  }
}

UnitTestSparseVectorSum()

void kaldi::UnitTestSparseVectorSum

(

)

Definition at line 26 of file sparse-matrix-test.cc.

References AssertEqual(), SparseVector< Real >::CopyElementsToVec(), rnnlm::i, Rand(), VectorBase< Real >::SetRandn(), SparseVector< Real >::SetRandn(), SparseVector< Real >::Sum(), and VectorBase< Real >::Sum().

                               {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT dim = 10 + Rand() % 40;

    SparseVector<Real> svec(dim);
    svec.SetRandn(0.8);

    Vector<Real> vec(dim);
    vec.SetRandn();
    svec.CopyElementsToVec(&vec);

    Real sum1 = svec.Sum();
    Real sum2 = vec.Sum();
    AssertEqual(sum1, sum2, 0.00001);
  }
}

UnitTestSparseVectorVecSvec()

void kaldi::UnitTestSparseVectorVecSvec

(

)

Definition at line 92 of file sparse-matrix-test.cc.

References SparseVector< Real >::CopyElementsToVec(), rnnlm::i, KALDI_ASSERT, Rand(), VectorBase< Real >::SetRandn(), SparseVector< Real >::SetRandn(), VecSvec(), and VecVec().

                                   {
  for (int32 i = 0; i < 10; i++) {
    MatrixIndexT dim = 10 + Rand() % 40;

    SparseVector<Real> svec(dim);
    svec.SetRandn(0.8);

    Vector<Real> vec(dim);
    vec.SetRandn();
    svec.CopyElementsToVec(&vec);

    Vector<Real> other_vec(dim);
    other_vec.SetRandn();

    Real product1 = VecSvec(other_vec, svec);
    Real product2 = VecVec(other_vec, vec);

    KALDI_ASSERT(fabs(product1 - product2) < 1.0e-04);
  }
}

UnitTestSpInvert()

static void kaldi::UnitTestSpInvert ( )

static

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

References MatrixBase< Real >::AddMatMat(), SpMatrix< Real >::CopyFromSp(), rnnlm::i, SpMatrix< Real >::Invert(), SpMatrix< Real >::InvertDouble(), MatrixBase< Real >::IsUnit(), rnnlm::j, KALDI_ASSERT, kNoTrans, PackedMatrix< Real >::NumRows(), Rand(), and RandGauss().

                                                        {
  for (MatrixIndexT i = 0;i < 30;i++) {
    MatrixIndexT dimM = 6 + Rand()%20;
    SpMatrix<Real> M(dimM);
    for (MatrixIndexT i = 0;i < M.NumRows();i++)
      for (MatrixIndexT j = 0;j<=i;j++) M(i, j) = RandGauss();
    SpMatrix<Real> N(dimM);
    N.CopyFromSp(M);
    if (Rand() % 2 == 0)
      N.Invert();
    else
      N.InvertDouble();
    Matrix<Real> Mm(dimM, dimM), Nm(dimM, dimM), Om(dimM, dimM);
    Mm.CopyFromSp(M); Nm.CopyFromSp(N);
    Om.AddMatMat(1.0, Mm, kNoTrans, Nm, kNoTrans, 0.0);
    KALDI_ASSERT(Om.IsUnit( 0.01*dimM ));
  }
}

UnitTestSpliceRows()

static void kaldi::UnitTestSpliceRows ( )

static

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

References AssertEqual(), VectorBase< Real >::CopyColFromMat(), MatrixBase< Real >::CopyColFromVec(), VectorBase< Real >::CopyColsFromMat(), MatrixBase< Real >::CopyColsFromVec(), VectorBase< Real >::CopyDiagFromMat(), MatrixBase< Real >::CopyDiagFromVec(), VectorBase< Real >::CopyRowFromMat(), MatrixBase< Real >::CopyRowFromVec(), VectorBase< Real >::CopyRowsFromMat(), MatrixBase< Real >::CopyRowsFromVec(), rnnlm::i, rnnlm::j, KALDI_ASSERT, and Rand().

                                                         {

  for (MatrixIndexT i = 0;i< 10;i++) {
    MatrixIndexT dimM = 10+Rand()%10, dimN = 10+Rand()%10;

    Vector<Real> V(dimM*dimN), V10(dimM*dimN);
    Vector<Real> Vs(std::min(dimM, dimN)), Vs10(std::min(dimM, dimN));
    V.SetRandn();
    Matrix<Real> M(dimM, dimN);
    M.CopyRowsFromVec(V);
    V10.CopyRowsFromMat(M);
    AssertEqual(V, V10);

    for (MatrixIndexT i = 0;i < dimM;i++)
      for (MatrixIndexT  j = 0;j < dimN;j++)
        KALDI_ASSERT(M(i, j) == V(i*dimN + j));

    {
      Vector<Real> V2(dimM), V3(dimM);
      V2.SetRandn();
      MatrixIndexT x;
      M.CopyColFromVec(V2, x = (Rand() % dimN));
      V3.CopyColFromMat(M, x);
      AssertEqual(V2, V3);
    }

    {
      Vector<Real> V2(dimN), V3(dimN);
      V2.SetRandn();
      MatrixIndexT x;
      M.CopyRowFromVec(V2, x = (Rand() % dimM));
      V3.CopyRowFromMat(M, x);
      AssertEqual(V2, V3);
    }

    {
      M.CopyColsFromVec(V);
      V10.CopyColsFromMat(M);
      AssertEqual(V, V10);
    }

    {
      M.CopyDiagFromVec(Vs);
      Vs10.CopyDiagFromMat(M);
      AssertEqual(Vs, Vs10);
    }

  }
}

UnitTestSplitRadixComplexFft()

static void kaldi::UnitTestSplitRadixComplexFft ( )

static

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

References AssertEqual(), ComplexFt(), SplitRadixComplexFft< Real >::Compute(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Data(), Rand(), and VectorBase< Real >::Scale().

                                                                   {

  // Make sure it inverts properly.
  for (MatrixIndexT N_ = 0; N_ < 30; N_+=3) {
    MatrixIndexT logn = 1 + Rand() % 10;
    MatrixIndexT N = 1 << logn;

    MatrixIndexT twoN = 2*N;
    std::vector<Real> temp_buffer;
    SplitRadixComplexFft<Real> srfft(N), srfft2(srfft);
    for (MatrixIndexT p = 0; p < 3; p++) {
      Vector<Real> v(twoN), w_base(twoN), w_alg(twoN), x_base(twoN), x_alg(twoN);

      v.SetRandn();

      if (N< 100) ComplexFt(v, &w_base, true);
      w_alg.CopyFromVec(v);

      if (Rand() % 2 == 0)
        srfft.Compute(w_alg.Data(), true);
      else
        srfft2.Compute(w_alg.Data(), true, &temp_buffer);

      if (N< 100) AssertEqual(w_base, w_alg, 0.01*N);

      if (N< 100) ComplexFt(w_base, &x_base, false);
      x_alg.CopyFromVec(w_alg);
      srfft.Compute(x_alg.Data(), false);

      if (N< 100) AssertEqual(x_base, x_alg, 0.01*N);
      x_alg.Scale(1.0/N);
      AssertEqual(v, x_alg, 0.001*N);
    }
  }
}

UnitTestSplitRadixComplexFft2()

static void kaldi::UnitTestSplitRadixComplexFft2 ( )

static

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

References ApproxEqual(), SplitRadixComplexFft< Real >::Compute(), VectorBase< Real >::CopyFromVec(), KALDI_ASSERT, and Rand().

                                                                    {

  // Make sure it inverts properly.
  for (MatrixIndexT p = 0; p < 30; p++) {
    MatrixIndexT logn = 1 + Rand() % 10;
    MatrixIndexT N = 1 << logn;
    SplitRadixComplexFft<Real> srfft(N);
    for (MatrixIndexT q = 0; q < 3; q++) {
      Vector<Real> v(N*2), vorig(N*2);
      v.SetRandn();
      vorig.CopyFromVec(v);
      srfft.Compute(v.Data(), true);  // forward
      srfft.Compute(v.Data(), false);  // backward
      v.Scale(1.0/N);
      KALDI_ASSERT(ApproxEqual(v, vorig));
    }
  }
}

UnitTestSplitRadixRealFft()

static void kaldi::UnitTestSplitRadixRealFft ( )

static

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

References AssertEqual(), SplitRadixRealFft< Real >::Compute(), VectorBase< Real >::CopyFromVec(), VectorBase< Real >::Data(), Rand(), RealFftInefficient(), and VectorBase< Real >::Scale().

                                                                {

  for (MatrixIndexT p = 0; p < 30; p++) {
    MatrixIndexT logn = 2 + Rand() % 9,
        N = 1 << logn;

    SplitRadixRealFft<Real> srfft(N), srfft2(srfft);
    std::vector<Real> temp_buffer;
    for (MatrixIndexT q = 0; q < 3; q++) {
      Vector<Real> v(N), w(N), x(N), y(N);
      v.SetRandn();
      w.CopyFromVec(v);
      RealFftInefficient(&w, true);
      y.CopyFromVec(v);
      if (Rand() % 2 == 0)
        srfft.Compute(y.Data(), true);
      else
        srfft2.Compute(y.Data(), true, &temp_buffer);

      // KALDI_LOG <<"v = "<<v;
      // KALDI_LOG << "Inefficient real fft of v is: "<< w;
      // KALDI_LOG << "Efficient real fft of v is: "<< y;
      AssertEqual(w, y, 0.01*N);
      x.CopyFromVec(w);
      RealFftInefficient(&x, false);
      srfft.Compute(y.Data(), false);
      // KALDI_LOG << "Inefficient real fft of v twice is: "<< x;
      x.Scale(1.0/N);
      y.Scale(1.0/N);
      AssertEqual(v, x, 0.001*N);
      AssertEqual(v, y, 0.001*N);  // ?
    }
  }
}

UnitTestSplitRadixRealFftSpeed() [1/2]

static void kaldi::UnitTestSplitRadixRealFftSpeed ( )

static

Definition at line 50 of file matrix-lib-speed-test.cc.

References SplitRadixRealFft< Real >::Compute(), VectorBase< Real >::Data(), Timer::Elapsed(), rnnlm::i, and KALDI_LOG.

                                                                     {
  Timer t;
  MatrixIndexT sz = 512;  // fairly typical size.
  SplitRadixRealFft<Real> srfft(sz);
  for (MatrixIndexT i = 0; i < 6000; i++) {
    if (i % 1000 == 0)
      KALDI_LOG << "done 1000 [ == ten seconds of speech, split-radix]";
    Vector<Real> v(sz);
    srfft.Compute(v.Data(), true);
  }
  CsvResult<Real>(__func__, 512, t.Elapsed(), "seconds");
}

UnitTestSplitRadixRealFftSpeed() [2/2]

static void kaldi::UnitTestSplitRadixRealFftSpeed ( )

static

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

References SplitRadixRealFft< Real >::Compute(), VectorBase< Real >::Data(), rnnlm::i, and KALDI_LOG.

                                                                     {
  KALDI_LOG << "starting. ";
  MatrixIndexT sz = 512;  // fairly typical size.
  SplitRadixRealFft<Real> srfft(sz);
  for (MatrixIndexT i = 0; i < 6000; i++) {
    if (i % 1000 == 0)
      KALDI_LOG << "done 1000 [ == ten seconds of speech, split-radix]";
    Vector<Real> v(sz);
    srfft.Compute(v.Data(), true);
  }
}

UnitTestSpVec()

static void kaldi::UnitTestSpVec ( )

static

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

References AssertEqual(), and PackedMatrix< Real >::CopyFromVec().

                                                    {
  // Test conversion back and forth between SpMatrix and Vector.
  for (MatrixIndexT iter = 0;iter < 1;iter++) {
    MatrixIndexT dimM =10;  // 20 + Rand()%10;
    SpMatrix<Real> A(dimM), B(dimM);
    SubVector<Real> vec(A);
    B.CopyFromVec(vec);
    AssertEqual(A, B);
  }
}

UnitTestSubvector()

static void kaldi::UnitTestSubvector ( )

static

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

References AssertEqual(), VectorBase< Real >::CopyFromVec(), rnnlm::i, and VectorBase< Real >::SetRandn().

                                                        {

  Vector<Real> V(100);
  V.SetRandn();
  Vector<Real> V2(100);
  for (MatrixIndexT i = 0;i < 10;i++) {
    SubVector<Real> tmp(V, i*10, 10);
    SubVector<Real> tmp2(V2, i*10, 10);
    tmp2.CopyFromVec(tmp);
  }
  AssertEqual(V, V2);
}

UnitTestSvd()

static void kaldi::UnitTestSvd ( )

static

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

References MatrixBase< Real >::AddMatMatMat(), AssertEqual(), MatrixBase< Real >::CopyDiagFromVec(), MatrixBase< Real >::CopyFromMat(), KALDI_LOG, kNoTrans, Rand(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::SetZero().

                                                  {
  MatrixIndexT Base = 3, Rand_ = 2, Iter = 25;
  for (MatrixIndexT iter = 0;iter < Iter;iter++) {
    MatrixIndexT dimM = Base + Rand() % Rand_, dimN =  Base + Rand() % Rand_;
    Matrix<Real> M(dimM, dimN);
    Matrix<Real> U(dimM, std::min(dimM, dimN)), Vt(std::min(dimM, dimN), dimN);
    Vector<Real> s(std::min(dimM, dimN));
    M.SetRandn();
    if (iter < 2) KALDI_LOG << "M " << M;
    Matrix<Real> M2(dimM, dimN); M2.CopyFromMat(M);
    M.Svd(&s, &U, &Vt);
    if (iter < 2) {
      KALDI_LOG << " s " << s;
      KALDI_LOG << " U " << U;
      KALDI_LOG << " Vt " << Vt;
    }
    MatrixIndexT min_dim = std::min(dimM, dimN);
    Matrix<Real> S(min_dim, min_dim);
    S.CopyDiagFromVec(s);
    Matrix<Real> Mtmp(dimM, dimN);
    Mtmp.SetZero();
    Mtmp.AddMatMatMat(1.0, U, kNoTrans, S, kNoTrans, Vt, kNoTrans, 0.0);
    AssertEqual(Mtmp, M2);
  }
}

UnitTestSvdBad()

static void kaldi::UnitTestSvdBad ( )

static

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

References rnnlm::i, rnnlm::j, MatrixBase< Real >::Set(), MatrixBase< Real >::Svd(), and SpMatrix< Real >::SymPosSemiDefEig().

                                                     {
  MatrixIndexT N = 20;
  {
    Matrix<Real> M(N, N);
    // M.Set(1591.3614306764898);
    M.Set(1.0);
    M(0, 0) *= 1.000001;
    Matrix<Real> U(N, N), V(N, N);
    Vector<Real> l(N);
    M.Svd(&l, &U, &V);
  }
  SpMatrix<Real> M(N);
  for(MatrixIndexT i =0; i < N; i++)
    for(MatrixIndexT j = 0; j <= i; j++)
      M(i, j) = 1591.3614306764898;
  M(0, 0) *= 1.00001;
  M(10, 10) *= 1.00001;
  Matrix<Real> U(N, N);
  Vector<Real> l(N);
  M.SymPosSemiDefEig(&l, &U);
}

UnitTestSvdJustvec()

static void kaldi::UnitTestSvdJustvec ( )

static

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

References AssertEqual(), Rand(), and MatrixBase< Real >::Svd().

                                                         {  // Making sure gives same answer if we get just the vector, not the eigs.
  MatrixIndexT Base = 10, Rand_ = 5, Iter = 25;
  for (MatrixIndexT iter = 0;iter < Iter;iter++) {
    MatrixIndexT dimM = Base + Rand() % Rand_, dimN =  Base + Rand() % Rand_;  // M>=N.
    MatrixIndexT minsz = std::min(dimM, dimN);

    Matrix<Real> M(dimM, dimN);
    Matrix<Real> U(dimM, minsz), Vt(minsz, dimN); Vector<Real> v(minsz);
    M.Svd(&v, &U, &Vt);
    Vector<Real> v2(minsz);
    M.Svd(&v2);
    AssertEqual(v, v2);
  }
}

UnitTestSvdNodestroy()

static void kaldi::UnitTestSvdNodestroy ( )

static

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

References MatrixBase< Real >::AddMatMat(), VectorBase< Real >::Dim(), rnnlm::i, rnnlm::j, KALDI_ASSERT, KALDI_LOG, kNoTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::SetRandn(), SortSvd(), and MatrixBase< Real >::Svd().

                                                           {
  MatrixIndexT Base = 3, Rand_ = 2, Iter = 25;
  for (MatrixIndexT iter = 0;iter < Iter;iter++) {
    MatrixIndexT dimN = Base + Rand() % Rand_, dimM =  dimN + Rand() % Rand_;  // M>=N, as required by JAMA Svd.
    MatrixIndexT minsz = std::min(dimM, dimN);
    Matrix<Real> M(dimM, dimN);
    Matrix<Real> U(dimM, minsz), Vt(minsz, dimN); Vector<Real> v(minsz);
    M.SetRandn();
    if (iter < 2) KALDI_LOG << "M " << M;
    M.Svd(&v, &U, &Vt);
    if (iter < 2) {
      KALDI_LOG << " v " << v;
      KALDI_LOG << " U " << U;
      KALDI_LOG << " Vt " << Vt;
    }

    for (MatrixIndexT it = 0;it < 2;it++) {
      Matrix<Real> Mtmp(minsz, minsz);
      for (MatrixIndexT i = 0;i < v.Dim();i++) Mtmp(i, i) = v(i);
      Matrix<Real> Mtmp2(minsz, dimN);
      Mtmp2.AddMatMat(1.0, Mtmp, kNoTrans, Vt, kNoTrans, 0.0);
      Matrix<Real> Mtmp3(dimM, dimN);
      Mtmp3.AddMatMat(1.0, U, kNoTrans, Mtmp2, kNoTrans, 0.0);
      for (MatrixIndexT i = 0;i < Mtmp.NumRows();i++) {
        for (MatrixIndexT j = 0;j < Mtmp.NumCols();j++) {
          KALDI_ASSERT(std::abs(Mtmp3(i, j) - M(i, j)) < 0.0001);
        }
      }

      SortSvd(&v, &U, &Vt);  // and re-check...
      for (MatrixIndexT i = 0; i + 1 < v.Dim(); i++) // check SortSvd is working.
        KALDI_ASSERT(std::abs(v(i+1)) <= std::abs(v(i)));
    }
  }
}

UnitTestSvdSpeed() [1/2]

static void kaldi::UnitTestSvdSpeed ( )

static

Definition at line 64 of file matrix-lib-speed-test.cc.

References SpMatrix< Real >::Eig(), Timer::Elapsed(), rnnlm::i, PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::Svd().

                               {
  Timer t;
  std::vector<MatrixIndexT> sizes;
  sizes.push_back(100);
  sizes.push_back(150);
  sizes.push_back(200);
  sizes.push_back(300);
  // sizes.push_back(500);
  // sizes.push_back(750);
  for (size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];
    {
      Timer t1;
      SpMatrix<Real> S(size);
      Vector<Real> l(size);
      S.Eig(&l);
      CsvResult<Real>("Eig w/o eigenvectors", size, t1.Elapsed(), "seconds");
    }
    {
      Timer t1;
      SpMatrix<Real> S(size);
      S.SetRandn();
      Vector<Real> l(size);
      Matrix<Real> P(size, size);
      S.Eig(&l, &P);
      CsvResult<Real>("Eig with eigenvectors", size, t1.Elapsed(), "seconds");
    }
    {
      Timer t1;
      Matrix<Real> M(size, size);
      M.SetRandn();
      Vector<Real> l(size);
      M.Svd(&l, NULL, NULL);
      CsvResult<Real>("SVD w/o eigenvectors", size, t1.Elapsed(), "seconds");
    }
    {
      Timer t1;
      Matrix<Real> M(size, size), U(size, size), V(size, size);
      M.SetRandn();
      Vector<Real> l(size);
      M.Svd(&l, &U, &V);
      CsvResult<Real>("SVD with eigenvectors", size, t1.Elapsed(), "seconds");
    }
  }
  CsvResult<Real>(__func__, sizes.size(), t.Elapsed(), "seconds");
}

UnitTestSvdSpeed() [2/2]

static void kaldi::UnitTestSvdSpeed ( )

static

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

References SpMatrix< Real >::Eig(), rnnlm::i, KALDI_LOG, PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and MatrixBase< Real >::Svd().

                               {
  std::vector<MatrixIndexT> sizes;
  sizes.push_back(100);
  sizes.push_back(150);
  sizes.push_back(200);
  sizes.push_back(300);
  sizes.push_back(500);
  sizes.push_back(750);
  sizes.push_back(1000);
  sizes.push_back(2000);
  time_t start, end;
  for (size_t i = 0; i < sizes.size(); i++) {
    MatrixIndexT size = sizes[i];
    {
      start = time(NULL);
      SpMatrix<Real> S(size);
      Vector<Real> l(size);
      S.Eig(&l);
      end = time(NULL);
      double diff = difftime(end, start);
      KALDI_LOG << "For size " << size << ", Eig without eigenvectors took " << diff
                << " seconds.";
    }
    {
      start = time(NULL);
      SpMatrix<Real> S(size);
      S.SetRandn();
      Vector<Real> l(size);
      Matrix<Real> P(size, size);
      S.Eig(&l, &P);
      end = time(NULL);
      double diff = difftime(end, start);
      KALDI_LOG << "For size " << size << ", Eig with eigenvectors took " << diff
                << " seconds.";
    }
    {
      start = time(NULL);
      Matrix<Real> M(size, size);
      M.SetRandn();
      Vector<Real> l(size);
      M.Svd(&l, NULL, NULL);
      end = time(NULL);
      double diff = difftime(end, start);
      KALDI_LOG << "For size " << size << ", SVD without eigenvectors took " << diff
                << " seconds.";
    }
    {
      start = time(NULL);
      Matrix<Real> M(size, size), U(size, size), V(size, size);
      M.SetRandn();
      Vector<Real> l(size);
      M.Svd(&l, &U, &V);
      end = time(NULL);
      double diff = difftime(end, start);
      KALDI_LOG << "For size " << size << ", SVD with eigenvectors took " << diff
                << " seconds.";
    }
  }
}

UnitTestSvdZero()

static void kaldi::UnitTestSvdZero ( )

static

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

References MatrixBase< Real >::CopyFromMat(), KALDI_ASSERT, KALDI_LOG, Rand(), and MatrixBase< Real >::SetZero().

                                                      {
  MatrixIndexT Base = 3, Rand_ = 2, Iter = 30;
  for (MatrixIndexT iter = 0;iter < Iter;iter++) {
    MatrixIndexT dimM = Base + Rand() % Rand_, dimN =  Base + Rand() % Rand_;  // M>=N.
    Matrix<Real> M(dimM, dimN);
    Matrix<Real> U(dimM, dimM), Vt(dimN, dimN); Vector<Real> v(std::min(dimM, dimN));
    if (iter%2 == 0) M.SetZero();
    else M.Unit();
    if (iter < 2) KALDI_LOG << "M " << M;
    Matrix<Real> M2(dimM, dimN); M2.CopyFromMat(M);
    bool ans = M.Svd(&v, &U, &Vt);
    KALDI_ASSERT(ans);  // make sure works with zero matrix.
  }
}

UnitTestSwapCu2Cu()

void kaldi::UnitTestSwapCu2Cu

(

)

Definition at line 2533 of file cu-matrix-test.cc.

References ApproxEqual(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), MatrixBase< Real >::SetRandn(), and CuMatrix< Real >::Swap().

                         {
  Matrix<Real> Hi(100,111);
  Hi.SetRandn();
  CuMatrix<Real> Di(100,111);
  Di.CopyFromMat(Hi);

  Matrix<Real> Hi2(110,121);
  Hi2.SetRandn();
  CuMatrix<Real> Di2(110,121);
  Di2.CopyFromMat(Hi2);

  Di.Swap(&Di2);
  Matrix<Real> Hf(Di.NumRows(), Di.NumCols());
  Di.CopyToMat(&Hf);
  Matrix<Real> Hf2(Di2.NumRows(), Di2.NumCols());
  Di2.CopyToMat(&Hf2);
  KALDI_ASSERT(ApproxEqual(Hi,Hf2));
  KALDI_ASSERT(ApproxEqual(Hi2,Hf));
}

UnitTestSwapCu2M()

void kaldi::UnitTestSwapCu2M

(

)

Definition at line 2554 of file cu-matrix-test.cc.

References ApproxEqual(), MatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyFromMat(), CuMatrixBase< Real >::CopyToMat(), KALDI_ASSERT, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), MatrixBase< Real >::SetRandn(), and CuMatrix< Real >::Swap().

                        {
  Matrix<Real> Hi(100,111);
  Hi.SetRandn();
  CuMatrix<Real> Di(100,111);
  Di.CopyFromMat(Hi);

  Matrix<Real> Hi2(110,121);
  Hi2.SetRandn();
  Matrix<Real> Di2(110,121);
  Di2.CopyFromMat(Hi2);

  Di.Swap(&Hi2);
  Matrix<Real> Hf(Di.NumRows(), Di.NumCols());
  Di.CopyToMat(&Hf);
  KALDI_ASSERT(ApproxEqual(Di2,Hf));
  KALDI_ASSERT(ApproxEqual(Hi2,Hi));
}

UnitTestSymAddMat2()

static void kaldi::UnitTestSymAddMat2 ( )

static

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

References MatrixBase< Real >::AddMatMat(), AssertEqual(), TpMatrix< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::SetRandn(), MatrixBase< Real >::Sum(), MatrixBase< Real >::SymAddMat2(), and Matrix< Real >::Transpose().

                                                         {
  for (int32 i = 0; i < 5; i++) {
    int32 dimM = 10 + Rand() % 200, dimN = 10 + Rand() % 30;
    KALDI_LOG << "dimM = " << dimM << ", dimN = " << dimN;

    Matrix<Real> M(dimM, dimM); // square matrix..
    Matrix<Real> N(dimM, dimN);
    M.SetRandn();
    N.SetRandn();
    //MatrixTransposeType trans = (i % 2 == 0 ? kTrans : kNoTrans),
    MatrixTransposeType trans = kTrans,
        other_trans = (trans == kTrans ? kNoTrans : kTrans);
    if (trans == kTrans) N.Transpose();
    KALDI_LOG << "N sum is " << N.Sum();
    Matrix<Real> M2(M);
    KALDI_LOG << "M sum is " << M.Sum();

    Real alpha = 0.2 * (Rand() % 6),
        beta = 0.2 * (Rand() % 6);
    //Real alpha = 0.3, beta = 1.75432;
    M.SymAddMat2(alpha, N, trans, beta);

    KALDI_LOG << "M(0, 0) is " << M(0, 0);
    KALDI_LOG << "M sum2 is " << M.Sum();

    M2.AddMatMat(alpha, N, trans, N, other_trans, beta);

    TpMatrix<Real> T1(M.NumRows()), T2(M2.NumRows());
    T1.CopyFromMat(M);
    T2.CopyFromMat(M2);
    Matrix<Real> X1(T1), X2(T2); // so we can test equality.
    AssertEqual(X1, X2);
    KALDI_ASSERT(dimM == 0 || X1.Trace() != 0 || (alpha == 0 && beta == 0));
  }
}

UnitTestTableRandomBothDouble()

void kaldi::UnitTestTableRandomBothDouble	(	bool	binary,
		bool	read_scp,
		bool	sorted,
		bool	called_sorted,
		bool	once
	)

Definition at line 768 of file kaldi-table-test.cc.

References ApproxEqual(), CharToString(), TableWriter< Holder >::Close(), RandomAccessTableReader< Holder >::HasKey(), rnnlm::i, KALDI_ASSERT, Rand(), RandomizeVector(), Uniq(), RandomAccessTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                               {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<double> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back((Rand() / static_cast<double>(Rand())));
  }

  if (!sorted)
    RandomizeVector(&k);


  bool ans;
  DoubleWriter bw(binary ? "b,f,ark,scp:tmpf,tmpf.scp" :
                  "t,f,ark,scp:tmpf,tmpf.scp");  // Putting the "flush" option
                                            // in too, just for good measure..
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);


  std::string name;
  if (sorted) name += "s,";
  else if (Rand()%2 == 0) name += "ns,";
  if (called_sorted) name += "cs,";
  else if (Rand()%2 == 0) name += "ncs,";
  if (once) name += "o,";
  else if (Rand()%2 == 0) name += "no,";
  name += std::string(read_scp ? "scp:tmpf.scp" : "ark:tmpf");

  RandomAccessDoubleReader sbr(name);

  if (sz != 0) {
    std::vector<std::string> read_keys;
    int32 read_sz = Rand() % 5;
    for (int32 i = 0; i < read_sz; i++)
      read_keys.push_back(k[Rand() % k.size()]);
    std::sort(read_keys.begin(), read_keys.end());
    if (once) Uniq(&read_keys);
    if (!called_sorted)
      RandomizeVector(&read_keys);

    for (size_t i = 0; i < read_keys.size(); i++) {
      std::cout << "Looking up key " << read_keys[i] << std::endl;
      std::string cur_key = read_keys[i];

      auto it = std::find(k.begin(), k.end(), cur_key);
      KALDI_ASSERT(it != k.end());
      size_t idx = std::distance(k.begin(), it);
      double value = v[idx];
      if (Rand() % 2 == 0) {
        bool ans = sbr.HasKey(cur_key);
        KALDI_ASSERT(ans == true);
      }
      if (binary) {
        KALDI_ASSERT(value == sbr.Value(cur_key));
      } else {
        KALDI_ASSERT(ApproxEqual(value, sbr.Value(cur_key)));
      }
    }
  }
}

UnitTestTableRandomBothDoubleMatrix()

void kaldi::UnitTestTableRandomBothDoubleMatrix	(	bool	binary,
		bool	read_scp,
		bool	sorted,
		bool	called_sorted,
		bool	once
	)

Definition at line 972 of file kaldi-table-test.cc.

References MatrixBase< Real >::ApproxEqual(), CharToString(), TableWriter< Holder >::Close(), RandomAccessTableReader< Holder >::HasKey(), rnnlm::i, rnnlm::j, KALDI_ASSERT, Rand(), RandomizeVector(), Uniq(), RandomAccessTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                    {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<Matrix<double> > v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.resize(v.size()+1);
    v.back().Resize(1 + Rand()%3, 1 + Rand()%3);
    for (int32 j = 0; j < v.back().NumRows(); j++)
      for (int32 k = 0; k < v.back().NumCols(); k++)
        v.back()(j, k) =  (Rand() % 100);
  }

  if (!sorted)
    RandomizeVector(&k);


  bool ans;
  DoubleMatrixWriter bw(binary ? "b,f,ark,scp:tmpf,tmpf.scp" :
                        "t,f,ark,scp:tmpf,tmpf.scp");  // Putting the "flush"
  // option in too, just for good measure..
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);


  std::string name;
  if (sorted) name += "s,";
  else if (Rand()%2 == 0) name += "ns,";
  if (called_sorted) name += "cs,";
  else if (Rand()%2 == 0) name += "ncs,";
  if (once) name += "o,";
  else if (Rand()%2 == 0) name += "no,";
  name += std::string(read_scp ? "scp:tmpf.scp" : "ark:tmpf");
  RandomAccessDoubleMatrixReader sbr(name);

  if (sz != 0) {
    std::vector<std::string> read_keys;
    int32 read_sz = Rand() % 5;
    for (int32 i = 0; i < read_sz; i++)
      read_keys.push_back(k[Rand() % k.size()]);
    std::sort(read_keys.begin(), read_keys.end());
    if (once) Uniq(&read_keys);
    if (!called_sorted)
      RandomizeVector(&read_keys);

    for (size_t i = 0; i < read_keys.size(); i++) {
      std::cout << "Looking up key " << read_keys[i] << std::endl;
      std::string cur_key = read_keys[i];
      Matrix<double> *value_ptr = NULL;
      for (size_t i = 0; i < k.size(); i++)
        if (cur_key == k[i]) value_ptr = &(v[i]);
      if (Rand() % 2 == 0) {
        bool ans = sbr.HasKey(cur_key);
        KALDI_ASSERT(ans == true);
      }
      if (binary) {
        KALDI_ASSERT(value_ptr->ApproxEqual(sbr.Value(cur_key), 1.0e-10));
      } else {
        KALDI_ASSERT(value_ptr->ApproxEqual(sbr.Value(cur_key), 0.01));
      }
    }
  }
  unlink("tmpf");
  unlink("tmpf.scp");
}

UnitTestTableSequentialBaseFloatVectorBoth()

void kaldi::UnitTestTableSequentialBaseFloatVectorBoth	(	bool	binary,
		bool	read_scp
	)

Definition at line 704 of file kaldi-table-test.cc.

References ApproxEqual(), CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandGauss(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                                            {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<Vector<BaseFloat>*> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back(new Vector<BaseFloat>(1 + Rand()%4));
    for (int32 i = 0; i < v.back()->Dim(); i++)
      (*(v.back()))(i) = RandGauss();
  }

  bool ans;
  BaseFloatVectorWriter bw(binary ? "b,ark,scp:tmpf,tmpf.scp" :
                           "t,ark,scp:tmpf,tmpf.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], *(v[i]));
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialBaseFloatVectorReader sbr(
      RandInt(0, 1) == 0 ?
      (read_scp ? "scp:tmpf.scp" : "ark:tmpf") :
      (read_scp ? "scp,bg:tmpf.scp" : "ark,bg:tmpf"));
  std::vector<std::string> k2;
  std::vector<Vector<BaseFloat>* > v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(new Vector<BaseFloat>(sbr.Value()));
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  if (binary) {
    for (size_t i = 0; i < v2.size(); i++)
      KALDI_ASSERT(v2[i]->ApproxEqual(*(v[i]), 1.0e-10));
  } else {
    KALDI_ASSERT(v2.size() == v.size());
    for (size_t i = 0; i < v2.size(); i++)
      KALDI_ASSERT(v2[i]->ApproxEqual(*(v[i])));
  }
  for (int32 i = 0; i < sz; i++) {
    delete v[i];
    delete v2[i];
  }
}

UnitTestTableSequentialBool()

void kaldi::UnitTestTableSequentialBool

(

bool

binary

)

Definition at line 356 of file kaldi-table-test.cc.

References CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                              {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<bool> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back((Rand()%2 == 0));
  }

  bool ans;
  BoolWriter bw(binary ? "b,ark:tmpf" : "t,ark:tmpf");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialBoolReader sbr(RandInt(0, 1) == 0 ? "ark:tmpf" : "ark,bg:tmpf");
  std::vector<std::string> k2;
  std::vector<bool> v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  KALDI_ASSERT(v2 == v);
}

UnitTestTableSequentialDouble()

void kaldi::UnitTestTableSequentialDouble

(

bool

binary

)

Definition at line 390 of file kaldi-table-test.cc.

References ApproxEqual(), CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<double> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back((Rand() / static_cast<double>(Rand())));
  }

  bool ans;
  DoubleWriter bw(binary ? "b,ark:tmpf" : "t,ark:tmpf");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialDoubleReader sbr(RandInt(0, 1) == 0 ? "ark:tmpf" : "ark,bg:tmpf");
  std::vector<std::string> k2;
  std::vector<double> v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  if (binary) {
    KALDI_ASSERT(v2 == v);
  } else {
    KALDI_ASSERT(v2.size() == v.size());
    for (size_t i = 0; i < v2.size(); i++)
      KALDI_ASSERT(ApproxEqual(v[i], v2[i]));
  }
}

UnitTestTableSequentialDoubleBoth()

void kaldi::UnitTestTableSequentialDoubleBoth	(	bool	binary,
		bool	read_scp
	)

Definition at line 431 of file kaldi-table-test.cc.

References ApproxEqual(), CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                                   {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<double> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back((Rand() / static_cast<double>(Rand())));
  }

  bool ans;
  DoubleWriter bw(binary ? "b,ark,scp:tmpf,tmpf.scp" :
                  "t,ark,scp:tmpf,tmpf.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialDoubleReader sbr(RandInt(0, 1) == 0 ?
                             (read_scp ? "scp:tmpf.scp" : "ark:tmpf") :
                             (read_scp ? "scp,bg:tmpf.scp" : "ark,bg:tmpf"));
  std::vector<std::string> k2;
  std::vector<double> v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  if (binary) {
    KALDI_ASSERT(v2 == v);
  } else {
    KALDI_ASSERT(v2.size() == v.size());
    for (size_t i = 0; i < v2.size(); i++)
      KALDI_ASSERT(ApproxEqual(v[i], v2[i]));
  }
  unlink("tmpf.scp");
  unlink("tmpf");
}

UnitTestTableSequentialDoubleMatrixBoth()

void kaldi::UnitTestTableSequentialDoubleMatrixBoth	(	bool	binary,
		bool	read_scp
	)

Definition at line 652 of file kaldi-table-test.cc.

References ApproxEqual(), CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, rnnlm::j, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandGauss(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                                         {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<Matrix<double>*> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back(new Matrix<double>(1 + Rand()%4, 1 + Rand() % 4));
    for (int32 i = 0; i < v.back()->NumRows(); i++)
      for (int32 j = 0; j < v.back()->NumCols(); j++)
        (*(v.back()))(i, j) = RandGauss();
  }

  bool ans;
  DoubleMatrixWriter bw(binary ? "b,ark,scp:tmpf,tmpf.scp" :
                        "t,ark,scp:tmpf,tmpf.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], *(v[i]));
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialDoubleMatrixReader sbr(read_scp ? "scp:tmpf.scp" : "ark:tmpf");
  std::vector<std::string> k2;
  std::vector<Matrix<double>* > v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(new Matrix<double>(sbr.Value()));
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  if (binary) {
    for (size_t i = 0; i < v2.size(); i++)
      KALDI_ASSERT(v2[i]->ApproxEqual(*(v[i]), 1.0e-10));
  } else {
    KALDI_ASSERT(v2.size() == v.size());
    for (size_t i = 0; i < v2.size(); i++)
      KALDI_ASSERT(v2[i]->ApproxEqual(*(v[i])));
  }
  for (int32 i = 0; i < sz; i++) {
    delete v[i];
    delete v2[i];
  }
  unlink("tmpf");
  unlink("tmpf.scp");
}

UnitTestTableSequentialInt32()

void kaldi::UnitTestTableSequentialInt32

(

bool

binary

)

Definition at line 323 of file kaldi-table-test.cc.

References CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                               {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<int32> v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back(Rand());
  }

  bool ans;
  Int32Writer bw(binary ? "b,ark:tmpf" : "t,ark:tmpf");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialInt32Reader sbr(RandInt(0, 1) == 0 ? "ark:tmpf" : "ark,bg:tmpf");
  std::vector<std::string> k2;
  std::vector<int32> v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  KALDI_ASSERT(v2 == v);
}

UnitTestTableSequentialInt32PairVectorBoth()

void kaldi::UnitTestTableSequentialInt32PairVectorBoth	(	bool	binary,
		bool	read_scp
	)

Definition at line 518 of file kaldi-table-test.cc.

References CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, rnnlm::j, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                                            {
  int32 sz = Rand() % 10;
  std::vector<std::string> k(sz);
  std::vector<std::vector<std::pair<int32, int32> > > v(sz);

  for (int32 i = 0; i < sz; i++) {
    k[i] = CharToString('a' + static_cast<char>(i));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    int32 sz2 = Rand() % 5;
    for (int32 j = 0; j < sz2; j++)
      v[i].push_back(std::pair<int32, int32>(Rand() % 10, Rand() % 10));
  }

  bool ans;
  Int32PairVectorWriter bw(binary ? "b,ark,scp:tmpf,tmpf.scp" :
                           "t,ark,scp:tmpf,tmpf.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialInt32PairVectorReader sbr(RandInt(0, 1) == 0 ?
                                      (read_scp ? "scp:tmpf.scp" : "ark:tmpf") :
                                      (read_scp ? "scp,bg:tmpf.scp" : "ark,bg:tmpf"));
  std::vector<std::string> k2;
  std::vector<std::vector<std::pair<int32, int32> > > v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  KALDI_ASSERT(v2 == v);
}

UnitTestTableSequentialInt32Script()

void kaldi::UnitTestTableSequentialInt32Script

(

bool

binary

)

Definition at line 600 of file kaldi-table-test.cc.

References SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), ReadScriptFile(), SequentialTableReader< Holder >::Value(), TableWriter< Holder >::Write(), and WriteScriptFile().

Referenced by main().

                                                     {
  int32 sz = Rand() % 10;
  std::vector<std::pair<std::string, std::string> > script;
  std::vector<std::string> k;
  std::vector<int32> v;

  for (int32 i = 0; i < sz; i++) {
    char buf[3];
    buf[0] = 'a' + static_cast<char>(i);
    buf[1] = (i%2 == 0 ? 'b'+static_cast<char>(i) : '\0');
    buf[2] = '\0';
    k.push_back(std::string(buf));
    script.push_back(std::make_pair(std::string(buf),
                     std::string(buf) + ".tmp"));
    v.push_back(Rand());
  }

  WriteScriptFile("tmp.scp", script);
  {
    std::vector<std::pair<std::string, std::string> > script2;
    ReadScriptFile("tmp.scp", true, &script2);
    KALDI_ASSERT(script2 == script);  // This tests WriteScriptFile and
                                      // ReadScriptFile.
  }

  bool ans;
  Int32Writer bw(binary ? "b,scp:tmp.scp" : "t,scp:tmp.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialInt32Reader sbr(RandInt(0, 1) == 0 ?
                            "scp:tmp.scp" : "scp,bg:tmp.scp");
  std::vector<std::string> k2;
  std::vector<int32> v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());

  unlink("tmp.scp");
  for (size_t i = 0; i < script.size(); i++) {
    unlink(script[i].second.c_str());
  }
  KALDI_ASSERT(k2 == k);
  KALDI_ASSERT(v2 == v);
}

UnitTestTableSequentialInt32VectorBoth()

void kaldi::UnitTestTableSequentialInt32VectorBoth	(	bool	binary,
		bool	read_scp
	)

Definition at line 477 of file kaldi-table-test.cc.

References CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, rnnlm::j, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), RandInt(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                                        {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<std::vector<int32> > v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back(std::vector<int32>());
    int32 sz2 = Rand() % 5;
    for (int32 j = 0; j  < sz2; j++)
      v.back().push_back(Rand() % 100);
  }

  bool ans;
  Int32VectorWriter bw(binary ? "b,ark,scp:tmpf,tmpf.scp" :
                       "t,ark,scp:tmpf,tmpf.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialInt32VectorReader sbr(RandInt(0, 1) == 0 ?
                                  (read_scp ? "scp:tmpf.scp" : "ark:tmpf") :
                                  (read_scp ? "scp,bg:tmpf.scp" : "ark,bg:tmpf"));
  std::vector<std::string> k2;
  std::vector<std::vector<int32> > v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  KALDI_ASSERT(v2 == v);
}

UnitTestTableSequentialInt32VectorVectorBoth()

void kaldi::UnitTestTableSequentialInt32VectorVectorBoth	(	bool	binary,
		bool	read_scp
	)

Definition at line 558 of file kaldi-table-test.cc.

References CharToString(), SequentialTableReader< Holder >::Close(), TableWriter< Holder >::Close(), SequentialTableReader< Holder >::Done(), rnnlm::i, rnnlm::j, KALDI_ASSERT, SequentialTableReader< Holder >::Key(), SequentialTableReader< Holder >::Next(), Rand(), SequentialTableReader< Holder >::Value(), and TableWriter< Holder >::Write().

Referenced by main().

                                                                              {
  int32 sz = Rand() % 10;
  std::vector<std::string> k;
  std::vector<std::vector<std::vector<int32> > > v;

  for (int32 i = 0; i < sz; i++) {
    k.push_back(CharToString('a' + static_cast<char>(i)));  // This gives us
    // some single quotes too but it doesn't really matter.
    if (i%2 == 0) k.back() = k.back() +  CharToString('a' + i);  // make them
                                                           // different lengths.
    v.push_back(std::vector<std::vector<int32> >());
    int32 sz2 = Rand() % 5;
    for (int32 j = 0; j  < sz2; j++) {
      v.back().push_back(std::vector<int32>());
      int32 sz3 = Rand() % 2;
      for (int32 k = 0; k  < sz3; k++)
        v.back().back().push_back(Rand() % 100);
    }
  }

  bool ans;
  Int32VectorVectorWriter bw(binary ? "b,ark,scp:tmpf,tmpf.scp" :
                             "t,ark,scp:tmpf,tmpf.scp");
  for (int32 i = 0; i < sz; i++)  {
    bw.Write(k[i], v[i]);
  }
  ans = bw.Close();
  KALDI_ASSERT(ans);

  SequentialInt32VectorVectorReader sbr(read_scp ? "scp:tmpf.scp" : "ark:tmpf");
  std::vector<std::string> k2;
  std::vector<std::vector<std::vector<int32> > > v2;
  for (; !sbr.Done(); sbr.Next()) {
    k2.push_back(sbr.Key());
    v2.push_back(sbr.Value());
  }
  KALDI_ASSERT(sbr.Close());
  KALDI_ASSERT(k2 == k);
  KALDI_ASSERT(v2 == v);
}

UnitTestTanh()

static void kaldi::UnitTestTanh ( )

static

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

References AssertEqual(), MatrixBase< Real >::DiffTanh(), Exp(), rnnlm::i, Rand(), and MatrixBase< Real >::Tanh().

                                                    {
  for (MatrixIndexT i = 0; i < 10; i++) {
    MatrixIndexT dimM = 5 + Rand() % 10, dimN = 5 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), P(dimM, dimN), Q(dimM, dimN), R(dimM, dimN);
    M.SetRandn();
    P.SetRandn();
    Matrix<Real> N(M);
    for(int32 r = 0; r < dimM; r++) {
      for (int32 c = 0; c < dimN; c++) {
        Real x = N(r, c);
        if (x > 0.0) {
          x = -1.0 + 2.0 / (1.0 + Exp(-2.0 * x));
        } else {
          x = 1.0 - 2.0 / (1.0 + Exp(2.0 * x));
        }
        N(r, c) = x;
        Real out_diff = P(r, c), in_diff = out_diff * (1.0 - x * x);
        Q(r, c) = in_diff;
      }
    }
    M.Tanh(M);
    R.DiffTanh(N, P);
    AssertEqual(M, N);
    AssertEqual(Q, R);
  }
}

UnitTestTopEigs()

static void kaldi::UnitTestTopEigs ( )

static

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

References SpMatrix< Real >::AddMat2(), MatrixBase< Real >::AddMatMat(), VectorBase< Real >::ApplyAbs(), AssertEqual(), VectorBase< Real >::CopyDiagFromMat(), VectorBase< Real >::Data(), SpMatrix< Real >::Eig(), rnnlm::i, SpMatrix< Real >::IsUnit(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, NonUnitness(), RandGauss(), and SpMatrix< Real >::TopEigs().

                              {
  for (MatrixIndexT i = 0; i < 2; i++) {
    // Previously tested with this but takes too long.
    MatrixIndexT dim = 400, num_eigs = 100;
    SpMatrix<Real> mat(dim);
    for (MatrixIndexT i = 0; i < dim; i++)
      for (MatrixIndexT j = 0; j <= i; j++)
        mat(i, j) = RandGauss();

    Matrix<Real> P(dim, num_eigs);
    Vector<Real> s(num_eigs);
    mat.TopEigs(&s, &P);
    { // P should have orthogonal columns.  Check this.
      SpMatrix<Real> S(num_eigs);
      S.AddMat2(1.0, P, kTrans, 0.0);
      KALDI_LOG << "Non-unit-ness of S is " << NonUnitness(S);
      KALDI_ASSERT(S.IsUnit(1.0e-04));
    }
    // Note: we call the matrix "mat" by the name "S" below.
    Matrix<Real> SP(dim, num_eigs); // diag of P^T SP should be eigs.
    SP.AddSpMat(1.0, mat, P, kNoTrans, 0.0);
    Matrix<Real> PSP(num_eigs, num_eigs);
    PSP.AddMatMat(1.0, P, kTrans, SP, kNoTrans, 0.0);
    Vector<Real> s2(num_eigs);
    s2.CopyDiagFromMat(PSP);
    AssertEqual(s, s2);
    // Now check that eigs are close to real top eigs.
    {
      Matrix<Real> fullP(dim, dim);
      Vector<Real> fulls(dim);
      mat.Eig(&fulls, &fullP);
      KALDI_LOG << "Approximate eigs are " << s;
      // find sum of largest-abs-value eigs.
      fulls.ApplyAbs();
      std::sort(fulls.Data(), fulls.Data() + dim);
      SubVector<Real> tmp(fulls, dim - num_eigs, num_eigs);
      KALDI_LOG << "abs(real eigs) are " << tmp;
      BaseFloat real_sum = tmp.Sum();
      s.ApplyAbs();
      BaseFloat approx_sum = s.Sum();
      KALDI_LOG << "real sum is " << real_sum << ", approx_sum = " << approx_sum;
    }
  }
}

UnitTestTp2()

static void kaldi::UnitTestTp2 ( )

static

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

References SpMatrix< Real >::AddMat2(), AssertEqual(), kNoTrans, kTrans, Rand(), and PackedMatrix< Real >::SetRandn().

                          {
  // Tests AddTp2()
  for (MatrixIndexT iter = 0; iter < 4; iter++) {
    MatrixIndexT dimM = 10 + Rand()%3;

    TpMatrix<Real> T(dimM);
    T.SetRandn();

    Matrix<Real> M(T);

    SpMatrix<Real> A(dimM), B(dimM);
    A.AddTp2(0.5, T, (iter < 2 ? kNoTrans : kTrans), 0.0);
    B.AddMat2(0.5, M, (iter < 2 ? kNoTrans : kTrans), 0.0);
    AssertEqual(A, B);
  }
}

UnitTestTp2Sp()

static void kaldi::UnitTestTp2Sp ( )

static

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

References SpMatrix< Real >::AddMat2Sp(), AssertEqual(), rnnlm::i, rnnlm::j, kNoTrans, kTrans, Rand(), and PackedMatrix< Real >::SetRandn().

                            {
  // Tests AddTp2Sp()
  for (MatrixIndexT iter = 0; iter < 4; iter++) {
    MatrixIndexT dimM = 10 + Rand()%3;

    TpMatrix<Real> T(dimM);
    T.SetRandn();
    SpMatrix<Real> S(dimM);
    S.SetRandn();

    Matrix<Real> M(T);
    for ( MatrixIndexT i = 0; i < dimM; i++)
      for (MatrixIndexT j = 0; j < dimM; j++) {
        if (j <= i) AssertEqual(T(i,j), M(i,j));
        else AssertEqual(M(i,j), 0.0);
      }

    SpMatrix<Real> A(dimM), B(dimM);
    A.AddTp2Sp(0.5, T, (iter < 2 ? kNoTrans : kTrans), S, 0.0);
    B.AddMat2Sp(0.5, M, (iter < 2 ? kNoTrans : kTrans), S, 0.0);
    AssertEqual(A, B);
  }
}

UnitTestTpInvert()

static void kaldi::UnitTestTpInvert ( )

static

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

References MatrixBase< Real >::AddMatMat(), TpMatrix< Real >::CopyFromTp(), rnnlm::i, TpMatrix< Real >::Invert(), MatrixBase< Real >::IsUnit(), rnnlm::j, KALDI_ASSERT, kNoTrans, PackedMatrix< Real >::NumRows(), Rand(), and RandGauss().

                                                        {
  for (MatrixIndexT i = 0;i < 30;i++) {
    MatrixIndexT dimM = 20 + Rand()%10;
    TpMatrix<Real> M(dimM);
    for (MatrixIndexT i = 0;i < M.NumRows();i++) {
      for (MatrixIndexT j = 0;j < i;j++) M(i, j) = RandGauss();
      M(i, i) = 20 * std::max((Real)0.1, (Real) RandGauss());  // make sure invertible by making it diagonally dominant (-ish)
    }
    TpMatrix<Real> N(dimM);
    N.CopyFromTp(M);
    N.Invert();
    TpMatrix<Real> O(dimM);

    Matrix<Real> Mm(dimM, dimM), Nm(dimM, dimM), Om(dimM, dimM);
    Mm.CopyFromTp(M); Nm.CopyFromTp(N);

    Om.AddMatMat(1.0, Mm, kNoTrans, Nm, kNoTrans, 0.0);
    KALDI_ASSERT(Om.IsUnit(0.001));
  }
}

UnitTestTrace() [1/2]

static void kaldi::UnitTestTrace ( )

static

Definition at line 119 of file cu-test.cc.

References KALDI_LOG, PackedMatrix< Real >::SetRandn(), CuPackedMatrix< Real >::Trace(), and SpMatrix< Real >::Trace().

                                                    {
  for (MatrixIndexT iter = 1; iter < 18; iter++) {
    MatrixIndexT dim = iter;
    KALDI_LOG << "dim is : " << iter;
    SpMatrix<Real> A(dim);
    A.SetRandn();
    CuSpMatrix<Real> B(A);
    KALDI_LOG << "cpu trace is : " << A.Trace();
    KALDI_LOG << "gpu trace is : " << B.Trace();
  }
  /*
  Vector<Real> tim(100);
  Vector<Real> d(100);
  for (MatrixIndexT iter = 0; iter < 100; iter++) {
    MatrixIndexT dim = 10000 + Rand() % 400;
    Matrix<Real> A(dim,dim);
    A.SetRandn();
    CuMatrix<Real> B(A);
    CuSpMatrix<Real> C(B,kTakeLower);
    clock_t t1 = clock();
    tim(iter) = C.Trace();
    clock_t t2 = clock();
    //tim(iter) = t2 - t1;
    d(iter) = dim;
    KALDI_LOG << tim(iter) << iter;
    KALDI_LOG << d(iter) << iter;
  }
  KALDI_LOG << "tim is " << tim;
  KALDI_LOG << "dim is " << d;
  */
}

UnitTestTrace() [2/2]

static void kaldi::UnitTestTrace ( )

static

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

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::AddMatMatMat(), approx_equal(), AssertEqual(), MatrixBase< Real >::CopyFromMat(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, Rand(), PackedMatrix< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), MatrixBase< Real >::Trace(), TraceMat(), TraceMatMat(), TraceMatMatMat(), TraceMatMatMatMat(), TraceMatSpMat(), TraceMatSpMatSp(), and TraceSpMat().

                                                    {

  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = 20 + Rand()%10, dimN = 20 + Rand()%10, dimO = 20 + Rand()%10, dimP = dimM;
    Matrix<Real> A(dimM, dimN), B(dimN, dimO), C(dimO, dimP);
    A.SetRandn();     B.SetRandn();     C.SetRandn();
    Matrix<Real> AT(dimN, dimM), BT(dimO, dimN), CT(dimP, dimO);
    AT.CopyFromMat(A, kTrans); BT.CopyFromMat(B, kTrans); CT.CopyFromMat(C, kTrans);

    Matrix<Real> AB(dimM, dimO);
    AB.AddMatMat(1.0, A, kNoTrans, B, kNoTrans, 0.0);
    Matrix<Real> BC(dimN, dimP);
    BC.AddMatMat(1.0, B, kNoTrans, C, kNoTrans, 0.0);
    Matrix<Real> ABC(dimM, dimP);
    ABC.AddMatMat(1.0, A, kNoTrans, BC, kNoTrans, 0.0);

    Real
        t1 = TraceMat(ABC),
        t2 = ABC.Trace(),
        t3 = TraceMatMat(A, BC),
        t4 = TraceMatMat(AT, BC, kTrans),
        t5 = TraceMatMat(BC, AT, kTrans),
        t6 = TraceMatMatMat(A, kNoTrans, B, kNoTrans, C, kNoTrans),
        t7 = TraceMatMatMat(AT, kTrans, B, kNoTrans, C, kNoTrans),
        t8 = TraceMatMatMat(AT, kTrans, BT, kTrans, C, kNoTrans),
        t9 = TraceMatMatMat(AT, kTrans, BT, kTrans, CT, kTrans);

    Matrix<Real> ABC1(dimM, dimP);  // tests AddMatMatMat.
    ABC1.AddMatMatMat(1.0, A, kNoTrans, B, kNoTrans, C, kNoTrans, 0.0);
    AssertEqual(ABC, ABC1);

    Matrix<Real> ABC2(dimM, dimP);  // tests AddMatMatMat.
    ABC2.AddMatMatMat(0.25, A, kNoTrans, B, kNoTrans, C, kNoTrans, 0.0);
    ABC2.AddMatMatMat(0.25, AT, kTrans, B, kNoTrans, C, kNoTrans, 2.0);  // the extra 1.0 means another 0.25.
    ABC2.AddMatMatMat(0.125, A, kNoTrans, BT, kTrans, C, kNoTrans, 1.0);
    ABC2.AddMatMatMat(0.125, A, kNoTrans, B, kNoTrans, CT, kTrans, 1.0);
    AssertEqual(ABC, ABC2);

    Real tol = 0.001;
    KALDI_ASSERT((std::abs(t1-t2) < tol) && (std::abs(t2-t3) < tol) && (std::abs(t3-t4) < tol)
                 && (std::abs(t4-t5) < tol) && (std::abs(t5-t6) < tol) && (std::abs(t6-t7) < tol)
                 && (std::abs(t7-t8) < tol) && (std::abs(t8-t9) < tol));
  }

  for (MatrixIndexT i = 0;i < 5;i++) {
    MatrixIndexT dimM = 20 + Rand()%10, dimN = 20 + Rand()%10;
    SpMatrix<Real> S(dimM), T(dimN);
    S.SetRandn(); T.SetRandn();
    Matrix<Real> M(dimM, dimN), O(dimM, dimN);
    M.SetRandn(); O.SetRandn();
    Matrix<Real> sM(S), tM(T);

    Real x1 = TraceMatMat(tM, tM);
    Real x2 = TraceSpMat(T, tM);
    KALDI_ASSERT(approx_equal(x1, x2) || fabs(x1-x2) < 0.1);

    Real t1 = TraceMatMatMat(M, kNoTrans, tM, kNoTrans, M, kTrans);
    Real t2 = TraceMatSpMat(M, kNoTrans, T, M, kTrans);
    KALDI_ASSERT(approx_equal(t1, t2) || fabs(t1-12) < 0.1);

    Real u1 = TraceMatSpMatSp(M, kNoTrans, T, O, kTrans, S);
    Real u2 = TraceMatMatMatMat(M, kNoTrans, tM, kNoTrans, O, kTrans, sM, kNoTrans);
    KALDI_ASSERT(approx_equal(u1, u2) || fabs(u1-u2) < 0.1);
  }

}

UnitTestTraceProduct()

static void kaldi::UnitTestTraceProduct ( )

static

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

References KALDI_ASSERT, KALDI_LOG, kTrans, Rand(), MatrixBase< Real >::SetRandn(), and TraceMatMat().

                                                           {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {  // First test the 2 det routines are the same
    int dimM = 10 + Rand() % 10, dimN = 10 + Rand() % 10;
    Matrix<Real> M(dimM, dimN), N(dimM, dimN);

    M.SetRandn();
    N.SetRandn();
    Matrix<Real> Nt(N, kTrans);
    Real a = TraceMatMat(M, Nt), b = TraceMatMat(M, N, kTrans);
    printf("m = %d, n = %d\n", dimM, dimN);
    KALDI_LOG << a << " " << b;
    KALDI_ASSERT(std::abs(a-b) < 0.1);
  }
}

UnitTestTraceSpSpLower()

static void kaldi::UnitTestTraceSpSpLower ( )

static

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

References AssertEqual(), Rand(), PackedMatrix< Real >::Scale(), PackedMatrix< Real >::ScaleDiag(), PackedMatrix< Real >::SetRandn(), TraceSpSp(), and TraceSpSpLower().

                                                             {

  MatrixIndexT N = 1 + Rand() % 10;
  SpMatrix<Real> S(N), T(N);
  S.SetRandn();
  T.SetRandn();

  SpMatrix<Real> Sfast(S);
  Sfast.Scale(2.0);
  Sfast.ScaleDiag(0.5);

  AssertEqual(TraceSpSp(S, T), TraceSpSpLower(Sfast, T));
}

UnitTestTrain()

void kaldi::UnitTestTrain

(

)

Definition at line 67 of file logistic-regression-test.cc.

References MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::CopyFromMat(), LogisticRegression::GetObjfAndGrad(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, Log(), LogisticRegressionConfig::max_steps, LogisticRegressionConfig::normalizer, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), Rand(), MatrixBase< Real >::SetRandn(), LogisticRegression::Train(), and LogisticRegression::weights_.

Referenced by main().

                     {

  int32 n_features = Rand() % 600 + 10,
        n_xs = Rand() % 200 + 100,
        n_labels = Rand() % 20 + 10;
  double normalizer = 0.01;
  Matrix<BaseFloat> xs(n_xs, n_features);
  xs.SetRandn();

  std::vector<int32> ys;
  for (int32 i = 0; i < n_xs; i++) {
    ys.push_back(Rand() % n_labels);
  }

  LogisticRegressionConfig conf;
  conf.max_steps = 20;
  conf.normalizer = normalizer;
  // Train the classifier
  LogisticRegression classifier = LogisticRegression();
  classifier.Train(xs, ys, conf);

  // Internally in LogisticRegression we add an additional element to
  // the x vectors: a 1.0 which handles the prior.
  Matrix<BaseFloat> xs_with_prior(n_xs, n_features + 1);
  for (int32 i = 0; i < n_xs; i++) {
    xs_with_prior(i, n_features) = 1.0;
  }
  SubMatrix<BaseFloat> sub_xs(xs_with_prior, 0, n_xs, 0, n_features);
  sub_xs.CopyFromMat(xs);

  Matrix<BaseFloat> xw(n_xs, n_labels);
  xw.AddMatMat(1.0, xs_with_prior, kNoTrans, classifier.weights_,
               kTrans, 0.0);

  Matrix<BaseFloat> grad(classifier.weights_.NumRows(),
                      classifier.weights_.NumCols());

  double objf_trained = classifier.GetObjfAndGrad(xs_with_prior,
                                                  ys, xw, &grad, normalizer);

  // Calculate objective function using a random weight matrix.
  Matrix<BaseFloat> xw_rand(n_xs, n_labels);

  Matrix<BaseFloat> weights_rand(classifier.weights_);
  weights_rand.SetRandn();
  xw.AddMatMat(1.0, xs_with_prior, kNoTrans, weights_rand,
               kTrans, 0.0);

  // Verify that the objective function after training is better
  // than the objective function with a random weight matrix.
  double objf_rand_w = classifier.GetObjfAndGrad(xs_with_prior, ys,
                                                 xw_rand, &grad, normalizer);
  KALDI_ASSERT(objf_trained > objf_rand_w);
  KALDI_ASSERT(objf_trained > Log(1.0 / n_xs));
}

UnitTestTranspose()

static void kaldi::UnitTestTranspose ( )

static

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

References AssertEqual(), kTrans, Rand(), MatrixBase< Real >::SetRandn(), and Matrix< Real >::Transpose().

                                                        {

  Matrix<Real> M(Rand() % 5 + 1, Rand() % 10 + 1);
  M.SetRandn();
  Matrix<Real> N(M, kTrans);
  N.Transpose();
  AssertEqual(M, N);
}

UnitTestTransposeScatter()

static void kaldi::UnitTestTransposeScatter ( )

static

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

References SpMatrix< Real >::AddMat2Sp(), MatrixBase< Real >::AddMatMat(), MatrixBase< Real >::CopyFromSp(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kNoTrans, kTrans, MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), PackedMatrix< Real >::NumRows(), Rand(), RandGauss(), and Matrix< Real >::Resize().

                                       {
  for (MatrixIndexT iter = 0;iter < 10;iter++) {

    MatrixIndexT dimA = 10 + Rand()%3;
    MatrixIndexT dimO = 10 + Rand()%3;
    Matrix<Real>   Af(dimA, dimA);
    SpMatrix<Real> Ap(dimA);
    Matrix<Real>   M(dimO, dimA);
    Matrix<Real>   Of(dimO, dimO);
    SpMatrix<Real> Op(dimO);
    Matrix<Real>   A_MT(dimA, dimO);

    for (MatrixIndexT i = 0;i < Ap.NumRows();i++) {
      for (MatrixIndexT j = 0; j<=i; j++) {
        Ap(i, j) = RandGauss();
      }
    }
    for (MatrixIndexT i = 0;i < M.NumRows();i++) {
      for (MatrixIndexT j = 0; j < M.NumCols(); j++) {
        M(i, j) = RandGauss();
      }
    }
    /*
      std::stringstream ss("1 2 3");
      ss >> Ap;
      ss.clear();
      ss.str("5 6 7 8 9 10");
      ss >> M;
    */

    Af.CopyFromSp(Ap);
    A_MT.AddMatMat(1.0, Af, kNoTrans, M, kTrans, 0.0);
    Of.AddMatMat(1.0, M, kNoTrans, A_MT, kNoTrans, 0.0);
    Op.AddMat2Sp(1.0, M, kNoTrans, Ap, 0.0);


    //    KALDI_LOG << "A" << '\n' << Af;
    //    KALDI_LOG << "M" << '\n' << M;
    //    KALDI_LOG << "Op" << '\n' << Op;

    for (MatrixIndexT i = 0; i < dimO; i++) {
      for (MatrixIndexT j = 0; j<=i; j++) {
        KALDI_ASSERT(std::abs(Of(i, j) - Op(i, j)) < 0.0001);
      }
    }

    A_MT.Resize(dimO, dimA);
    A_MT.AddMatMat(1.0, Of, kNoTrans, M, kNoTrans, 0.0);
    Af.AddMatMat(1.0, M, kTrans, A_MT, kNoTrans, 1.0);
    Ap.AddMat2Sp(1.0, M, kTrans, Op, 1.0);

    //    KALDI_LOG << "Ap" << '\n' << Ap;
    //    KALDI_LOG << "Af" << '\n' << Af;

    for (MatrixIndexT i = 0; i < dimA; i++) {
      for (MatrixIndexT j = 0; j<=i; j++) {
        KALDI_ASSERT(std::abs(Af(i, j) - Ap(i, j)) < 0.01);
      }
    }
  }
}

UnitTestTridiag()

static void kaldi::UnitTestTridiag ( )

static

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

References SpMatrix< Real >::IsTridiagonal(), and KALDI_ASSERT.

                              {
  SpMatrix<Real> A(3);
  A(1,1) = 1.0;
  A(1, 2) = 1.0;
  KALDI_ASSERT(A.IsTridiagonal());
  A(0, 2) = 1.0;
  KALDI_ASSERT(!A.IsTridiagonal());
  A(0, 2) = 0.0;
  A(0, 1) = 1.0;
  KALDI_ASSERT(A.IsTridiagonal());
}

UnitTestTridiagonalize()

static void kaldi::UnitTestTridiagonalize ( )

static

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

References SpMatrix< Real >::AddMat2Sp(), AssertEqual(), cblas_Xspmv(), rnnlm::i, InitRandNonsingular(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, SpMatrix< Real >::LogDet(), NonUnitness(), Rand(), MatrixBase< Real >::Set(), SpMatrix< Real >::Trace(), and SpMatrix< Real >::Tridiagonalize().

                                     {

  {
    float tmp[5];
    tmp[4] = 1.0;
    cblas_Xspmv(1, 0.0, tmp+2,
                tmp+1, 1, 0.0, tmp+4, 1);
    KALDI_ASSERT(tmp[4] == 0.0);
  }
  for (MatrixIndexT i = 0; i < 4; i++) {
    MatrixIndexT dim = 40 + Rand() % 4;
    // We happened to find out that a 16x16 matrix of 27's causes problems for
    // Tridiagonalize.
    if (i == 0 || i == 1)
      dim = 16;
    SpMatrix<Real> S(dim), S2(dim), R(dim), S3(dim);
    Matrix<Real> Q(dim, dim);
    InitRandNonsingular(&S);
    // Very small or large scaling is challenging to qr due to squares that
    // could go out of range.
    if (Rand() % 3 == 0)
      S.Scale(1.0e-15);
    else if (Rand() % 2 == 0)
      S.Scale(1.0e+15);
    if (i == 0 || i == 1) {
      Matrix<Real> temp(dim, dim);
      if (i == 0)
        temp.Set(27.0);
      else
        temp.Set(-1.61558713e-27);
      S.CopyFromMat(temp);
    }
    SpMatrix<Real> T(S);
    T.Tridiagonalize(&Q);
    KALDI_LOG << "S trace " << S.Trace() << ", T trace " << T.Trace();
    // KALDI_LOG << S << "\n" << T;
    AssertEqual(S.Trace(), T.Trace());
    // Also test Trace().
    Real ans = 0.0;
    for (MatrixIndexT j = 0; j < dim; j++) ans += T(j, j);
    AssertEqual(ans, T.Trace());
    if (S.LogDet() > -50.0) {
      // don't check logdet equality if original logdet is very negative- could
      // be singular.
      AssertEqual(T.LogDet(), S.LogDet());
    }
    R.AddMat2(1.0, Q, kNoTrans, 0.0);
    KALDI_LOG << "Non-unit-ness of R is " << NonUnitness(R);
    KALDI_ASSERT(R.IsUnit(0.01)); // Check Q is orthogonal.
    S2.AddMat2Sp(1.0, Q, kTrans, T, 0.0);
    S3.AddMat2Sp(1.0, Q, kNoTrans, S, 0.0);
    //KALDI_LOG << "T is " << T;
    //KALDI_LOG << "S is " << S;
    //KALDI_LOG << "S2 (should be like S) is " << S2;
    //KALDI_LOG << "S3 (should be like T) is " << S3;
    AssertEqual(S, S2);
    AssertEqual(T, S3);
  }
}

UnitTestTridiagonalizeAndQr()

static void kaldi::UnitTestTridiagonalizeAndQr ( )

static

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

References SpMatrix< Real >::AddMat2Sp(), AssertEqual(), cblas_Xspmv(), rnnlm::i, InitRandNonsingular(), SpMatrix< Real >::IsDiagonal(), rnnlm::j, KALDI_ASSERT, KALDI_LOG, kNoTrans, kTrans, SpMatrix< Real >::LogDet(), NonUnitness(), SpMatrix< Real >::Qr(), Rand(), SpMatrix< Real >::Trace(), and SpMatrix< Real >::Tridiagonalize().

                                          {

  {
    float tmp[5];
    tmp[4] = 1.0;
   // cblas_sspmv(CblasRowMajor, CblasLower, 1, 0.0, tmp+2,
   //             tmp+1, 1, 0.0, tmp+4, 1);
    cblas_Xspmv(1, 0.0, tmp+2,
                tmp+1, 1, 0.0, tmp+4, 1);

    KALDI_ASSERT(tmp[4] == 0.0);
  }
  for (MatrixIndexT i = 0; i < 4; i++) {
    MatrixIndexT dim = 50 + Rand() % 4;
    SpMatrix<Real> S(dim), S2(dim), R(dim), S3(dim), S4(dim);
    Matrix<Real> Q(dim, dim);
    InitRandNonsingular(&S);
    SpMatrix<Real> T(S);
    T.Tridiagonalize(&Q);
    KALDI_LOG << "S trace " << S.Trace() << ", T trace " << T.Trace();
    // KALDI_LOG << S << "\n" << T;
    AssertEqual(S.Trace(), T.Trace());
    // Also test Trace().
    Real ans = 0.0;
    for (MatrixIndexT j = 0; j < dim; j++) ans += T(j, j);
    AssertEqual(ans, T.Trace());
    AssertEqual(T.LogDet(), S.LogDet());
    R.AddMat2(1.0, Q, kNoTrans, 0.0);
    KALDI_LOG << "Non-unit-ness of R after tridiag is " << NonUnitness(R);
    KALDI_ASSERT(R.IsUnit(0.001)); // Check Q is orthogonal.
    S2.AddMat2Sp(1.0, Q, kTrans, T, 0.0);
    S3.AddMat2Sp(1.0, Q, kNoTrans, S, 0.0);
    //KALDI_LOG << "T is " << T;
    //KALDI_LOG << "S is " << S;
    //KALDI_LOG << "S2 (should be like S) is " << S2;
    //KALDI_LOG << "S3 (should be like T) is " << S3;
    AssertEqual(S, S2);
    AssertEqual(T, S3);
    SpMatrix<Real> T2(T);
    T2.Qr(&Q);
    R.AddMat2(1.0, Q, kNoTrans, 0.0);
    KALDI_LOG << "Non-unit-ness of R after QR is " << NonUnitness(R);
    KALDI_ASSERT(R.IsUnit(0.001)); // Check Q is orthogonal.
    AssertEqual(T.Trace(), T2.Trace());
    KALDI_ASSERT(T2.IsDiagonal());
    AssertEqual(T.LogDet(), T2.LogDet());
    S4.AddMat2Sp(1.0, Q, kTrans, T2, 0.0);
    //KALDI_LOG << "S4 (should be like S) is " << S4;
    AssertEqual(S, S4);
  }
}

UnitTestTriVecSolver()

static void kaldi::UnitTestTriVecSolver ( )

static

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

References VectorBase< Real >::AddTpVec(), AssertEqual(), rnnlm::i, KALDI_LOG, kNoTrans, kTrans, Rand(), VectorBase< Real >::SetRandn(), PackedMatrix< Real >::SetRandn(), and VectorBase< Real >::Solve().

                                                           {
  for (MatrixIndexT iter = 0; iter < 100; iter++) {
    int32 dim = 1 + Rand() % 20;
    Vector<Real> b(dim);
    b.SetRandn();
    TpMatrix<Real> T(dim);
    T.SetRandn();

    bool bad = false;
    for (int32 i = 0; i < dim; i++) {
      if (fabs(T(i, i)) < 0.2)
        bad = true;
    }
    if (bad) {
      // Test may fail due to almost-singular matrix.
      continue;
    }

    Vector<Real> x(b);
    MatrixTransposeType trans = (iter % 2 == 0 ? kTrans : kNoTrans);
    x.Solve(T, trans);  // solve for T x = b
    Vector<Real> b2(dim);
    b2.AddTpVec((Real)1.0, T, trans, x, (Real)0.0);
    KALDI_LOG << "b is " << b << ", b2 is " << b2;
    AssertEqual(b, b2, 0.01);
  }
}

UnitTestVecMatVec()

void kaldi::UnitTestVecMatVec

(

)

Definition at line 234 of file cu-vector-test.cc.

References AssertEqual(), rnnlm::i, rnnlm::j, Rand(), CuVectorBase< Real >::SetRandn(), CuMatrixBase< Real >::SetRandn(), and VecMatVec().

                                                 {
  int32 NR = 10 + Rand() % 100, NC = 20 + Rand() % 100;
  CuVector<Real> v1(NR), v2(NC);
  v1.SetRandn();
  v2.SetRandn();
  CuMatrix<Real> M(NR, NC);
  M.SetRandn();
  Real sum = 0;
  for (int32 i = 0; i < NR; i++)
    for (int32 j = 0; j < NC; j++)
      sum += v1(i) * M(i, j) * v2(j);
  Real result = VecMatVec(v1, M, v2);
  AssertEqual(sum, result);
}

UnitTestVecmul()

static void kaldi::UnitTestVecmul ( )

static

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

References VectorBase< Real >::AddMatSvec(), AssertEqual(), rnnlm::i, rnnlm::j, KALDI_ASSERT, kNoTrans, kTrans, Rand(), VectorBase< Real >::SetRandn(), MatrixBase< Real >::SetRandn(), and Matrix< Real >::Transpose().

                                                     {
  for (MatrixIndexT iter = 0;iter < 5;iter++) {
    MatrixTransposeType trans = (iter % 2 == 0 ? kTrans : kNoTrans);
    MatrixIndexT dimM = 20 + Rand()%10, dimN = 20 + Rand()%10;  // dims between 10 and 20.
    Real alpha = 0.333, beta = 0.5;
    Matrix<Real> A(dimM, dimN);
    if (trans == kTrans) A.Transpose();
    A.SetRandn();
    Vector<Real> x(dimM), y(dimN);
    //x.SetRandn();
    y.SetRandn();
    Vector<Real> orig_x(x), x2(x);

    x.AddMatVec(alpha, A, trans, y, beta);  // x = A * y + beta*x.
    x2.AddMatSvec(alpha, A, trans, y, beta);  // x = A * y + beta*x

    for (MatrixIndexT i = 0; i < dimM; i++) {
      double sum = beta * orig_x(i);
      for (MatrixIndexT j = 0; j < dimN; j++) {
        if (trans == kNoTrans) {
          sum += alpha * A(i, j) * y(j);
        } else {
          sum += alpha * A(j, i) * y(j);
        }
      }
      KALDI_ASSERT(std::abs(sum - x(i)) < 0.0001);
    }
    AssertEqual(x, x2);
  }

}

UnitTestVector()

static void kaldi::UnitTestVector ( )

static

Definition at line 406 of file cu-test.cc.

References AssertEqual(), CuVectorBase< Real >::CopyToVec(), CuVectorBase< Real >::MulElements(), VectorBase< Real >::MulElements(), Rand(), CuVectorBase< Real >::Scale(), VectorBase< Real >::Scale(), VectorBase< Real >::SetRandn(), and CuVectorBase< Real >::SetRandn().

                                                     {
  // Scale
  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 24 + Rand() % 10;
    Vector<Real> A(dim);
    A.SetRandn();
    CuVector<Real> B(A);
    Vector<Real> C(dim);
    Real r = 1.43;
    B.Scale(r);
    B.CopyToVec(&C);
    A.Scale(r);
    //KALDI_LOG << A;
    //KALDI_LOG << (A.Scale(r));
    //KALDI_LOG << C;
    AssertEqual(A, C);
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 15 + Rand() % 10;
    CuVector<Real> A(dim);
    CuVector<Real> B(dim);
    Vector<Real> A1(dim);
    Vector<Real> B1(dim);
    A.SetRandn();
    B.SetRandn();
    A.CopyToVec(&A1);
    B.CopyToVec(&B1);
    A.MulElements(B);
    A1.MulElements(B1);
    Vector<Real> A2(dim);
    A.CopyToVec(&A2);
    AssertEqual(A1,A2);
  }
  /*
  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 72;
    CuVector<Real> A(dim);
    Vector<Real> A1(dim);
    CuMatrix<Real> B(9,8);
    Matrix<Real> B1(9,8);
    B.SetRandn();
    B.CopyToMat(&B1);
    A.CopyRowsFromMat(B);
    A1.CopyRowsFromMat(B1);
    Vector<Real> A2(dim);
    A.CopyToVec(&A2);
    AssertEqual(A1,A2);
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 15 + Rand() % 10;
    CuVector<Real> A(dim);
    A.SetRandn();
    Vector<Real> A1(dim);
    A.CopyToVec(&A1);
    KALDI_LOG << "cpu min is : " << A1.Min();
    KALDI_LOG << "gpu min is : " << A.Min();
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 15 + Rand() % 10;
    CuVector<Real> A(dim);
    A.SetRandn();
    Vector<Real> A1(dim);
    A.CopyToVec(&A1);
    CuVector<Real> B(dim);
    B.SetRandn();
    Vector<Real> B1(dim);
    B.CopyToVec(&B1);
    CuVector<Real> C(dim);
    C.SetRandn();
    Vector<Real> C1(dim);
    C.CopyToVec(&C1);
    Real alpha = 2;
    Real beta = 3;
    A.AddVecVec(alpha, B, C, beta);
    A1.AddVecVec(alpha,B1,C1,beta);
    Vector<Real> D(dim);
    A.CopyToVec(&D);
    AssertEqual(D,A1);
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim1 = 15 + Rand() % 10;
    int32 dim2 = 10 + Rand() % 10;
    Matrix<Real> A(dim1,dim2);
    for (MatrixIndexT i = 0; i < dim1; i++) {
      for (MatrixIndexT j = 0; j < dim2; j++)
        A(i,j) = i + 2 * j + 1;
    }
    KALDI_LOG << A;
    CuMatrix<Real> B(dim1,dim2);
    B.CopyFromMat(A);
    CuVector<Real> C(dim1);
    C.SetZero();
    Real alpha = 1;
    Real beta = 1;
    C.AddDiagMat2(alpha, B, kNoTrans, beta);
    Vector<Real> D(dim1);
    C.CopyToVec(&D);
    KALDI_LOG << D;
    Vector<Real> E(dim1);
    E.AddDiagMat2(alpha, A, kNoTrans, beta);
    KALDI_LOG << E;
    AssertEqual(D,E);
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim1 = 15 + Rand() % 10;
    int32 dim2 = 10 + Rand() % 10;
    Matrix<Real> A(dim1,dim2);
    for (MatrixIndexT i = 0; i < dim1; i++) {
      for (MatrixIndexT j = 0; j < dim2; j++)
        A(i,j) = i + 2 * j + 1;
    }
    KALDI_LOG << A;
    CuMatrix<Real> B(dim1,dim2);
    B.CopyFromMat(A);
    CuSubVector<Real> C(B,1);
    Vector<Real> D(dim2);
    C.CopyToVec(&D);
    KALDI_LOG << D;
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 15 + Rand() % 10;
    CuVector<Real> A(dim);
    A.SetRandn();
    Vector<Real> A1(dim);
    A.CopyToVec(&A1);
    CuVector<Real> B(dim);
    B.SetRandn();
    Vector<Real> B1(dim);
    B.CopyToVec(&B1);
    Real dot = VecVec(A,B);
    KALDI_LOG << "dot product in gpu: " << dot;
    dot = VecVec(A1,B1);
    KALDI_LOG << "dot product in cpu: " << dot;
  }

  for (MatrixIndexT iter = 0; iter < 10; iter++) {
    int32 dim = 15 + Rand() % 10;
    CuVector<Real> A(dim);
    Vector<Real> A1(dim);
    for (MatrixIndexT i = 0; i < dim; i++)
      A1(i) = i;
    A.CopyFromVec(A1);
    KALDI_LOG << A(dim-2);
    KALDI_LOG << A1(dim-2);
  }
  */
}

UnitTestVectorMax()

static void kaldi::UnitTestVectorMax ( )

static

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

References rnnlm::i, KALDI_ASSERT, VectorBase< Real >::Max(), Rand(), and VectorBase< Real >::SetRandn().

                                {
  int32 dimM = 1 + Rand() % 10;
  Vector<Real> V(dimM);
  V.SetRandn();
  Real m = V(0);
  for (int32 i = 1; i < dimM; i++) m = std::max(m, V(i));
  KALDI_ASSERT(m == V.Max());
  MatrixIndexT i;
  KALDI_ASSERT(m == V.Max(&i));
  KALDI_ASSERT(m == V(i));
}

UnitTestVectorMin()

static void kaldi::UnitTestVectorMin ( )

static

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

References rnnlm::i, KALDI_ASSERT, VectorBase< Real >::Min(), Rand(), and VectorBase< Real >::SetRandn().

                                {
  int32 dimM = 1 + Rand() % 10;
  Vector<Real> V(dimM);
  V.SetRandn();
  Real m = V(0);
  for (int32 i = 1; i < dimM; i++) m = std::min(m, V(i));
  KALDI_ASSERT(m == V.Min());
  MatrixIndexT i;
  KALDI_ASSERT(m == V.Min(&i));
  KALDI_ASSERT(m == V(i));
}

UnitTextCuMatrixAddMatSmat()

static void kaldi::UnitTextCuMatrixAddMatSmat ( )

static

Definition at line 810 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddMatSmat(), MatrixBase< Real >::AddMatSmat(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, rnnlm::n, Rand(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), and swap().

                                         {
  for (int i = 0; i < 2; ++i) {
    int m = 10 + Rand() % 40;
    int k = 10 + Rand() % 60;
    int n = 10 + Rand() % 50;
    int srows = k;
    int scols = n;

    MatrixTransposeType trans = (i % 2 == 0) ? kNoTrans : kTrans;
    if (trans == kTrans) {
      std::swap(srows, scols);
    }

    Real alpha = 0.345;
    Real beta = 0.567;

    Matrix<Real> mat(m, k);
    mat.SetRandn();
    CuMatrix<Real> cumat(mat);

    Matrix<Real> result(m, n);
    result.SetRandn();
    CuMatrix<Real> curesult(result);

    SparseMatrix<Real> smat(srows, scols);
    smat.SetRandn(0.8);
    CuSparseMatrix<Real> cusmat(smat);

    result.AddMatSmat(alpha, mat, smat, trans, beta);
    curesult.AddMatSmat(alpha, cumat, cusmat, trans, beta);

    Matrix<Real> result2(curesult);

    KALDI_ASSERT(ApproxEqual(result, result2));
  }
}

UnitTextCuMatrixAddSmat()

static void kaldi::UnitTextCuMatrixAddSmat ( )

static

Definition at line 778 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddSmat(), MatrixBase< Real >::AddSmat(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, Rand(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), and swap().

                                      {
  for (int i = 0; i < 2; ++i) {
    int rows = 10 + Rand() % 40;
    int cols = 10 + Rand() % 50;
    int srows = rows;
    int scols = cols;

    MatrixTransposeType trans = (i % 2 == 0) ? kNoTrans : kTrans;
    if (trans == kTrans) {
      std::swap(srows, scols);
    }

    Real alpha = 0.345;

    Matrix<Real> mat(rows, cols);
    mat.SetRandn();
    CuMatrix<Real> cumat(mat);

    SparseMatrix<Real> smat(srows, scols);
    smat.SetRandn(0.5);
    CuSparseMatrix<Real> cusmat(smat);

    mat.AddSmat(alpha, smat, trans);
    cumat.AddSmat(alpha, cusmat, trans);

    Matrix<Real> mat2(cumat);

    KALDI_ASSERT(ApproxEqual(mat, mat2));
  }
}

UnitTextCuMatrixAddSmatMat()

static void kaldi::UnitTextCuMatrixAddSmatMat ( )

static

Definition at line 848 of file cu-matrix-test.cc.

References CuMatrixBase< Real >::AddSmatMat(), MatrixBase< Real >::AddSmatMat(), ApproxEqual(), rnnlm::i, KALDI_ASSERT, kNoTrans, kTrans, rnnlm::n, Rand(), MatrixBase< Real >::SetRandn(), SparseMatrix< Real >::SetRandn(), and swap().

                                         {
  for (int i = 0; i < 2; ++i) {
    int m = 10 + Rand() % 40;
    int k = 10 + Rand() % 60;
    int n = 10 + Rand() % 50;
    int srows = m;
    int scols = k;

    MatrixTransposeType trans = (i % 2 == 0) ? kNoTrans : kTrans;
    if (trans == kTrans) {
      std::swap(srows, scols);
    }

    Real alpha = 0.345;
    Real beta = 0.567;

    SparseMatrix<Real> smat(srows, scols);
    smat.SetRandn(0.8);
    CuSparseMatrix<Real> cusmat(smat);

    Matrix<Real> mat(k, n);
    mat.SetRandn();
    CuMatrix<Real> cumat(mat);

    Matrix<Real> result(m, n);
    result.SetRandn();
    CuMatrix<Real> curesult(result);

    result.AddSmatMat(alpha, smat, trans, mat, beta);
    curesult.AddSmatMat(alpha, cusmat, trans, cumat, beta);

    Matrix<Real> result2(curesult);

    KALDI_ASSERT(ApproxEqual(result, result2));
  }
}

UpdateEbwAmDiagGmm()

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
	)

Definition at line 278 of file ebw-diag-gmm.cc.

References AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), KALDI_ASSERT, AccumAmDiagGmm::NumAccs(), AmDiagGmm::NumPdfs(), and UpdateEbwDiagGmm().

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

                                                {
  KALDI_ASSERT(num_stats.NumAccs() == den_stats.NumAccs()
               && num_stats.NumAccs() == am_gmm->NumPdfs());

  if (auxf_change_out) *auxf_change_out = 0.0;
  if (count_out) *count_out = 0.0;
  if (num_floored_out) *num_floored_out = 0.0;

  for (int32 pdf = 0; pdf < num_stats.NumAccs(); pdf++)
    UpdateEbwDiagGmm(num_stats.GetAcc(pdf), den_stats.GetAcc(pdf), flags,
                     opts, &(am_gmm->GetPdf(pdf)), auxf_change_out,
                     count_out, num_floored_out);
}                     

UpdateEbwDiagGmm()

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
	)

Definition at line 94 of file ebw-diag-gmm.cc.

References VectorBase< Real >::AddVec(), DiagGmm::ComputeGconsts(), DiagGmmNormal::CopyFromDiagGmm(), VectorBase< Real >::CopyFromVec(), MatrixBase< Real >::CopyRowFromVec(), DiagGmmNormal::CopyToDiagGmm(), DiagGmm::Dim(), AccumDiagGmm::Dim(), EbwOptions::E, EBWUpdateGaussian(), AccumDiagGmm::Flags(), GmmFlagsToString(), KALDI_ASSERT, KALDI_ERR, KALDI_VLOG, KALDI_WARN, kGmmMeans, kGmmVariances, kGmmWeights, AccumDiagGmm::mean_accumulator(), DiagGmmNormal::means_, DiagGmm::NumGauss(), AccumDiagGmm::NumGauss(), AccumDiagGmm::occupancy(), MatrixBase< Real >::Row(), EbwOptions::tau, AccumDiagGmm::variance_accumulator(), and DiagGmmNormal::vars_.

Referenced by EbwWeightOptions::Register(), UnitTestEstimateMmieDiagGmm(), and UpdateEbwAmDiagGmm().

                                              {
  GmmFlagsType acc_flags = num_stats.Flags();
  if (flags & ~acc_flags)
    KALDI_ERR << "Incompatible flags: you requested to update flags \""
              << GmmFlagsToString(flags) << "\" but accumulators have only \""
              << GmmFlagsToString(acc_flags) << '"';
  
  // It could be that the num stats actually contain the difference between
  // num and den (for mean and var stats), and den stats only have the weights.
  bool den_has_stats;
  if (den_stats.Flags() != acc_flags) {
    den_has_stats = false;
    if (den_stats.Flags() != kGmmWeights) 
      KALDI_ERR << "Incompatible flags: num stats have flags \""
                << GmmFlagsToString(acc_flags) << "\" vs. den stats \""
                << GmmFlagsToString(den_stats.Flags()) << '"';
  } else {
    den_has_stats = true;
  }
  int32 num_comp = num_stats.NumGauss();
  int32 dim = num_stats.Dim();
  KALDI_ASSERT(num_stats.NumGauss() == den_stats.NumGauss());
  KALDI_ASSERT(num_stats.Dim() == gmm->Dim());
  KALDI_ASSERT(gmm->NumGauss() == num_comp);
  
  if ( !(flags & (kGmmMeans | kGmmVariances)) ) {
    return; // Nothing to update.
  }
  
  // copy DiagGMM model and transform this to the normal case
  DiagGmmNormal diaggmmnormal;
  gmm->ComputeGconsts();
  diaggmmnormal.CopyFromDiagGmm(*gmm);

  // go over all components
  Vector<double> mean(dim), var(dim), mean_stats(dim), var_stats(dim);

  for (int32 g = 0; g < num_comp; g++) {
    BaseFloat num_count = num_stats.occupancy()(g),
        den_count = den_stats.occupancy()(g);
    if (num_count == 0.0 && den_count == 0.0) {
      KALDI_VLOG(2) << "Not updating Gaussian " << g << " since counts are zero";
      continue;
    }
    mean_stats.CopyFromVec(num_stats.mean_accumulator().Row(g));
    if (den_has_stats)
      mean_stats.AddVec(-1.0, den_stats.mean_accumulator().Row(g));
    if (flags & kGmmVariances) {
      var_stats.CopyFromVec(num_stats.variance_accumulator().Row(g));
      if (den_has_stats)
        var_stats.AddVec(-1.0, den_stats.variance_accumulator().Row(g));
    }
    double D = (opts.tau + opts.E * den_count) / 2;
    if (D+num_count-den_count <= 0.0) {
      // ensure +ve-- can be problem if num count == 0 and E=2.
      D = -1.0001*(num_count-den_count) + 1.0e-10;
      KALDI_ASSERT(D+num_count-den_count > 0.0);
    }
    // We initialize to half the value of D that would be dictated by E (and
    // tau); this is part of the strategy used to ensure that the value of D we
    // use is at least twice the value that would ensure positive variances.

    int32 iter, max_iter = 100;
    for (iter = 0; iter < max_iter; iter++) { // will normally break from the loop
      // the first time.
      if (EBWUpdateGaussian(D, flags,
                            diaggmmnormal.means_.Row(g),
                            diaggmmnormal.vars_.Row(g),
                            mean_stats, var_stats, num_count-den_count,
                            &mean, &var, NULL)) {
        // Succeeded in getting all +ve vars at this value of D.
        // So double D and commit changes.
        D *= 2.0;
        double auxf_impr = 0.0;
        bool ans = EBWUpdateGaussian(D, flags,
                                     diaggmmnormal.means_.Row(g),
                                     diaggmmnormal.vars_.Row(g),
                                     mean_stats, var_stats, num_count-den_count,
                                     &mean, &var, &auxf_impr);
        if (!ans) {
          KALDI_WARN << "Something went wrong in the EBW update. Check that your"
              "previous update phase looks reasonable, probably your model is "
              "already ruined.  Reverting to the old values";
        } else {
          if (auxf_change_out) *auxf_change_out += auxf_impr;
          if (count_out) *count_out += den_count; // The idea is that for MMI, this will
          // reflect the actual #frames trained on (the numerator one would be I-smoothed).
          // In general (e.g. for MPE), we won't know the #frames.
          diaggmmnormal.means_.CopyRowFromVec(mean, g);
          diaggmmnormal.vars_.CopyRowFromVec(var, g);
        }
        break;
      } else {
        // small step
        D *= 1.1; 
      }
    }
    if (iter > 0 && num_floored_out != NULL) (*num_floored_out)++;
    if (iter == max_iter) KALDI_WARN << "Dropped off end of loop, recomputing D. (unexpected.)";
  }
  // copy to natural representation according to flags.
  diaggmmnormal.CopyToDiagGmm(gmm, flags);
  gmm->ComputeGconsts();
}

UpdateEbwWeightsAmDiagGmm()

void UpdateEbwWeightsAmDiagGmm	(	const AccumAmDiagGmm &	num_stats,
		const AccumAmDiagGmm &	den_stats,
		const EbwWeightOptions &	opts,
		AmDiagGmm *	am_gmm,
		BaseFloat *	auxf_change_out,
		BaseFloat *	count_out
	)

Definition at line 300 of file ebw-diag-gmm.cc.

References AccumAmDiagGmm::GetAcc(), AmDiagGmm::GetPdf(), KALDI_ASSERT, AccumAmDiagGmm::NumAccs(), AmDiagGmm::NumPdfs(), and UpdateEbwWeightsDiagGmm().

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

                                                     {
  KALDI_ASSERT(num_stats.NumAccs() == den_stats.NumAccs()
               && num_stats.NumAccs() == am_gmm->NumPdfs());

  if (auxf_change_out) *auxf_change_out = 0.0;
  if (count_out) *count_out = 0.0;
  
  for (int32 pdf = 0; pdf < num_stats.NumAccs(); pdf++)
    UpdateEbwWeightsDiagGmm(num_stats.GetAcc(pdf), den_stats.GetAcc(pdf),
                            opts, &(am_gmm->GetPdf(pdf)), auxf_change_out,
                            count_out);
}                     

UpdateEbwWeightsDiagGmm()

void UpdateEbwWeightsDiagGmm	(	const AccumDiagGmm &	num_stats,
		const AccumDiagGmm &	den_stats,
		const EbwWeightOptions &	opts,
		DiagGmm *	gmm,
		BaseFloat *	auxf_change_out,
		BaseFloat *	count_out
	)

Definition at line 207 of file ebw-diag-gmm.cc.

References DiagGmm::ComputeGconsts(), DiagGmmNormal::CopyFromDiagGmm(), VectorBase< Real >::CopyFromVec(), DiagGmmNormal::CopyToDiagGmm(), KALDI_ASSERT, KALDI_LOG, kGmmAll, EbwWeightOptions::min_gaussian_weight, EbwWeightOptions::min_num_count_weight_update, AccumDiagGmm::occupancy(), VectorBase< Real >::Sum(), EbwWeightOptions::tau, and DiagGmmNormal::weights_.

Referenced by EbwWeightOptions::Register(), UnitTestEstimateMmieDiagGmm(), and UpdateEbwWeightsAmDiagGmm().

                                                   {

  DiagGmmNormal diaggmmnormal;
  gmm->ComputeGconsts();
  diaggmmnormal.CopyFromDiagGmm(*gmm);

  Vector<double> weights(diaggmmnormal.weights_),
      num_occs(num_stats.occupancy()),
      den_occs(den_stats.occupancy());
  if (opts.tau == 0.0 &&
      num_occs.Sum() + den_occs.Sum() < opts.min_num_count_weight_update) {
    KALDI_LOG << "Not updating weights for this state because total count is "
              << num_occs.Sum() + den_occs.Sum() << " < "
              << opts.min_num_count_weight_update;
    if (count_out)
      *count_out += num_occs.Sum();
    return;
  }
  num_occs.AddVec(opts.tau, weights);
  KALDI_ASSERT(weights.Dim() == num_occs.Dim() && num_occs.Dim() == den_occs.Dim());
  if (weights.Dim() == 1) return; // Nothing to do: only one mixture.
  double weight_auxf_at_start = 0.0, weight_auxf_at_end = 0.0;
  
  int32 num_comp = weights.Dim();
  for (int32 g = 0; g < num_comp; g++) {   // c.f. eq. 4.32 in Dan Povey's thesis.
    weight_auxf_at_start +=
        num_occs(g) * log (weights(g))
        - den_occs(g) * weights(g) / diaggmmnormal.weights_(g);
  }
  for (int32 iter = 0; iter < 50; iter++) {
    Vector<double> k_jm(num_comp); // c.f. eq. 4.35
    double max_m = 0.0;
    for (int32 g = 0; g < num_comp; g++)
      max_m = std::max(max_m, den_occs(g)/diaggmmnormal.weights_(g));
    for (int32 g = 0; g < num_comp; g++)
      k_jm(g) = max_m - den_occs(g)/diaggmmnormal.weights_(g);
    for (int32 g = 0; g < num_comp; g++) // c.f. eq. 4.34
      weights(g) = num_occs(g) + k_jm(g)*weights(g);
    weights.Scale(1.0 / weights.Sum()); // c.f. eq. 4.34 (denominator)
  }
  for (int32 g = 0; g < num_comp; g++) {   // weight flooring.
    if (weights(g) < opts.min_gaussian_weight)
      weights(g) = opts.min_gaussian_weight;
  }
  weights.Scale(1.0 / weights.Sum()); // renormalize after flooring..
  // floor won't be exact now but doesn't really matter.

  for (int32 g = 0; g < num_comp; g++) {   // c.f. eq. 4.32 in Dan Povey's thesis.
    weight_auxf_at_end +=
        num_occs(g) * log (weights(g))
        - den_occs(g) * weights(g) / diaggmmnormal.weights_(g);
  }

  if (auxf_change_out)
    *auxf_change_out += weight_auxf_at_end - weight_auxf_at_start;
  if (count_out)
    *count_out += num_occs.Sum(); // only really valid for MMI [not MPE, or MMI
  // with canceled stats]
  
  diaggmmnormal.weights_.CopyFromVec(weights);

  // copy to natural representation
  diaggmmnormal.CopyToDiagGmm(gmm, kGmmAll);
  gmm->ComputeGconsts();
}

VecMatVec() [1/5]

Real VecMatVec	(	const CuVectorBase< Real > &	v1,
		const CuMatrixBase< Real > &	M,
		const CuVectorBase< Real > &	v2
	)

Returns .

Definition at line 83 of file cu-vector.cc.

References CuVectorBase< Real >::AddMatVec(), CuVectorBase< Real >::Dim(), KALDI_ASSERT, kNoTrans, kTrans, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), VecMatVec(), and VecVec().

                                             {
  KALDI_ASSERT(v1.Dim() == M.NumRows() && M.NumCols() == v2.Dim());
  if (v1.Dim() > v2.Dim()) {  // do v2*M first
    CuVector<Real> v2M(v1.Dim());
    v2M.AddMatVec(1.0, M, kNoTrans, v2, 0.0);
    return VecVec(v2M, v1);
  } else {  // do v1*M first
    CuVector<Real> v1M(v2.Dim());
    v1M.AddMatVec(1.0, M, kTrans, v1, 0.0);
    return VecVec(v1M, v2);
  }
}

VecMatVec() [2/5]

template float kaldi::VecMatVec	(	const CuVectorBase< float > &	v1,
		const CuMatrixBase< float > &	M,
		const CuVectorBase< float > &	v2
	)

VecMatVec() [3/5]

template double kaldi::VecMatVec	(	const CuVectorBase< double > &	v1,
		const CuMatrixBase< double > &	M,
		const CuVectorBase< double > &	v2
	)

VecMatVec() [4/5]

template float kaldi::VecMatVec	(	const VectorBase< float > &	v1,
		const MatrixBase< float > &	M,
		const VectorBase< float > &	v2
	)

VecMatVec() [5/5]

template double kaldi::VecMatVec	(	const VectorBase< double > &	v1,
		const MatrixBase< double > &	M,
		const VectorBase< double > &	v2
	)

Referenced by VecMatVec().

VecSpVec() [1/2]

template float kaldi::VecSpVec	(	const VectorBase< float > &	v1,
		const SpMatrix< float > &	M,
		const VectorBase< float > &	v2
	)

VecSpVec() [2/2]

template double kaldi::VecSpVec	(	const VectorBase< double > &	v1,
		const SpMatrix< double > &	M,
		const VectorBase< double > &	v2
	)

VecSvec() [1/2]

template float kaldi::VecSvec	(	const VectorBase< float > &	vec,
		const SparseVector< float > &	svec
	)

VecSvec() [2/2]

template double kaldi::VecSvec	(	const VectorBase< double > &	vec,
		const SparseVector< double > &	svec
	)

Referenced by TraceMatSmat().

VecVec() [1/10]

template float kaldi::VecVec	(	const VectorBase< float > &	a,
		const VectorBase< float > &	b
	)

VecVec() [2/10]

Real VecVec	(	const CuVectorBase< Real > &	a,
		const CuVectorBase< Real > &	b
	)

Definition at line 47 of file cu-vector.cc.

References CuVectorBase< Real >::Data(), CuVectorBase< Real >::Dim(), KALDI_ASSERT, CuVectorBase< Real >::Vec(), and VecVec().

                                         {
  //MatrixIndexT a_dim = a.Dim();
  KALDI_ASSERT(a.Dim() == b.Dim());
  Real result = 0;
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    CuTimer tim;
    CUBLAS_SAFE_CALL(cublas_dot(GetCublasHandle(), a.Dim(), a.Data(), 1, b.Data(),
                                1, &result));
    CuDevice::Instantiate().AccuProfile(__func__, tim);
} else
#endif
  {
    result = VecVec(a.Vec(), b.Vec());
  }
  return result;
}

VecVec() [3/10]

template double kaldi::VecVec	(	const VectorBase< double > &	a,
		const VectorBase< double > &	b
	)

VecVec() [4/10]

template float kaldi::VecVec	(	const VectorBase< float > &	ra,
		const VectorBase< double > &	rb
	)

VecVec() [5/10]

template float kaldi::VecVec	(	const CuVectorBase< float > &	a,
		const CuVectorBase< float > &	b
	)

VecVec() [6/10]

template double kaldi::VecVec	(	const CuVectorBase< double > &	a,
		const CuVectorBase< double > &	b
	)

VecVec() [7/10]

template double kaldi::VecVec	(	const VectorBase< double > &	ra,
		const VectorBase< float > &	rb
	)

Referenced by VecMatVec().

VecVec() [8/10]

Real VecVec	(	const CuVectorBase< Real > &	A,
		const CuVectorBase< OtherReal > &	B
	)

Definition at line 73 of file cu-vector.cc.

References VecVec().

                                                                           {
  CuVector<Real> B2(B);
  return VecVec(A, B2); // This will call the single-parameter template.
}

VecVec() [9/10]

template float kaldi::VecVec	(	const CuVectorBase< float > &	A,
		const CuVectorBase< double > &	B
	)

VecVec() [10/10]

template double kaldi::VecVec	(	const CuVectorBase< double > &	A,
		const CuVectorBase< float > &	B
	)

Referenced by CuVectorBase< float >::ApproxEqual().

VerifySymbolRange()

void kaldi::VerifySymbolRange	(	const std::string &	trace,
		const bool	want_found,
		const std::string &	want_symbol
	)

Definition at line 36 of file kaldi-error-test.cc.

References KALDI_ERR, and kaldi::internal::LocateSymbolRange().

Referenced by TestLocateSymbolRange().

                                                     {
  size_t begin, end;
  const bool found = internal::LocateSymbolRange(trace, &begin, &end);
  if (found != want_found) {
    KALDI_ERR << "Found mismatch, got " << found << " want " << want_found;
  }
  if (!found) {
    return;
  }
  const std::string symbol = trace.substr(begin, end - begin);
  if (symbol != want_symbol) {
    KALDI_ERR << "Symbol mismatch, got " << symbol << " want " << want_symbol;
  }
}

WithProb()

bool WithProb	(	BaseFloat	prob,
		struct RandomState *	state
	)

Definition at line 72 of file kaldi-math.cc.

References KALDI_ASSERT, KALDI_COMPILE_TIME_ASSERT, and Rand().

Referenced by GetCount(), kaldi::nnet2::GetCount(), kaldi::nnet3::GetCount(), SpecAugmentTimeMaskComponent::GetMemo(), main(), kaldi::nnet3::PerturbImage(), RescoreCompactLatticeInternal(), SparseVector< Real >::SetRandn(), UnitTestCuMatrixAddToElements(), and UnitTestRand().

                                                         {
  KALDI_ASSERT(prob >= 0 && prob <= 1.1);  // prob should be <= 1.0,
  // but we allow slightly larger values that could arise from roundoff in
  // previous calculations.
  KALDI_COMPILE_TIME_ASSERT(RAND_MAX > 128 * 128);
  if (prob == 0) return false;
  else if (prob == 1.0) return true;
  else if (prob * RAND_MAX < 128.0) {
    // prob is very small but nonzero, and the "main algorithm"
    // wouldn't work that well.  So: with probability 1/128, we
    // return WithProb (prob * 128), else return false.
    if (Rand(state) < RAND_MAX / 128) {  // with probability 128...
      // Note: we know that prob * 128.0 < 1.0, because
      // we asserted RAND_MAX > 128 * 128.
      return WithProb(prob * 128.0);
    } else {
      return false;
    }
  } else {
    return (Rand(state) < ((RAND_MAX + static_cast<BaseFloat>(1.0)) * prob));
  }
}

WordAlignLattice()

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.

[May also have epsilon arcs for optional silences.] Returns true if everything was OK, false if some kind of error was detected (e.g. the words didn't have the kinds of sequences we would expect if the WordBoundaryInfo was correct). Note: we don't expect silence inside words, or empty words (words with no phones), and we expect the word to start with a wbegin_phone, to end with a wend_phone, and to possibly have winternal_phones inside (or to consist of just one wbegin_and_end_phone). Note: if it returns false, it doesn't mean the lattice that the output is necessarily bad: it might just be that the lattice was "forced out" as the end-state was not reached during decoding, and in this case the output might be usable. If max_states > 0, if this code detects that the #states of the output will be greater than max_states, it will abort the computation, return false and produce an empty lattice out.

Definition at line 723 of file word-align-lattice.cc.

References LatticeWordAligner::AlignLattice().

Referenced by main().

                                               {
  LatticeWordAligner aligner(lat, tmodel, info, max_states, lat_out);
  return aligner.AlignLattice();
}

WordAlignLatticeLexicon()

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.

[May also have epsilon arcs for optional silences.] Returns true if everything was OK, false if there was any kind of error including when the the lattice seems to have been "forced out" (did not reach end state, resulting in partial word at end).

Definition at line 1001 of file word-align-lattice-lexicon.cc.

References LatticeLexiconWordAligner::AlignLattice(), WordAlignLatticeLexiconOpts::allow_duplicate_paths, KALDI_WARN, WordAlignLatticeLexiconOpts::max_expand, WordAlignLatticeLexiconOpts::partial_word_label, PhoneAlignLattice(), PhoneAlignLatticeOptions::remove_epsilon, PhoneAlignLatticeOptions::reorder, WordAlignLatticeLexiconOpts::reorder, PhoneAlignLatticeOptions::replace_output_symbols, WordAlignLatticeLexiconOpts::test, and TestWordAlignedLattice().

Referenced by main(), WordAlignLatticeLexiconOpts::Register(), and TestWordAlignLatticeLexicon().

                                                      {
  PhoneAlignLatticeOptions phone_align_opts;
  phone_align_opts.reorder = opts.reorder;
  phone_align_opts.replace_output_symbols = false;
  phone_align_opts.remove_epsilon = false;

  // Input Lattice should be deterministic and w/o epsilons.
  bool test = true;
  uint64 props = lat.Properties(fst::kIDeterministic|fst::kIEpsilons, test);
  if (props != fst::kIDeterministic) {
    KALDI_WARN << "[Lattice has input epsilons and/or is not input-deterministic "
               << "(in Mohri sense)]-- i.e. lattice is not deterministic.  "
               << "Word-alignment may be slow and-or blow up in memory.";
  }

  CompactLattice phone_aligned_lat;
  bool ans = PhoneAlignLattice(lat, tmodel, phone_align_opts,
                               &phone_aligned_lat);
  // 'phone_aligned_lat' is no longer deterministic and contains epsilons.

  int32 max_states;
  if (opts.max_expand <= 0) {
    max_states = -1;
  } else {
    // The 1000 is a fixed offset to give it more wiggle room for very
    // small inputs.
    max_states = kNumStatesOffset + opts.max_expand * phone_aligned_lat.NumStates();
  }

  // If ans == false, we hope this is due to a forced-out lattice, and we try to
  // continue.
  LatticeLexiconWordAligner aligner(phone_aligned_lat, tmodel, lexicon_info,
                                    max_states, opts.partial_word_label, lat_out);
  // We'll let the calling code warn if this is false; it will know the utterance-id.
  ans = aligner.AlignLattice() && ans;
  if (ans && opts.test) { // We only test if it succeeded.
    if (!TestWordAlignedLattice(lexicon_info, tmodel, lat, *lat_out,
                                opts.allow_duplicate_paths)) {
      KALDI_WARN << "Lattice failed test (activated because --test=true). "
                 << "Probable code error, please contact Kaldi maintainers.";
      ans = false;
    }
  }
  return ans;
}

WriteAsKaldiVector()

void kaldi::WriteAsKaldiVector	(	const std::vector< double > &	counts,
		std::string &	wxfilename,
		bool	binary
	)

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

References rnnlm::i, and WriteKaldiObject().

Referenced by main().

                                     {
  Vector<BaseFloat> counts_vec(counts.size());
  for (size_t i = 0; i < counts.size(); i++)
    counts_vec(i) = counts[i];
  WriteKaldiObject(counts_vec, wxfilename, binary);
}

WriteCompactLattice()

bool WriteCompactLattice	(	std::ostream &	os,
		bool	binary,
		const CompactLattice &	t
	)

Definition at line 62 of file kaldi-lattice.cc.

References KALDI_WARN.

Referenced by TestWordAlignLatticeLexicon(), CompactLatticeHolder::Write(), and DiscriminativeNnetExample::Write().

                                                  {
  if (binary) {
    fst::FstWriteOptions opts;
    // Leave all the options default.  Normally these lattices wouldn't have any
    // osymbols/isymbols so no point directing it not to write them (who knows what
    // we'd want to if we had them).
    return t.Write(os, opts);
  } else {
    // Text-mode output.  Note: we expect that t.InputSymbols() and
    // t.OutputSymbols() would always return NULL.  The corresponding input
    // routine would not work if the FST actually had symbols attached.
    // Write a newline after the key, so the first line of the FST appears
    // on its own line.
    os << '\n';
    bool acceptor = true, write_one = false;
    fst::FstPrinter<CompactLatticeArc> printer(t, t.InputSymbols(),
                                               t.OutputSymbols(),
                                               NULL, acceptor, write_one, "\t");
    printer.Print(&os, "<unknown>");
    if (os.fail())
      KALDI_WARN << "Stream failure detected.";
    // Write another newline as a terminating character.  The read routine will
    // detect this [this is a Kaldi mechanism, not somethig in the original
    // OpenFst code].
    os << '\n';
    return os.good();
  }
}

WriteEventType()

void WriteEventType	(	std::ostream &	os,
		bool	binary,
		const EventType &	evec
	)

Definition at line 228 of file event-map.cc.

References rnnlm::i, WriteBasicType(), and WriteToken().

Referenced by MakeEventPair(), TestEventTypeIo(), and WriteBuildTreeStats().

                                                                        {
  WriteToken(os, binary, "EV");
  uint32 size = evec.size();
  WriteBasicType(os, binary, size);
  for (size_t i = 0; i < size; i++) {
    WriteBasicType(os, binary, evec[i].first);
    WriteBasicType(os, binary, evec[i].second);
  }
  if (!binary) os << '\n';
}

WriteFull()

bool WriteFull	(	int32	desc,
		char *	data,
		int32	size
	)

Definition at line 340 of file online-audio-client.cc.

Referenced by main().

                                                   {
  int32 to_write = size;
  int32 wrote = 0;
  while (to_write > 0) {
    int32 ret = write(desc, data + wrote, to_write);
    if (ret <= 0)
      return false;

    to_write -= ret;
    wrote += ret;
  }

  return true;
}

WriteHtk() [1/2]

template bool kaldi::WriteHtk	(	std::ostream &	os,
		const MatrixBase< float > &	M,
		HtkHeader	htk_hdr
	)

WriteHtk() [2/2]

template bool kaldi::WriteHtk	(	std::ostream &	os,
		const MatrixBase< double > &	M,
		HtkHeader	htk_hdr
	)

Referenced by WriteHtk().

WriteIntegerVectorSimple()

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.

returns true if succeeded.

Definition at line 24 of file simple-io-funcs.cc.

References Output::Close(), rnnlm::i, Output::Open(), and Output::Stream().

Referenced by main().

                                                            {
  kaldi::Output ko;
  // false, false is: text-mode, no Kaldi header.
  if (!ko.Open(wxfilename, false, false)) return false;
  for (size_t i = 0; i < list.size(); i++) ko.Stream() << list[i] << '\n';
  return ko.Close();
}

WriteIntegerVectorVectorSimple()

bool WriteIntegerVectorVectorSimple	(	const std::string &	wxfilename,
		const std::vector< std::vector< int32 > > &	list
	)

Definition at line 46 of file simple-io-funcs.cc.

References Output::Close(), rnnlm::i, rnnlm::j, Output::Open(), and Output::Stream().

Referenced by main().

                                                                           {
  kaldi::Output ko;
  // false, false is: text-mode, no Kaldi header.
  if (!ko.Open(wxfilename, false, false)) return false;
  std::ostream &os = ko.Stream();
  for (size_t i = 0; i < list.size(); i++) {
    for (size_t j = 0; j < list[i].size(); j++) {
      os << list[i][j];
      if (j+1 < list[i].size()) os << ' ';
    }
    os << '\n';
  }
  return ko.Close();
}

WriteLattice()

bool WriteLattice	(	std::ostream &	os,
		bool	binary,
		const Lattice &	t
	)

Definition at line 388 of file kaldi-lattice.cc.

References KALDI_WARN.

Referenced by LatticeHolder::Write(), and DiscriminativeSupervision::Write().

                                                                 {
  if (binary) {
    fst::FstWriteOptions opts;
    // Leave all the options default.  Normally these lattices wouldn't have any
    // osymbols/isymbols so no point directing it not to write them (who knows what
    // we'd want to do if we had them).
    return t.Write(os, opts);
  } else {
    // Text-mode output.  Note: we expect that t.InputSymbols() and
    // t.OutputSymbols() would always return NULL.  The corresponding input
    // routine would not work if the FST actually had symbols attached.
    // Write a newline after the key, so the first line of the FST appears
    // on its own line.
    os << '\n';
    bool acceptor = false, write_one = false;
    fst::FstPrinter<LatticeArc> printer(t, t.InputSymbols(),
                                        t.OutputSymbols(),
                                        NULL, acceptor, write_one, "\t");
    printer.Print(&os, "<unknown>");
    if (os.fail())
      KALDI_WARN << "Stream failure detected.";
    // Write another newline as a terminating character.  The read routine will
    // detect this [this is a Kaldi mechanism, not somethig in the original
    // OpenFst code].
    os << '\n';
    return os.good();
  }
}

WriteLine()

bool WriteLine	(	int32	socket,
		std::string	line
	)

Definition at line 406 of file online-audio-server-decode-faster.cc.

Referenced by main().

                                             {
  line = line + "\n";

  const char* p = line.c_str();
  int32 to_write = line.size();
  int32 wrote = 0;
  while (to_write > 0) {
    int32 ret = write(socket, p + wrote, to_write);
    if (ret <= 0)
      return false;

    to_write -= ret;
    wrote += ret;
  }

  return true;
}

WriteSphinx() [1/2]

template bool kaldi::WriteSphinx	(	std::ostream &	os,
		const MatrixBase< float > &	M
	)

WriteSphinx() [2/2]

template bool kaldi::WriteSphinx	(	std::ostream &	os,
		const MatrixBase< double > &	M
	)

Referenced by WriteSphinx().

WriteUint16()

static void kaldi::WriteUint16 ( std::ostream &  os, int16  i  )

static

Definition at line 100 of file wave-reader.cc.

References rnnlm::i, KALDI_ERR, and KALDI_SWAP2.

Referenced by WaveData::Write().

                                                 {
  union {
    char buf[2];
    int16 i;
  } u;
  u.i = i;
#ifdef __BIG_ENDIAN__
  KALDI_SWAP2(u.buf);
#endif
  os.write(u.buf, 2);
  if (os.fail())
    KALDI_ERR << "WaveData: error writing to stream.";
}

WriteUint32()

static void kaldi::WriteUint32 ( std::ostream &  os, int32  i  )

static

Definition at line 86 of file wave-reader.cc.

References rnnlm::i, KALDI_ERR, and KALDI_SWAP4.

Referenced by WaveData::Write().

                                                 {
  union {
    char buf[4];
    int i;
  } u;
  u.i = i;
#ifdef __BIG_ENDIAN__
  KALDI_SWAP4(u.buf);
#endif
  os.write(u.buf, 4);
  if (os.fail())
    KALDI_ERR << "WaveData: error writing to stream.";
}

Xgemv_sparsevec()

void kaldi::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  )

inline

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

References cblas_Xaxpy(), cblas_Xscal(), rnnlm::i, and kNoTrans.

Referenced by MatrixBase< float >::AddMatSmat(), VectorBase< float >::AddMatSvec(), SpMatrix< float >::AddSmat2Sp(), and MatrixBase< float >::AddSmatMat().

                                               {
  if (trans == kNoTrans) {
    if (beta != 1.0) cblas_Xscal(num_rows, beta, ydata, incY);
    for (MatrixIndexT i = 0; i < num_cols; i++) {
      Real x_i = xdata[i * incX];
      if (x_i == 0.0) continue;
      // Add to ydata, the i'th column of M, times alpha * x_i
      cblas_Xaxpy(num_rows, x_i * alpha, Mdata + i, stride, ydata, incY);
    }    
  } else {
    if (beta != 1.0) cblas_Xscal(num_cols, beta, ydata, incY);
    for (MatrixIndexT i = 0; i < num_rows; i++) {
      Real x_i = xdata[i * incX];
      if (x_i == 0.0) continue;
      // Add to ydata, the i'th row of M, times alpha * x_i
      cblas_Xaxpy(num_cols, x_i * alpha,
                  Mdata + (i * stride), 1, ydata, incY);
    }
  }
}

Variable Documentation

_RandMutex

std::mutex _RandMutex

static

Definition at line 43 of file kaldi-math.cc.

buffer_fill

int32 buffer_fill = 0

Definition at line 356 of file online-audio-client.cc.

Referenced by ReadLine().

buffer_offset

int32 buffer_offset = 0

Definition at line 355 of file online-audio-client.cc.

Referenced by ReadLine().

g_allocator_options

CuAllocatorOptions g_allocator_options

Definition at line 644 of file cu-allocator.cc.

Referenced by CuAllocatorOptions::Check().

g_num_threads

int32 g_num_threads = 8

Definition at line 25 of file kaldi-thread.cc.

Referenced by IvectorExtractor::ComputeDerivedVars(), kaldi::nnet2::DoBackpropParallel(), main(), TestThreads(), IvectorExtractorStats::UpdateProjections(), and IvectorExtractorStats::UpdateWeights().

g_profile_stats

ProfileStats g_profile_stats

Definition at line 79 of file timer.cc.

kFramesPerSecond

const float kFramesPerSecond = 100.0f

Definition at line 65 of file online-audio-server-decode-faster.cc.

Referenced by main().

kLogZeroBaseFloat

const BaseFloat kLogZeroBaseFloat = -std::numeric_limits<BaseFloat>::infinity()

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

kLogZeroDouble

const double kLogZeroDouble = -std::numeric_limits<double>::infinity()

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

Referenced by ComputeCompactLatticeAlphas(), ComputeCompactLatticeBetas(), ComputeLatticeAlphasAndBetas(), MinimumBayesRisk::EditDistance(), LatticeForwardBackward(), LatticeForwardBackwardMpeVariants(), LogSub(), VectorBase< float >::LogSumExp(), MatrixBase< float >::LogSumExp(), and UnitTestDefines().

kLogZeroFloat

const float kLogZeroFloat = -std::numeric_limits<float>::infinity()

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

Referenced by LogSub(), VectorBase< float >::LogSumExp(), MatrixBase< float >::LogSumExp(), and UnitTestDefines().

kMaxVal

const int32 kMaxVal = 20

Definition at line 143 of file event-map-test.cc.

Referenced by RandomEventMap(), and TestEventMapMapValues().

kMinLogDiffDouble

const double kMinLogDiffDouble = Log(DBL_EPSILON)

static

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

Referenced by VectorBase< float >::LogSumExp(), and MatrixBase< float >::LogSumExp().

kMinLogDiffFloat

const float kMinLogDiffFloat = Log(FLT_EPSILON)

static

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

Referenced by VectorBase< float >::LogSumExp(), and MatrixBase< float >::LogSumExp().

kNumStatesOffset

const int kNumStatesOffset = 1000

Definition at line 31 of file word-align-lattice-lexicon.cc.

kPdfClass

const EventKeyType kPdfClass = -1

static

Definition at line 39 of file context-dep.h.

Referenced by AccumulateTreeStats(), AutomaticallyObtainQuestions(), ContextDependency::Compute(), ContextDependency::EnumeratePairs(), GenRandStats(), GetFullBiphoneStubMap(), ContextDependency::GetPdfInfo(), GetStubMap(), GetToLengthMap(), KMeansClusterPhones(), main(), TreeRenderer::MakeEdgeLabel(), MakeEvent(), TreeRenderer::RenderNonLeaf(), TreeRenderer::RenderTable(), and TestGenRandStats().

kRandomSentences

const int kRandomSentences = 50

static

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

Referenced by CoverageTest().

kShellType

ShellType kShellType = kBash

static

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

kTemporaryEpsilon

const int kTemporaryEpsilon = -2

Definition at line 30 of file word-align-lattice-lexicon.cc.

Referenced by WordAlignLatticeLexiconInfo::UpdateLexiconMap().

kWaveSampleMax

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].

Definition at line 62 of file wave-reader.h.

log_handler

LogHandler log_handler = NULL

static

Definition at line 48 of file kaldi-error.cc.

Referenced by MessageLogger::LogMessage(), and SetLogHandler().

pitch_use_naive_search

bool pitch_use_naive_search = false

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

Referenced by UnitTestDelay().

program_name

std::string program_name

static

Definition at line 47 of file kaldi-error.cc.

read_buffer

char read_buffer[1025]

Definition at line 357 of file online-audio-client.cc.

ws_delim

const char* ws_delim = " \t\n\r"

Definition at line 32 of file text-utils-test.cc.