kaldi.transform¶

Functions

`apply_affine_transform`	Calls C++ function
`compose_transforms`	Calls C++ function

Classes

`AffineXformStats`	CLIF wrapper for ::kaldi::AffineXformStats
`CompressedAffineXformStats`	CLIF wrapper for ::kaldi::CompressedAffineXformStats
`RegressionTree`	CLIF wrapper for ::kaldi::RegressionTree

class kaldi.transform.AffineXformStats¶

CLIF wrapper for ::kaldi::AffineXformStats

G_¶: C++ ::std::vector< ::kaldi::SpMatrix<double> > AffineXformStats.G_

K_¶: C++ ::kaldi::Matrix<double> AffineXformStats.K_

add(other:AffineXformStats)¶: Calls C++ function void ::kaldi::AffineXformStats::Add(::kaldi::AffineXformStats)

beta_¶: C++ double AffineXformStats.beta_

copy_stats(other:AffineXformStats)¶: Calls C++ function void ::kaldi::AffineXformStats::CopyStats(::kaldi::AffineXformStats)

dim() → int¶: Calls C++ function int ::kaldi::AffineXformStats::Dim()

dim_¶: C++ ::int32 AffineXformStats.dim_

init(dim:int, num_gs:int)¶: Calls C++ function void ::kaldi::AffineXformStats::Init(int, int)

new(other:AffineXformStats) → AffineXformStats¶: Calls C++ function std::unique_ptr<::kaldi::AffineXformStats> ::kaldi::AffineXformStats::AffineXformStats(::kaldi::AffineXformStats)

read(is:istream, binary:bool, add:bool)¶: Calls C++ function void ::kaldi::AffineXformStats::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

set_zero()¶: Calls C++ function void ::kaldi::AffineXformStats::SetZero()

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::AffineXformStats::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.CompressedAffineXformStats¶

CLIF wrapper for ::kaldi::CompressedAffineXformStats

copy_from_affine_xform_stats(input:AffineXformStats)¶: Calls C++ function void ::kaldi::CompressedAffineXformStats::CopyFromAffineXformStats(::kaldi::AffineXformStats)

copy_to_affine_xform_stats() → AffineXformStats¶: Calls C++ function void ::kaldi::CompressedAffineXformStats::CopyToAffineXformStats(::kaldi::AffineXformStats*)

new(input:AffineXformStats) → CompressedAffineXformStats¶: Calls C++ function std::unique_ptr<::kaldi::CompressedAffineXformStats> ::kaldi::CompressedAffineXformStats::CompressedAffineXformStats(::kaldi::AffineXformStats)

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::CompressedAffineXformStats::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::CompressedAffineXformStats::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.RegressionTree¶

CLIF wrapper for ::kaldi::RegressionTree

build_tree(state_occs:Vector, sil_indices:list<int>, am:AmDiagGmm, max_clusters:int)¶: Calls C++ function void ::kaldi::RegressionTree::BuildTree(::kaldi::Vector<float>, ::std::vector< ::int32>, ::kaldi::AmDiagGmm, int)

gather_stats(stats_in:list<AffineXformStats>, min_count:float) -> (success:bool, regclasses_out:list<int>, stats_out:list<AffineXformStats>)¶: Calls C++ function bool ::kaldi::RegressionTree::GatherStats(::std::vector< ::kaldi::AffineXformStats >, double, ::std::vector< ::int32>, ::std::vector< ::kaldi::AffineXformStats >)

gauss_to_base_class_id(pdf_id:int, gauss_id:int) → int¶: Calls C++ function int ::kaldi::RegressionTree::Gauss2BaseclassId(unsigned long, unsigned long)

get_base_class(bclass:int) → list<tuple<int, int>>¶: Calls C++ function ::std::vector< ::std::pair< ::int32, ::int32> > ::kaldi::RegressionTree::GetBaseclass(int)

num_base_classes() → int¶: Calls C++ function int ::kaldi::RegressionTree::NumBaseclasses()

read(is:istream, binary:bool, am:AmDiagGmm)¶: Calls C++ function void ::kaldi::RegressionTree::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, ::kaldi::AmDiagGmm)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::RegressionTree::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

kaldi.transform.apply_affine_transform(xform:MatrixBase, vec:VectorBase)¶: Calls C++ function void ::kaldi::ApplyAffineTransform(::kaldi::MatrixBase<float>, ::kaldi::VectorBase<float> *)

kaldi.transform.compose_transforms(a:Matrix, b:Matrix, b_is_affine:bool) -> (success:bool, c:Matrix)¶: Calls C++ function bool ::kaldi::ComposeTransforms(::kaldi::Matrix<float>, ::kaldi::Matrix<float>, bool, ::kaldi::Matrix<float>*)

kaldi.transform.cmvn¶

Classes

Cmvn Cepstral mean variance normalization (CMVN).

class kaldi.transform.cmvn.Cmvn(dim=None)[source]¶

Cepstral mean variance normalization (CMVN).

This class is used for accumulating CMVN statistics and applying CMVN using accumulated statistics. Global CMVN can be computed and applied as follows:

cmvn = Cmvn(40)  # 40 dimensional features

for key, feats in SequentialMatrixReader("ark:feats.ark"):
    cmvn.accumulate(feats)

with MatrixWriter("ark:feats_norm.ark") as writer:
    for key, feats in SequentialMatrixReader("ark:feats.ark"):
        cmvn.apply(feats, norm_vars=True)
        writer[key] = feats

Variables: stats (DoubleMatrix or None) – Accumulated mean/variance statistics matrix of size 2 x dim+1. This matrix is initialized when a CMVN object is instantiated by specifying a feature dimension or when the init() method is explicitly called. It is None otherwise. stats[0,:-1] represents the sum of accumulated feature vectors. stats[1,:-1] represents the sum of element-wise squares of accumulated feature vectors. stats[0,-1] represents the total count of accumulated feature vectors. stats[1,-1] is initialized to zero but otherwise is not used.

Parameters: dim (int) – The feature dimension. If specified, stats matrix is initialized with the given dimension.

accumulate(feats, weights=None)[source]¶

Accumulates CMVN statistics.

Computes the CMVN statistics for given features and adds them to the stats matrix.

Parameters:	feats (VectorBase or MatrixBase) – The input features. weights (float or VectorBase) – The frame weights. If `feats` is a single feature vector, then `weights` should be a single number. If `feats` is a feature matrix, then `weights` should be a vector of size `feats.num_rows`. If `weights` is not specified or `None`, then no frame weighting is done.

apply(feats, norm_vars=False, reverse=False)[source]¶

Applies CMVN to the given feature matrix.

Parameters:	feats (Matrix) – The feature matrix to normalize. norm_vars (bool) – Whether to apply variance normalization. reverse (bool) – Whether to apply CMVN in a reverse sense, so as to transform zero-mean, unit-variance features into features with the desired mean and variance.

init(dim)[source]¶

Initializes the CMVN statistics matrix.

This method is called during object initialization. It can also be called at a later time to initialize or reset the internal statistics matrix.

Parameters:	dim (int or None) – The feature dimension. If `None`, then `stats` attribute is set to `None`. Otherwise, it is initialized as a `2 x dim+1` matrix of zeros.

read_stats(rxfilename, binary=True)[source]¶

Reads CMVN statistics from file.

Parameters:	rxfilename (str) – Extended filename for reading CMVN statistics. binary (bool) – Whether to open the file in binary mode.

skip_dims(dims)[source]¶

Modifies the stats to skip normalization for given dimensions.

This is a destructive operation. The statistics for given dimensions are replaced with fake values that effectively disable normalization in those dimensions. This method should only be called after statistics accumulation is finished since accumulation modifies the stats matrix.

Parameters:	dims (List[int]) – Dimensions for which to skip normalization.

write_stats(wxfilename, binary=True)[source]¶

Writes CMVN statistics to file.

Parameters:	wxfilename (str) – Extended filename for writing CMVN statistics. binary (bool) – Whether to open the file in binary mode.

kaldi.transform.fmpe¶

Functions

compute_am_gmm_feature_deriv Calls C++ function

Classes

`Fmpe`	CLIF wrapper for ::kaldi::Fmpe
`FmpeOptions`	CLIF wrapper for ::kaldi::FmpeOptions
`FmpeStats`	CLIF wrapper for ::kaldi::FmpeStats
`FmpeUpdateOptions`	CLIF wrapper for ::kaldi::FmpeUpdateOptions

class kaldi.transform.fmpe.Fmpe¶

CLIF wrapper for ::kaldi::Fmpe

acc_stats(feat_in:MatrixBase, gselect:list<list<int>>, direct_feat_deriv:MatrixBase, indirect_feat_deriv:MatrixBase, stats:FmpeStats)¶: Calls C++ function void ::kaldi::Fmpe::AccStats(::kaldi::MatrixBase<float>, ::std::vector< ::std::vector< ::int32> >, ::kaldi::MatrixBase<float>, ::kaldi::MatrixBase<float> *, ::kaldi::FmpeStats *)

compute_features(feat_in:MatrixBase, gselect:list<list<int>>) → Matrix¶: Calls C++ function void ::kaldi::Fmpe::ComputeFeatures(::kaldi::MatrixBase<float>, ::std::vector< ::std::vector< ::int32> >, ::kaldi::Matrix<float>*)

feat_dim() → int¶: Calls C++ function int ::kaldi::Fmpe::FeatDim()

new(gmm:DiagGmm, config:FmpeOptions) → Fmpe¶: Calls C++ function std::unique_ptr<::kaldi::Fmpe> ::kaldi::Fmpe::Fmpe(::kaldi::DiagGmm, ::kaldi::FmpeOptions)

num_contexts() → int¶: Calls C++ function int ::kaldi::Fmpe::NumContexts()

num_gauss() → int¶: Calls C++ function int ::kaldi::Fmpe::NumGauss()

projection_t_num_cols() → int¶: Calls C++ function int ::kaldi::Fmpe::ProjectionTNumCols()

projection_t_num_rows() → int¶: Calls C++ function int ::kaldi::Fmpe::ProjectionTNumRows()

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::Fmpe::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

update(config:FmpeUpdateOptions, stats:FmpeStats) → float¶: Calls C++ function float ::kaldi::Fmpe::Update(::kaldi::FmpeUpdateOptions, ::kaldi::FmpeStats)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::Fmpe::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.fmpe.FmpeOptions¶

CLIF wrapper for ::kaldi::FmpeOptions

context_expansion¶: C++ ::std::string FmpeOptions.context_expansion

post_scale¶: C++ ::kaldi::BaseFloat FmpeOptions.post_scale

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::FmpeOptions::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::FmpeOptions::Register(::kaldi::OptionsItf *)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::FmpeOptions::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.fmpe.FmpeStats¶

CLIF wrapper for ::kaldi::FmpeStats

accumulate_checks(feats:MatrixBase, direct_deriv:MatrixBase, indirect_deriv:MatrixBase)¶: Calls C++ function void ::kaldi::FmpeStats::AccumulateChecks(::kaldi::MatrixBase<float>, ::kaldi::MatrixBase<float>, ::kaldi::MatrixBase<float>)

deriv_minus() → SubMatrix¶: Calls C++ function ::kaldi::SubMatrix<float> ::kaldi::FmpeStats::DerivMinus()

deriv_plus() → SubMatrix¶: Calls C++ function ::kaldi::SubMatrix<float> ::kaldi::FmpeStats::DerivPlus()

do_checks()¶: Calls C++ function void ::kaldi::FmpeStats::DoChecks()

read(is:istream, binary:bool, add:bool=default)¶: Calls C++ function void ::kaldi::FmpeStats::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::FmpeStats::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.fmpe.FmpeUpdateOptions¶

CLIF wrapper for ::kaldi::FmpeUpdateOptions

l2_weight¶: C++ ::kaldi::BaseFloat FmpeUpdateOptions.l2_weight

learning_rate¶: C++ ::kaldi::BaseFloat FmpeUpdateOptions.learning_rate

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::FmpeUpdateOptions::Register(::kaldi::OptionsItf *)

kaldi.transform.fmpe.compute_am_gmm_feature_deriv(am_gmm:AmDiagGmm, trans_model:TransitionModel, posterior:list<list<tuple<int, float>>>, features:MatrixBase, direct_deriv:Matrix, model_diff:AccumAmDiagGmm=default, indirect_deriv:Matrix=default) → float¶: Calls C++ function float ::kaldi::ComputeAmGmmFeatureDeriv(::kaldi::AmDiagGmm, ::kaldi::TransitionModel, ::kaldi::Posterior, ::kaldi::MatrixBase<float>, ::kaldi::Matrix<float> *, ::kaldi::AccumAmDiagGmm *, ::kaldi::Matrix<float> *)

kaldi.transform.lda¶

Classes

`LdaEstimate`	CLIF wrapper for ::kaldi::LdaEstimate
`LdaEstimateOptions`	CLIF wrapper for ::kaldi::LdaEstimateOptions

class kaldi.transform.lda.LdaEstimate¶

CLIF wrapper for ::kaldi::LdaEstimate

accumulate(data:VectorBase, class_id:int, weight:float=default)¶: Calls C++ function void ::kaldi::LdaEstimate::Accumulate(::kaldi::VectorBase<float>, int, float)

dim() → int¶: Calls C++ function int ::kaldi::LdaEstimate::Dim()

estimate(opts:LdaEstimateOptions, M:Matrix, Mfull:Matrix=default)¶: Calls C++ function void ::kaldi::LdaEstimate::Estimate(::kaldi::LdaEstimateOptions, ::kaldi::Matrix<float> *, ::kaldi::Matrix<float> *)

init(num_classes:int, dimension:int)¶: Calls C++ function void ::kaldi::LdaEstimate::Init(int, int)

num_classes() → int¶: Calls C++ function int ::kaldi::LdaEstimate::NumClasses()

read(is:istream, binary:bool, add:bool)¶: Calls C++ function void ::kaldi::LdaEstimate::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

scale(f:float)¶: Calls C++ function void ::kaldi::LdaEstimate::Scale(float)

tot_count() → float¶: Calls C++ function double ::kaldi::LdaEstimate::TotCount()

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::LdaEstimate::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

zero_accumulators()¶: Calls C++ function void ::kaldi::LdaEstimate::ZeroAccumulators()

class kaldi.transform.lda.LdaEstimateOptions¶

CLIF wrapper for ::kaldi::LdaEstimateOptions

allow_large_dim¶: C++ bool LdaEstimateOptions.allow_large_dim

dim¶: C++ ::int32 LdaEstimateOptions.dim

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::LdaEstimateOptions::Register(::kaldi::OptionsItf *)

remove_offset¶: C++ bool LdaEstimateOptions.remove_offset

within_class_factor¶: C++ ::kaldi::BaseFloat LdaEstimateOptions.within_class_factor

kaldi.transform.lvtln¶

Classes

LinearVtln CLIF wrapper for ::kaldi::LinearVtln

class kaldi.transform.lvtln.LinearVtln¶

CLIF wrapper for ::kaldi::LinearVtln

dim() → int¶: Calls C++ function int ::kaldi::LinearVtln::Dim()

get_transform(i:int, transform:MatrixBase)¶: Calls C++ function void ::kaldi::LinearVtln::GetTransform(int, ::kaldi::MatrixBase<float> *)

get_warp(i:int) → float¶: Calls C++ function float ::kaldi::LinearVtln::GetWarp(int)

new(dim:int, num_classes:int, default_class:int) → LinearVtln¶: Calls C++ function std::unique_ptr<::kaldi::LinearVtln> ::kaldi::LinearVtln::LinearVtln(int, int, int)

num_classes() → int¶: Calls C++ function int ::kaldi::LinearVtln::NumClasses()

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::LinearVtln::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

set_transform(i:int, transform:MatrixBase)¶: Calls C++ function void ::kaldi::LinearVtln::SetTransform(int, ::kaldi::MatrixBase<float>)

set_warp(i:int, warp:float)¶: Calls C++ function void ::kaldi::LinearVtln::SetWarp(int, float)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::LinearVtln::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

kaldi.transform.mllr¶

Functions

`apply_feature_transform_to_stats`	Calls C++ function
`apply_model_transform_to_stats`	Calls C++ function
`compute_fmllr_log_det`	Calls C++ function
`compute_fmllr_matrix_diag_gmm`	Calls C++ function
`compute_fmllr_matrix_diag_gmm_diagonal`	Calls C++ function
`compute_fmllr_matrix_diag_gmm_full`	Calls C++ function
`compute_fmllr_matrix_diag_gmm_offset`	Calls C++ function
`fmllr_aux_func_diag_gmm`	Calls C++ function
`fmllr_aux_func_diag_gmm_double`	Calls C++ function
`fmllr_auxf_gradient`	Calls C++ function
`fmllr_inner_update`	Calls C++ function
`init_fmllr`	Calls C++ function

Classes

`BasisFmllrAccus`	CLIF wrapper for ::kaldi::BasisFmllrAccus
`BasisFmllrEstimate`	CLIF wrapper for ::kaldi::BasisFmllrEstimate
`BasisFmllrOptions`	CLIF wrapper for ::kaldi::BasisFmllrOptions
`DecodableAmDiagGmmRegtreeFmllr`	CLIF wrapper for ::kaldi::DecodableAmDiagGmmRegtreeFmllr
`DecodableAmDiagGmmRegtreeMllr`	CLIF wrapper for ::kaldi::DecodableAmDiagGmmRegtreeMllr
`FmllrDiagGmmAccs`	CLIF wrapper for ::kaldi::FmllrDiagGmmAccs
`FmllrOptions`	CLIF wrapper for ::kaldi::FmllrOptions
`FmllrRawAccs`	CLIF wrapper for ::kaldi::FmllrRawAccs
`FmllrRawOptions`	CLIF wrapper for ::kaldi::FmllrRawOptions
`RegtreeFmllrDiagGmm`	CLIF wrapper for ::kaldi::RegtreeFmllrDiagGmm
`RegtreeFmllrDiagGmmAccs`	CLIF wrapper for ::kaldi::RegtreeFmllrDiagGmmAccs
`RegtreeFmllrOptions`	CLIF wrapper for ::kaldi::RegtreeFmllrOptions
`RegtreeMllrDiagGmm`	CLIF wrapper for ::kaldi::RegtreeMllrDiagGmm
`RegtreeMllrDiagGmmAccs`	CLIF wrapper for ::kaldi::RegtreeMllrDiagGmmAccs
`RegtreeMllrOptions`	CLIF wrapper for ::kaldi::RegtreeMllrOptions

class kaldi.transform.mllr.BasisFmllrAccus¶

CLIF wrapper for ::kaldi::BasisFmllrAccus

accu_gradient_scatter(spk_stats:AffineXformStats)¶: Calls C++ function void ::kaldi::BasisFmllrAccus::AccuGradientScatter(::kaldi::AffineXformStats)

beta_¶: C++ double BasisFmllrAccus.beta_

dim_¶: C++ ::int32 BasisFmllrAccus.dim_

from_dim(dim:int) → BasisFmllrAccus¶: Calls C++ function std::unique_ptr<::kaldi::BasisFmllrAccus> ::kaldi::BasisFmllrAccus::BasisFmllrAccus(int)

grad_scatter_¶: C++ ::kaldi::SpMatrix< ::kaldi::BaseFloat> BasisFmllrAccus.grad_scatter_

read(is:istream, binary:bool, add:bool=default)¶: Calls C++ function void ::kaldi::BasisFmllrAccus::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

resize_accus(dim:int)¶: Calls C++ function void ::kaldi::BasisFmllrAccus::ResizeAccus(int)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::BasisFmllrAccus::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.mllr.BasisFmllrEstimate¶

CLIF wrapper for ::kaldi::BasisFmllrEstimate

basis_size() → int¶: Calls C++ function int ::kaldi::BasisFmllrEstimate::BasisSize()

compute_am_diag_precond(am_gmm:AmDiagGmm, pre_cond:DoubleSpMatrix)¶: Calls C++ function void ::kaldi::BasisFmllrEstimate::ComputeAmDiagPrecond(::kaldi::AmDiagGmm, ::kaldi::SpMatrix<double> *)

compute_transform(spk_stats:AffineXformStats, out_xform:Matrix, coefficients:Vector, options:BasisFmllrOptions) → float¶: Calls C++ function double ::kaldi::BasisFmllrEstimate::ComputeTransform(::kaldi::AffineXformStats, ::kaldi::Matrix<float> *, ::kaldi::Vector<float> *, ::kaldi::BasisFmllrOptions)

dim() → int¶: Calls C++ function int ::kaldi::BasisFmllrEstimate::Dim()

estimate_fmllr_basis(am_gmm:AmDiagGmm, basis_accus:BasisFmllrAccus)¶: Calls C++ function void ::kaldi::BasisFmllrEstimate::EstimateFmllrBasis(::kaldi::AmDiagGmm, ::kaldi::BasisFmllrAccus)

from_dim(dim:int) → BasisFmllrEstimate¶: Calls C++ function std::unique_ptr<::kaldi::BasisFmllrEstimate> ::kaldi::BasisFmllrEstimate::BasisFmllrEstimate(int)

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::BasisFmllrEstimate::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::BasisFmllrEstimate::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.mllr.BasisFmllrOptions¶

CLIF wrapper for ::kaldi::BasisFmllrOptions

min_count¶: C++ ::kaldi::BaseFloat BasisFmllrOptions.min_count

num_iters¶: C++ ::int32 BasisFmllrOptions.num_iters

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::BasisFmllrOptions::Register(::kaldi::OptionsItf *)

size_scale¶: C++ ::kaldi::BaseFloat BasisFmllrOptions.size_scale

step_size_iters¶: C++ ::int32 BasisFmllrOptions.step_size_iters

class kaldi.transform.mllr.DecodableAmDiagGmmRegtreeFmllr¶

CLIF wrapper for ::kaldi::DecodableAmDiagGmmRegtreeFmllr

is_last_frame(frame:int) → bool¶: Checks if given frame is the last frame.

log_likelihood(frame:int, index:int) → float¶: Returns the log-likehood of the given index for the given frame.

num_frames_ready() → int¶: Returns number of frames ready for decoding.

num_indices() → int¶: Returns number of indices.

class kaldi.transform.mllr.DecodableAmDiagGmmRegtreeMllr¶

CLIF wrapper for ::kaldi::DecodableAmDiagGmmRegtreeMllr

is_last_frame(frame:int) → bool¶: Checks if given frame is the last frame.

log_likelihood(frame:int, index:int) → float¶: Returns the log-likehood of the given index for the given frame.

num_frames_ready() → int¶: Returns number of frames ready for decoding.

num_indices() → int¶: Returns number of indices.

trans_model() → TransitionModel¶: Returns the transition model.

class kaldi.transform.mllr.FmllrDiagGmmAccs¶

CLIF wrapper for ::kaldi::FmllrDiagGmmAccs

G_¶: C++ ::std::vector< ::kaldi::SpMatrix<double> > AffineXformStats.G_

K_¶: C++ ::kaldi::Matrix<double> AffineXformStats.K_

accumulate_for_gmm(gmm:DiagGmm, data:VectorBase, weight:float) → float¶: Calls C++ function float ::kaldi::FmllrDiagGmmAccs::AccumulateForGmm(::kaldi::DiagGmm, ::kaldi::VectorBase<float>, float)

accumulate_for_gmm_preselect(gmm:DiagGmm, gselect:list<int>, data:VectorBase, weight:float) → float¶: Calls C++ function float ::kaldi::FmllrDiagGmmAccs::AccumulateForGmmPreselect(::kaldi::DiagGmm, ::std::vector< ::int32>, ::kaldi::VectorBase<float>, float)

accumulate_from_posteriors(gmm:DiagGmm, data:VectorBase, posteriors:VectorBase)¶: Calls C++ function void ::kaldi::FmllrDiagGmmAccs::AccumulateFromPosteriors(::kaldi::DiagGmm, ::kaldi::VectorBase<float>, ::kaldi::VectorBase<float>)

accumulate_from_posteriors_preselect(gmm:DiagGmm, gselect:list<int>, data:VectorBase, posteriors:VectorBase)¶: Calls C++ function void ::kaldi::FmllrDiagGmmAccs::AccumulateFromPosteriorsPreselect(::kaldi::DiagGmm, ::std::vector< ::int32>, ::kaldi::VectorBase<float>, ::kaldi::VectorBase<float>)

add(other:AffineXformStats)¶: Calls C++ function void ::kaldi::AffineXformStats::Add(::kaldi::AffineXformStats)

beta_¶: C++ double AffineXformStats.beta_

copy_stats(other:AffineXformStats)¶: Calls C++ function void ::kaldi::AffineXformStats::CopyStats(::kaldi::AffineXformStats)

dim() → int¶: Calls C++ function int ::kaldi::AffineXformStats::Dim()

dim_¶: C++ ::int32 AffineXformStats.dim_

from_dim(dim:int, opts:FmllrOptions=default) → FmllrDiagGmmAccs¶: Calls C++ function std::unique_ptr<::kaldi::FmllrDiagGmmAccs> ::kaldi::FmllrDiagGmmAccs::FmllrDiagGmmAccs(int, ::kaldi::FmllrOptions)

from_gmm(gmm:DiagGmm, fgmm_accs:AccumFullGmm) → FmllrDiagGmmAccs¶: Calls C++ function std::unique_ptr<::kaldi::FmllrDiagGmmAccs> ::kaldi::FmllrDiagGmmAccs::FmllrDiagGmmAccs(::kaldi::DiagGmm, ::kaldi::AccumFullGmm)

from_options(opts:FmllrOptions) → FmllrDiagGmmAccs¶: Calls C++ function std::unique_ptr<::kaldi::FmllrDiagGmmAccs> ::kaldi::FmllrDiagGmmAccs::FmllrDiagGmmAccs(::kaldi::FmllrOptions)

from_other(other:FmllrDiagGmmAccs) → FmllrDiagGmmAccs¶: Calls C++ function std::unique_ptr<::kaldi::FmllrDiagGmmAccs> ::kaldi::FmllrDiagGmmAccs::FmllrDiagGmmAccs(::kaldi::FmllrDiagGmmAccs)

init(dim:int)¶: Calls C++ function void ::kaldi::FmllrDiagGmmAccs::Init(unsigned long)

new(other:AffineXformStats) → AffineXformStats¶: Calls C++ function std::unique_ptr<::kaldi::AffineXformStats> ::kaldi::AffineXformStats::AffineXformStats(::kaldi::AffineXformStats)

read(is:istream, binary:bool, add:bool)¶: Calls C++ function void ::kaldi::AffineXformStats::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

set_zero()¶: Calls C++ function void ::kaldi::AffineXformStats::SetZero()

update(opts:FmllrOptions, fmllr_mat:MatrixBase) -> (objf_impr:float, count:float)¶: Calls C++ function void ::kaldi::FmllrDiagGmmAccs::Update(::kaldi::FmllrOptions, ::kaldi::MatrixBase<float> , float, float*)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::AffineXformStats::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.mllr.FmllrOptions¶

CLIF wrapper for ::kaldi::FmllrOptions

min_count¶: C++ ::kaldi::BaseFloat FmllrOptions.min_count

num_iters¶: C++ ::int32 FmllrOptions.num_iters

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::FmllrOptions::Register(::kaldi::OptionsItf *)

update_type¶: C++ ::std::string FmllrOptions.update_type

class kaldi.transform.mllr.FmllrRawAccs¶

CLIF wrapper for ::kaldi::FmllrRawAccs

accumulate_for_gmm(gmm:DiagGmm, data:VectorBase, weight:float) → float¶: Calls C++ function float ::kaldi::FmllrRawAccs::AccumulateForGmm(::kaldi::DiagGmm, ::kaldi::VectorBase<float>, float)

accumulate_from_posteriors(gmm:DiagGmm, data:VectorBase, posteriors:VectorBase)¶: Calls C++ function void ::kaldi::FmllrRawAccs::AccumulateFromPosteriors(::kaldi::DiagGmm, ::kaldi::VectorBase<float>, ::kaldi::VectorBase<float>)

full_dim() → int¶: Calls C++ function int ::kaldi::FmllrRawAccs::FullDim()

model_dim() → int¶: Calls C++ function int ::kaldi::FmllrRawAccs::ModelDim()

new(raw_dim:int, model_dim:int, full_transform:Matrix) → FmllrRawAccs¶: Calls C++ function std::unique_ptr<::kaldi::FmllrRawAccs> ::kaldi::FmllrRawAccs::FmllrRawAccs(int, int, ::kaldi::Matrix<float>)

raw_dim() → int¶: Calls C++ function int ::kaldi::FmllrRawAccs::RawDim()

set_zero()¶: Calls C++ function void ::kaldi::FmllrRawAccs::SetZero()

splice_width() → int¶: Calls C++ function int ::kaldi::FmllrRawAccs::SpliceWidth()

update(opts:FmllrRawOptions, raw_fmllr_mat:MatrixBase) -> (objf_impr:float, count:float)¶: Calls C++ function void ::kaldi::FmllrRawAccs::Update(::kaldi::FmllrRawOptions, ::kaldi::MatrixBase<float> , float, float*)

class kaldi.transform.mllr.FmllrRawOptions¶

CLIF wrapper for ::kaldi::FmllrRawOptions

min_count¶: C++ ::kaldi::BaseFloat FmllrRawOptions.min_count

num_iters¶: C++ ::int32 FmllrRawOptions.num_iters

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::FmllrRawOptions::Register(::kaldi::OptionsItf *)

class kaldi.transform.mllr.RegtreeFmllrDiagGmm¶

CLIF wrapper for ::kaldi::RegtreeFmllrDiagGmm

base_to_reg_class(bclass:int) → int¶: Calls C++ function int ::kaldi::RegtreeFmllrDiagGmm::Base2RegClass(int)

compute_log_dets()¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::ComputeLogDets()

dim() → int¶: Calls C++ function int ::kaldi::RegtreeFmllrDiagGmm::Dim()

get_log_dets(out:VectorBase)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::GetLogDets(::kaldi::VectorBase<float> *)

get_xform_matrix(xform_index:int) → Matrix¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::GetXformMatrix(int, ::kaldi::Matrix<float>*)

init(num_xforms:int, dim:int)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::Init(unsigned long, unsigned long)

new(other:RegtreeFmllrDiagGmm) → RegtreeFmllrDiagGmm¶: Calls C++ function std::unique_ptr<::kaldi::RegtreeFmllrDiagGmm> ::kaldi::RegtreeFmllrDiagGmm::RegtreeFmllrDiagGmm(::kaldi::RegtreeFmllrDiagGmm)

num_base_classes() → int¶: Calls C++ function int ::kaldi::RegtreeFmllrDiagGmm::NumBaseClasses()

num_reg_classes() → int¶: Calls C++ function int ::kaldi::RegtreeFmllrDiagGmm::NumRegClasses()

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

set_bclass2xforms(in:list<int>)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::set_bclass2xforms(::std::vector< ::int32>)

set_parameters(mat:MatrixBase, regclass:int)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::SetParameters(::kaldi::MatrixBase<float>, unsigned long)

set_unit()¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::SetUnit()

transform_feature(in:VectorBase) → list<Vector>¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::TransformFeature(::kaldi::VectorBase<float>, ::std::vector< ::kaldi::Vector< ::kaldi::BaseFloat> >*)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmm::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.mllr.RegtreeFmllrDiagGmmAccs¶

CLIF wrapper for ::kaldi::RegtreeFmllrDiagGmmAccs

accumulate_for_gaussian(regtree:RegressionTree, am:AmDiagGmm, data:VectorBase, pdf_index:int, gauss_index:int, weight:float)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmmAccs::AccumulateForGaussian(::kaldi::RegressionTree, ::kaldi::AmDiagGmm, ::kaldi::VectorBase<float>, unsigned long, unsigned long, float)

accumulate_for_gmm(regtree:RegressionTree, am:AmDiagGmm, data:VectorBase, pdf_index:int, weight:float) → float¶: Calls C++ function float ::kaldi::RegtreeFmllrDiagGmmAccs::AccumulateForGmm(::kaldi::RegressionTree, ::kaldi::AmDiagGmm, ::kaldi::VectorBase<float>, unsigned long, float)

baseclass_stats¶: C++ clif_type_57 RegtreeFmllrDiagGmmAccs.baseclass_stats()

dim() → int¶: Calls C++ function int ::kaldi::RegtreeFmllrDiagGmmAccs::Dim()

init(num_bclass:int, dim:int)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmmAccs::Init(unsigned long, unsigned long)

num_base_classes() → int¶: Calls C++ function int ::kaldi::RegtreeFmllrDiagGmmAccs::NumBaseClasses()

read(is:istream, binary:bool, add:bool)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmmAccs::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

set_zero()¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmmAccs::SetZero()

update(regtree:RegressionTree, opts:RegtreeFmllrOptions, out_mllr:RegtreeFmllrDiagGmm) -> (auxf_impr:float, t:float)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmmAccs::Update(::kaldi::RegressionTree, ::kaldi::RegtreeFmllrOptions, ::kaldi::RegtreeFmllrDiagGmm , float, float*)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::RegtreeFmllrDiagGmmAccs::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.mllr.RegtreeFmllrOptions¶

CLIF wrapper for ::kaldi::RegtreeFmllrOptions

min_count¶: C++ ::kaldi::BaseFloat RegtreeFmllrOptions.min_count

num_iters¶: C++ ::int32 RegtreeFmllrOptions.num_iters

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::RegtreeFmllrOptions::Register(::kaldi::OptionsItf *)

update_type¶: C++ ::std::string RegtreeFmllrOptions.update_type

use_regtree¶: C++ bool RegtreeFmllrOptions.use_regtree

class kaldi.transform.mllr.RegtreeMllrDiagGmm¶

CLIF wrapper for ::kaldi::RegtreeMllrDiagGmm

get_transformed_means(regtree:RegressionTree, am:AmDiagGmm, pdf_index:int, out:MatrixBase)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::GetTransformedMeans(::kaldi::RegressionTree, ::kaldi::AmDiagGmm, int, ::kaldi::MatrixBase<float> *)

init(num_xforms:int, dim:int)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::Init(int, int)

read(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool)

set_bclass2xforms(in:list<int>)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::set_bclass2xforms(::std::vector< ::int32>)

set_parameters(mat:MatrixBase, regclass:int)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::SetParameters(::kaldi::MatrixBase<float>, int)

set_unit()¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::SetUnit()

transform_model(regtree:RegressionTree, am:AmDiagGmm)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::TransformModel(::kaldi::RegressionTree, ::kaldi::AmDiagGmm *)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmm::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

xform_matrices¶: C++ clif_type_22 RegtreeMllrDiagGmm.xform_matrices()

class kaldi.transform.mllr.RegtreeMllrDiagGmmAccs¶

CLIF wrapper for ::kaldi::RegtreeMllrDiagGmmAccs

accumulate_for_gaussian(regtree:RegressionTree, am:AmDiagGmm, data:VectorBase, pdf_index:int, gauss_index:int, weight:float)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmmAccs::AccumulateForGaussian(::kaldi::RegressionTree, ::kaldi::AmDiagGmm, ::kaldi::VectorBase<float>, int, int, float)

accumulate_for_gmm(regtree:RegressionTree, am:AmDiagGmm, data:VectorBase, pdf_index:int, weight:float) → float¶: Calls C++ function float ::kaldi::RegtreeMllrDiagGmmAccs::AccumulateForGmm(::kaldi::RegressionTree, ::kaldi::AmDiagGmm, ::kaldi::VectorBase<float>, int, float)

baseclass_stats¶: C++ clif_type_53 RegtreeMllrDiagGmmAccs.baseclass_stats()

dim() → int¶: Calls C++ function int ::kaldi::RegtreeMllrDiagGmmAccs::Dim()

init(num_bclass:int, dim:int)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmmAccs::Init(int, int)

num_base_classes() → int¶: Calls C++ function int ::kaldi::RegtreeMllrDiagGmmAccs::NumBaseClasses()

read(is:istream, binary:bool, add:bool)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmmAccs::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

set_zero()¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmmAccs::SetZero()

update(regtree:RegressionTree, opts:RegtreeMllrOptions, out_mllr:RegtreeMllrDiagGmm) -> (auxf_impr:float, t:float)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmmAccs::Update(::kaldi::RegressionTree, ::kaldi::RegtreeMllrOptions, ::kaldi::RegtreeMllrDiagGmm , float, float*)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::RegtreeMllrDiagGmmAccs::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.transform.mllr.RegtreeMllrOptions¶

CLIF wrapper for ::kaldi::RegtreeMllrOptions

min_count¶: C++ ::kaldi::BaseFloat RegtreeMllrOptions.min_count

register(opts:OptionsItf)¶: Calls C++ function void ::kaldi::RegtreeMllrOptions::Register(::kaldi::OptionsItf *)

use_regtree¶: C++ bool RegtreeMllrOptions.use_regtree

kaldi.transform.mllr.apply_feature_transform_to_stats(xform:MatrixBase, stats:AffineXformStats)¶: Calls C++ function void ::kaldi::ApplyFeatureTransformToStats(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats *)

kaldi.transform.mllr.apply_model_transform_to_stats(xform:MatrixBase, stats:AffineXformStats)¶: Calls C++ function void ::kaldi::ApplyModelTransformToStats(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats *)

kaldi.transform.mllr.compute_fmllr_log_det(fmllr_mat:Matrix) → float¶: Calls C++ function float ::kaldi::ComputeFmllrLogDet(::kaldi::Matrix<float>)

kaldi.transform.mllr.compute_fmllr_matrix_diag_gmm(in_xform:MatrixBase, stats:AffineXformStats, fmllr_type:str, num_iters:int, out_xform:MatrixBase) → float¶: Calls C++ function float ::kaldi::ComputeFmllrMatrixDiagGmm(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats, ::std::string, int, ::kaldi::MatrixBase<float> *)

kaldi.transform.mllr.compute_fmllr_matrix_diag_gmm_diagonal(in_xform:MatrixBase, stats:AffineXformStats, out_xform:MatrixBase) → float¶: Calls C++ function float ::kaldi::ComputeFmllrMatrixDiagGmmDiagonal(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats, ::kaldi::MatrixBase<float> *)

kaldi.transform.mllr.compute_fmllr_matrix_diag_gmm_full(in_xform:MatrixBase, stats:AffineXformStats, num_iters:int, out_xform:MatrixBase) → float¶: Calls C++ function float ::kaldi::ComputeFmllrMatrixDiagGmmFull(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats, int, ::kaldi::MatrixBase<float> *)

kaldi.transform.mllr.compute_fmllr_matrix_diag_gmm_offset(in_xform:MatrixBase, stats:AffineXformStats, out_xform:MatrixBase) → float¶: Calls C++ function float ::kaldi::ComputeFmllrMatrixDiagGmmOffset(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats, ::kaldi::MatrixBase<float> *)

kaldi.transform.mllr.fmllr_aux_func_diag_gmm(xform:MatrixBase, stats:AffineXformStats) → float¶: Calls C++ function float ::kaldi::FmllrAuxFuncDiagGmm(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats)

kaldi.transform.mllr.fmllr_aux_func_diag_gmm_double(xform:DoubleMatrixBase, stats:AffineXformStats) → float¶: Calls C++ function double ::kaldi::FmllrAuxFuncDiagGmm(::kaldi::MatrixBase<double>, ::kaldi::AffineXformStats)

kaldi.transform.mllr.fmllr_auxf_gradient(xform:MatrixBase, stats:AffineXformStats, grad_out:MatrixBase) → float¶: Calls C++ function float ::kaldi::FmllrAuxfGradient(::kaldi::MatrixBase<float>, ::kaldi::AffineXformStats, ::kaldi::MatrixBase<float> *)

kaldi.transform.mllr.fmllr_inner_update(inv_G:DoubleSpMatrix, k:DoubleVectorBase, beta:float, row:int, transform:DoubleMatrixBase)¶: Calls C++ function void ::kaldi::FmllrInnerUpdate(::kaldi::SpMatrix<double>, ::kaldi::VectorBase<double>, double, int, ::kaldi::MatrixBase<double> *)

kaldi.transform.mllr.init_fmllr(dim:int) → Matrix¶: Calls C++ function void ::kaldi::InitFmllr(int, ::kaldi::Matrix<float>*)

kaldi.transform.mllt¶

Classes

MlltAccs CLIF wrapper for ::kaldi::MlltAccs

class kaldi.transform.mllt.MlltAccs¶

CLIF wrapper for ::kaldi::MlltAccs

G_¶: C++ ::std::vector< ::kaldi::SpMatrix<double> > MlltAccs.G_

accumulate_from_gmm(gmm:DiagGmm, data:VectorBase, weight:float) → float¶: Calls C++ function float ::kaldi::MlltAccs::AccumulateFromGmm(::kaldi::DiagGmm, ::kaldi::VectorBase<float>, float)

accumulate_from_gmm_preselect(gmm:DiagGmm, gselect:list<int>, data:VectorBase, weight:float) → float¶: Calls C++ function float ::kaldi::MlltAccs::AccumulateFromGmmPreselect(::kaldi::DiagGmm, ::std::vector< ::int32>, ::kaldi::VectorBase<float>, float)

accumulate_from_posteriors(gmm:DiagGmm, data:VectorBase, posteriors:VectorBase)¶: Calls C++ function void ::kaldi::MlltAccs::AccumulateFromPosteriors(::kaldi::DiagGmm, ::kaldi::VectorBase<float>, ::kaldi::VectorBase<float>)

beta_¶: C++ double MlltAccs.beta_

dim() → int¶: Calls C++ function int ::kaldi::MlltAccs::Dim()

init(dim:int, rand_prune:float=default)¶: Calls C++ function void ::kaldi::MlltAccs::Init(int, float)

new(dim:int, rand_prune:float=default) → MlltAccs¶: Calls C++ function std::unique_ptr<::kaldi::MlltAccs> ::kaldi::MlltAccs::MlltAccs(int, float)

rand_prune_¶: C++ ::kaldi::BaseFloat MlltAccs.rand_prune_

read(is:istream, binary:bool, add:bool=default)¶: Calls C++ function void ::kaldi::MlltAccs::Read(::std::basic_istream<char, ::std::char_traits<char> >, bool, bool)

update(M:MatrixBase) -> (objf_impr_out:float, count_out:float)¶: Calls C++ function void ::kaldi::MlltAccs::Update(::kaldi::MatrixBase<float> , float, float*)

update_static(beta:float, G:list<DoubleSpMatrix>, M:MatrixBase) -> (objf_impr_out:float, count_out:float)¶: Calls C++ function void ::kaldi::MlltAccs::Update(double, ::std::vector< ::kaldi::SpMatrix<double> >, ::kaldi::MatrixBase<float> , float, float*)

write(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::MlltAccs::Write(::std::basic_ostream<char, ::std::char_traits<char> >, bool)