kaldi.nnet3¶

Functions

`add_nnet`	Calls C++ function
`add_nnet_components`	Calls C++ function
`append_cindexes`	Calls C++ function
`append_input_frames`	Calls C++ function
`apply_l2_regularization`	Calls C++ function
`apply_scales_to_input`	Calls C++ function
`apply_scales_to_output`	Calls C++ function
`attention_backward`	Calls C++ function
`attention_forward`	Calls C++ function
`check_computation`	Calls C++ function
`check_model_and_io`	Calls C++ function
`collapse_model`	Calls C++ function
`compile_convolution_computation`	Calls C++ function
`compile_looped`	Calls C++ function
`component_dot_products`	Calls C++ function
`compute_command_attributes`	Calls C++ function
`compute_computation_phases`	Calls C++ function
`compute_example_computation_request_simple`	Calls C++ function
`compute_graph_transpose`	Calls C++ function
`compute_matrix_accesses`	Calls C++ function
`compute_matrix_to_submatrix`	Calls C++ function
`compute_nnet_computation_epochs`	Calls C++ function
`compute_objective_function`	Calls C++ function
`compute_simple_nnet_context`	Calls C++ function
`compute_top_sort_order`	Calls C++ function
`compute_variable_accesses`	Calls C++ function
`consolidate_io_operations`	Calls C++ function
`consolidate_memory`	Calls C++ function
`consolidate_model_update`	Calls C++ function
`constrain_orthonormal`	Calls C++ function
`convert_addition_to_assignment`	Calls C++ function
`convert_repeated_to_block_affine`	Calls C++ function
`convert_to_indexes`	Calls C++ function
`convolve_backward_data`	Calls C++ function
`convolve_backward_params`	Calls C++ function
`convolve_forward`	Calls C++ function
`create_looped_computation_request`	Calls C++ function
`create_looped_computation_request_simple`	Calls C++ function
`descriptor_tokenize`	Calls C++ function
`dot_product`	Calls C++ function
`ensure_contiguous_property`	Calls C++ function
`error_context`	Calls C++ function
`error_context_from_stream`	Calls C++ function
`evaluate_computation_request`	Calls C++ function
`example_approx_equal`	Calls C++ function
`expand_computation`	Calls C++ function
`extend_matrices`	Calls C++ function
`find_orphan_components`	Calls C++ function
`find_orphan_nodes`	Calls C++ function
`find_sccs`	Calls C++ function
`fix_goto_label`	Calls C++ function
`freeze_natural_gradient`	Calls C++ function
`generate_config_sequence`	Calls C++ function
`generate_config_sequence_composite_block`	Calls C++ function
`generate_random_simple_component`	Calls C++ function
`generate_simple_nnet_training_example`	Calls C++ function
`get_attention_dot_products`	Calls C++ function
`get_chain_computation_request`	Calls C++ function
`get_chunk_size`	Calls C++ function
`get_commands_of_type`	Calls C++ function
`get_computation_io`	Calls C++ function
`get_computation_request`	Calls C++ function
`get_indexes_for_computation`	Calls C++ function
`get_max_memory_use`	Calls C++ function
`get_nnet_example_size`	Calls C++ function
`get_num_n_values`	Calls C++ function
`get_nx_list`	Calls C++ function
`get_t_list`	Calls C++ function
`graph_has_cycles`	Calls C++ function
`has_batchnorm`	Calls C++ function
`has_contiguous_property`	Calls C++ function
`identify_submatrix_args`	Calls C++ function
`identify_submatrix_args_in_computation`	Calls C++ function
`is_simple_nnet`	Calls C++ function
`is_valid_name`	Calls C++ function
`limit_derivative_times`	Calls C++ function
`make_computation`	Calls C++ function
`make_scc_graph`	Calls C++ function
`matrix_is_unused`	Calls C++ function
`max_output_time_in_request`	Calls C++ function
`merge_chain_examples`	Calls C++ function
`merge_examples`	Calls C++ function
`modify_nnet_ivector_period`	Calls C++ function
`move_sizing_commands`	Calls C++ function
`nnet_info`	Calls C++ function
`nnet_is_recurrent`	Calls C++ function
`nnet_parameters_are_identical`	Calls C++ function
`nnet_to_directed_graph`	Calls C++ function
`num_input_nodes`	Calls C++ function
`num_output_nodes`	Calls C++ function
`num_parameters`	Calls C++ function
`num_updatable_components`	Calls C++ function
`optimize`	Calls C++ function
`optimize_looped_computation`	Calls C++ function
`optimize_memory_compression`	Calls C++ function
`pad_computation_input_time`	Calls C++ function
`pad_model_height`	Calls C++ function
`parse_config_lines`	Calls C++ function
`perturb_params`	Calls C++ function
`print_cindex`	Calls C++ function
`print_cindexes`	Calls C++ function
`print_command_attributes`	Calls C++ function
`print_graph_to_string`	Calls C++ function
`print_indexes`	Calls C++ function
`print_integer_vector`	Calls C++ function
`print_matrix_accesses`	Calls C++ function
`print_parameter_matrix_stats`	Calls C++ function
`print_parameter_vector_stats`	Calls C++ function
`print_vector_per_updatable_component`	Calls C++ function
`read_cindex_vector`	Calls C++ function
`read_config_lines`	Calls C++ function
`read_edit_config`	Calls C++ function
`read_index_vector`	Calls C++ function
`read_vector_as_char`	Calls C++ function
`recompute_stats`	Calls C++ function
`remove_commands_for_unused_matrix`	Calls C++ function
`remove_no_ops`	Calls C++ function
`remove_unnecessary_allocation`	Calls C++ function
`remove_unnecessary_zeroing`	Calls C++ function
`renumber_computation`	Calls C++ function
`replace_row_with_matrix_ops`	Calls C++ function
`request_is_decomposable`	Calls C++ function
`reset_generators`	Calls C++ function
`scale_batchnorm_stats`	Calls C++ function
`scale_nnet`	Calls C++ function
`set_batchnorm_test_mode`	Calls C++ function
`set_dropout_proportion`	Calls C++ function
`set_dropout_test_mode`	Calls C++ function
`set_learning_rate`	Calls C++ function
`set_nnet_as_gradient`	Calls C++ function
`shift_chain_example_times`	Calls C++ function
`snip_row_ops`	Calls C++ function
`split_locations`	Calls C++ function
`split_locations_backward`	Calls C++ function
`split_row_ops`	Calls C++ function
`summarize_cu_vector`	Calls C++ function
`summarize_double_vector`	Calls C++ function
`summarize_vector`	Calls C++ function
`un_pad_model_height`	Calls C++ function
`un_vectorize_nnet`	Calls C++ function
`update_nnet_with_max_change`	Calls C++ function
`variable_merging_optimization`	Calls C++ function
`vectorize_nnet`	Calls C++ function
`write_cindex_vector`	Calls C++ function
`write_index_vector`	Calls C++ function
`write_vector_as_char`	Calls C++ function
`zero_component_stats`	Calls C++ function

Classes

`Access`	CLIF wrapper for ::kaldi::nnet3::Access
`AccessType`	An enumeration.
`AffineComponent`	CLIF wrapper for ::kaldi::nnet3::AffineComponent
`AmNnetSimple`	CLIF wrapper for ::kaldi::nnet3::AmNnetSimple
`Analyzer`	CLIF wrapper for ::kaldi::nnet3::Analyzer
`BackpropTruncationComponent`	CLIF wrapper for ::kaldi::nnet3::BackpropTruncationComponent
`BackpropTruncationComponentPrecomputedIndexes`	CLIF wrapper for ::kaldi::nnet3::BackpropTruncationComponentPrecomputedIndexes
`BatchNormComponent`	CLIF wrapper for ::kaldi::nnet3::BatchNormComponent
`BinarySumDescriptor`	CLIF wrapper for ::kaldi::nnet3::BinarySumDescriptor
`BlockAffineComponent`	CLIF wrapper for ::kaldi::nnet3::BlockAffineComponent
`CachingOptimizingCompiler`	CLIF wrapper for ::kaldi::nnet3::CachingOptimizingCompiler
`CachingOptimizingCompilerOptions`	CLIF wrapper for ::kaldi::nnet3::CachingOptimizingCompilerOptions
`ChainExampleMerger`	CLIF wrapper for ::kaldi::nnet3::ChainExampleMerger
`ChainObjectiveInfo`	CLIF wrapper for ::kaldi::nnet3::ChainObjectiveInfo
`CheckComputationOptions`	CLIF wrapper for ::kaldi::nnet3::CheckComputationOptions
`ChunkTimeInfo`	CLIF wrapper for ::kaldi::nnet3::ChunkTimeInfo
`CindexSet`	CLIF wrapper for ::kaldi::nnet3::CindexSet
`ClipGradientComponent`	CLIF wrapper for ::kaldi::nnet3::ClipGradientComponent
`CollapseModelConfig`	CLIF wrapper for ::kaldi::nnet3::CollapseModelConfig
`CommandAttributes`	CLIF wrapper for ::kaldi::nnet3::CommandAttributes
`CommandType`	An enumeration.
`Compiler`	CLIF wrapper for ::kaldi::nnet3::Compiler
`CompilerOptions`	CLIF wrapper for ::kaldi::nnet3::CompilerOptions
`Component`	CLIF wrapper for ::kaldi::nnet3::Component
`ComponentPrecomputedIndexes`	CLIF wrapper for ::kaldi::nnet3::ComponentPrecomputedIndexes
`ComponentProperties`	An enumeration.
`CompositeComponent`	CLIF wrapper for ::kaldi::nnet3::CompositeComponent
`ComputationAnalysis`	CLIF wrapper for ::kaldi::nnet3::ComputationAnalysis
`ComputationChecker`	CLIF wrapper for ::kaldi::nnet3::ComputationChecker
`ComputationGraph`	CLIF wrapper for ::kaldi::nnet3::ComputationGraph
`ComputationGraphBuilder`	CLIF wrapper for ::kaldi::nnet3::ComputationGraphBuilder
`ComputationRequest`	CLIF wrapper for ::kaldi::nnet3::ComputationRequest
`ComputationVariables`	CLIF wrapper for ::kaldi::nnet3::ComputationVariables
`ConfigLine`	CLIF wrapper for ::kaldi::nnet3::ConfigLine
`ConstantComponent`	CLIF wrapper for ::kaldi::nnet3::ConstantComponent
`ConstantFunctionComponent`	CLIF wrapper for ::kaldi::nnet3::ConstantFunctionComponent
`ConstantSumDescriptor`	CLIF wrapper for ::kaldi::nnet3::ConstantSumDescriptor
`ConvolutionComputation`	CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputation
`ConvolutionComputationIo`	CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo
`ConvolutionComputationOptions`	CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputationOptions
`ConvolutionModel`	CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionModel
`DecodableAmNnetLoopedOnline`
`DecodableAmNnetSimple`	CLIF wrapper for ::kaldi::nnet3::DecodableAmNnetSimple
`DecodableAmNnetSimpleLooped`	CLIF wrapper for ::kaldi::nnet3::DecodableAmNnetSimpleLooped
`DecodableAmNnetSimpleParallel`	CLIF wrapper for ::kaldi::nnet3::DecodableAmNnetSimpleParallel
`DecodableNnetLoopedOnline`
`DecodableNnetSimple`	CLIF wrapper for ::kaldi::nnet3::DecodableNnetSimple
`DecodableNnetSimpleLooped`	CLIF wrapper for ::kaldi::nnet3::DecodableNnetSimpleLooped
`DecodableNnetSimpleLoopedInfo`	CLIF wrapper for ::kaldi::nnet3::DecodableNnetSimpleLoopedInfo
`DerivativeTimeLimiter`	CLIF wrapper for ::kaldi::nnet3::DerivativeTimeLimiter
`Descriptor`	CLIF wrapper for ::kaldi::nnet3::Descriptor
`DistributeComponent`	CLIF wrapper for ::kaldi::nnet3::DistributeComponent
`DistributeComponentPrecomputedIndexes`	CLIF wrapper for ::kaldi::nnet3::DistributeComponentPrecomputedIndexes
`DropoutComponent`	CLIF wrapper for ::kaldi::nnet3::DropoutComponent
`DropoutMaskComponent`	CLIF wrapper for ::kaldi::nnet3::DropoutMaskComponent
`ElementwiseProductComponent`	CLIF wrapper for ::kaldi::nnet3::ElementwiseProductComponent
`ExampleGenerationConfig`	CLIF wrapper for ::kaldi::nnet3::ExampleGenerationConfig
`ExampleMerger`	CLIF wrapper for ::kaldi::nnet3::ExampleMerger
`ExampleMergingConfig`	CLIF wrapper for ::kaldi::nnet3::ExampleMergingConfig
`ExampleMergingStats`	CLIF wrapper for ::kaldi::nnet3::ExampleMergingStats
`FixedAffineComponent`	CLIF wrapper for ::kaldi::nnet3::FixedAffineComponent
`FixedBiasComponent`	CLIF wrapper for ::kaldi::nnet3::FixedBiasComponent
`FixedScaleComponent`	CLIF wrapper for ::kaldi::nnet3::FixedScaleComponent
`ForwardingDescriptor`	CLIF wrapper for ::kaldi::nnet3::ForwardingDescriptor
`GeneralDescriptor`	CLIF wrapper for ::kaldi::nnet3::GeneralDescriptor
`GeneralDropoutComponent`	CLIF wrapper for ::kaldi::nnet3::GeneralDropoutComponent
`GeneralDropoutComponentPrecomputedIndexes`	CLIF wrapper for ::kaldi::nnet3::GeneralDropoutComponentPrecomputedIndexes
`GruNonlinearityComponent`	CLIF wrapper for ::kaldi::nnet3::GruNonlinearityComponent
`Index`	CLIF wrapper for ::kaldi::nnet3::Index
`IndexSet`	CLIF wrapper for ::kaldi::nnet3::IndexSet
`IoSpecification`	CLIF wrapper for ::kaldi::nnet3::IoSpecification
`LinearComponent`	CLIF wrapper for ::kaldi::nnet3::LinearComponent
`LogSoftmaxComponent`	CLIF wrapper for ::kaldi::nnet3::LogSoftmaxComponent
`LstmNonlinearityComponent`	CLIF wrapper for ::kaldi::nnet3::LstmNonlinearityComponent
`MatrixAccesses`	CLIF wrapper for ::kaldi::nnet3::MatrixAccesses
`MiscComputationInfo`	CLIF wrapper for ::kaldi::nnet3::MiscComputationInfo
`NaturalGradientAffineComponent`	CLIF wrapper for ::kaldi::nnet3::NaturalGradientAffineComponent
`NaturalGradientPerElementScaleComponent`	CLIF wrapper for ::kaldi::nnet3::NaturalGradientPerElementScaleComponent
`NaturalGradientRepeatedAffineComponent`	CLIF wrapper for ::kaldi::nnet3::NaturalGradientRepeatedAffineComponent
`NetworkNode`	CLIF wrapper for ::kaldi::nnet3::NetworkNode
`Nnet`	CLIF wrapper for ::kaldi::nnet3::Nnet
`NnetBatchComputer`	CLIF wrapper for ::kaldi::nnet3::NnetBatchComputer
`NnetBatchComputerOptions`	CLIF wrapper for ::kaldi::nnet3::NnetBatchComputerOptions
`NnetBatchDecoder`	CLIF wrapper for ::kaldi::nnet3::NnetBatchDecoder
`NnetBatchInference`	CLIF wrapper for ::kaldi::nnet3::NnetBatchInference
`NnetChainComputeProb`	CLIF wrapper for ::kaldi::nnet3::NnetChainComputeProb
`NnetChainExample`	CLIF wrapper for ::kaldi::nnet3::NnetChainExample
`NnetChainSupervision`	CLIF wrapper for ::kaldi::nnet3::NnetChainSupervision
`NnetChainTrainer`	CLIF wrapper for ::kaldi::nnet3::NnetChainTrainer
`NnetChainTrainingOptions`	CLIF wrapper for ::kaldi::nnet3::NnetChainTrainingOptions
`NnetComputation`	CLIF wrapper for ::kaldi::nnet3::NnetComputation
`NnetComputeOptions`	CLIF wrapper for ::kaldi::nnet3::NnetComputeOptions
`NnetComputeProb`	CLIF wrapper for ::kaldi::nnet3::NnetComputeProb
`NnetComputeProbOptions`	CLIF wrapper for ::kaldi::nnet3::NnetComputeProbOptions
`NnetComputer`	CLIF wrapper for ::kaldi::nnet3::NnetComputer
`NnetExample`	CLIF wrapper for ::kaldi::nnet3::NnetExample
`NnetGenerationOptions`	CLIF wrapper for ::kaldi::nnet3::NnetGenerationOptions
`NnetIo`	CLIF wrapper for ::kaldi::nnet3::NnetIo
`NnetOptimizeOptions`	CLIF wrapper for ::kaldi::nnet3::NnetOptimizeOptions
`NnetSimpleComputationOptions`	CLIF wrapper for ::kaldi::nnet3::NnetSimpleComputationOptions
`NnetSimpleLoopedComputationOptions`	CLIF wrapper for ::kaldi::nnet3::NnetSimpleLoopedComputationOptions
`NnetTrainer`	CLIF wrapper for ::kaldi::nnet3::NnetTrainer
`NnetTrainerOptions`	CLIF wrapper for ::kaldi::nnet3::NnetTrainerOptions
`NoOpComponent`	CLIF wrapper for ::kaldi::nnet3::NoOpComponent
`NodeType`	An enumeration.
`NonlinearComponent`	CLIF wrapper for ::kaldi::nnet3::NonlinearComponent
`NormalizeComponent`	CLIF wrapper for ::kaldi::nnet3::NormalizeComponent
`ObjectiveFunctionInfo`	CLIF wrapper for ::kaldi::nnet3::ObjectiveFunctionInfo
`ObjectiveType`	An enumeration.
`OffsetForwardingDescriptor`	CLIF wrapper for ::kaldi::nnet3::OffsetForwardingDescriptor
`OnlineNaturalGradient`	CLIF wrapper for ::kaldi::nnet3::OnlineNaturalGradient
`OptionalSumDescriptor`	CLIF wrapper for ::kaldi::nnet3::OptionalSumDescriptor
`OutputGruNonlinearityComponent`	CLIF wrapper for ::kaldi::nnet3::OutputGruNonlinearityComponent
`PerDimObjectiveInfo`	CLIF wrapper for ::kaldi::nnet3::PerDimObjectiveInfo
`PerElementOffsetComponent`	CLIF wrapper for ::kaldi::nnet3::PerElementOffsetComponent
`PerElementScaleComponent`	CLIF wrapper for ::kaldi::nnet3::PerElementScaleComponent
`PermuteComponent`	CLIF wrapper for ::kaldi::nnet3::PermuteComponent
`PnormComponent`	CLIF wrapper for ::kaldi::nnet3::PnormComponent
`RandomComponent`	CLIF wrapper for ::kaldi::nnet3::RandomComponent
`RectifiedLinearComponent`	CLIF wrapper for ::kaldi::nnet3::RectifiedLinearComponent
`RepeatedAffineComponent`	CLIF wrapper for ::kaldi::nnet3::RepeatedAffineComponent
`ReplaceIndexForwardingDescriptor`	CLIF wrapper for ::kaldi::nnet3::ReplaceIndexForwardingDescriptor
`RestrictedAttentionComponent`	CLIF wrapper for ::kaldi::nnet3::RestrictedAttentionComponent
`RoundingForwardingDescriptor`	CLIF wrapper for ::kaldi::nnet3::RoundingForwardingDescriptor
`ScaleAndOffsetComponent`	CLIF wrapper for ::kaldi::nnet3::ScaleAndOffsetComponent
`SigmoidComponent`	CLIF wrapper for ::kaldi::nnet3::SigmoidComponent
`SimpleForwardingDescriptor`	CLIF wrapper for ::kaldi::nnet3::SimpleForwardingDescriptor
`SimpleObjectiveInfo`	CLIF wrapper for ::kaldi::nnet3::SimpleObjectiveInfo
`SimpleSumDescriptor`	CLIF wrapper for ::kaldi::nnet3::SimpleSumDescriptor
`SoftmaxComponent`	CLIF wrapper for ::kaldi::nnet3::SoftmaxComponent
`StatisticsExtractionComponent`	CLIF wrapper for ::kaldi::nnet3::StatisticsExtractionComponent
`StatisticsExtractionComponentPrecomputedIndexes`	CLIF wrapper for ::kaldi::nnet3::StatisticsExtractionComponentPrecomputedIndexes
`StatisticsPoolingComponent`	CLIF wrapper for ::kaldi::nnet3::StatisticsPoolingComponent
`StatisticsPoolingComponentPrecomputedIndexes`	CLIF wrapper for ::kaldi::nnet3::StatisticsPoolingComponentPrecomputedIndexes
`SumBlockComponent`	CLIF wrapper for ::kaldi::nnet3::SumBlockComponent
`SumDescriptor`	CLIF wrapper for ::kaldi::nnet3::SumDescriptor
`SumGroupComponent`	CLIF wrapper for ::kaldi::nnet3::SumGroupComponent
`SwitchingForwardingDescriptor`	CLIF wrapper for ::kaldi::nnet3::SwitchingForwardingDescriptor
`TanhComponent`	CLIF wrapper for ::kaldi::nnet3::TanhComponent
`TdnnComponent`	CLIF wrapper for ::kaldi::nnet3::TdnnComponent
`TimeHeightConvolutionComponent`	CLIF wrapper for ::kaldi::nnet3::TimeHeightConvolutionComponent
`UpdatableComponent`	CLIF wrapper for ::kaldi::nnet3::UpdatableComponent
`UtteranceSplitter`	CLIF wrapper for ::kaldi::nnet3::UtteranceSplitter
`VariableMergingOptimizer`	CLIF wrapper for ::kaldi::nnet3::VariableMergingOptimizer

class kaldi.nnet3.Access¶

CLIF wrapper for ::kaldi::nnet3::Access

access_type¶: C++ ::kaldi::nnet3::AccessType Access.access_type

command_index¶: C++ ::int32 Access.command_index

new(command_index:int, access_type:AccessType) → Access¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::Access> ::kaldi::nnet3::Access::Access(int, ::kaldi::nnet3::AccessType)

class kaldi.nnet3.AccessType¶

An enumeration.

READ_ACCESS = 0¶

READ_WRITE_ACCESS = 2¶

WRITE_ACCESS = 1¶

class kaldi.nnet3.AffineComponent¶

CLIF wrapper for ::kaldi::nnet3::AffineComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

bias_params() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::AffineComponent::BiasParams()

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::AffineComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::AffineComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::FreezeNaturalGradient(bool)

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

from_params(linear_params:CuMatrixBase, bias_params:CuVectorBase, learning_rate:float) → AffineComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::AffineComponent> ::kaldi::nnet3::AffineComponent::AffineComponent(::kaldi::CuMatrixBase<float>, ::kaldi::CuVectorBase<float>, float)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::AffineComponent::Info()

init(input_dim:int, output_dim:int, param_stddev:float, bias_stddev:float)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Init(int, int, float, float)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

linear_params() → CuMatrix¶: Calls C++ function ::kaldi::CuMatrix<float> ::kaldi::nnet3::AffineComponent::LinearParams()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::NumParameters()

orthonormal_constraint() → float¶: Calls C++ function float ::kaldi::nnet3::AffineComponent::OrthonormalConstraint()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::AffineComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

resize(input_dim:int, output_dim:int)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Resize(int, int)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_params(bias:CuVectorBase, linear:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::SetParams(::kaldi::CuVectorBase<float>, ::kaldi::CuMatrixBase<float>)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::AffineComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.AmNnetSimple¶

CLIF wrapper for ::kaldi::nnet3::AmNnetSimple

from_nnet(nnet:Nnet) → AmNnetSimple¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::AmNnetSimple> ::kaldi::nnet3::AmNnetSimple::AmNnetSimple(::kaldi::nnet3::Nnet)

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

get_nnet() → Nnet¶: Calls C++ function ::kaldi::nnet3::Nnet * ::kaldi::nnet3::AmNnetSimple::GetNnetPtr()

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::AmNnetSimple::Info()

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::AmNnetSimple::InputDim()

ivector_dim() → int¶: Calls C++ function int ::kaldi::nnet3::AmNnetSimple::IvectorDim()

left_context() → int¶: Calls C++ function int ::kaldi::nnet3::AmNnetSimple::LeftContext()

num_pdfs() → int¶: Calls C++ function int ::kaldi::nnet3::AmNnetSimple::NumPdfs()

priors() → VectorBase¶: Calls C++ function ::kaldi::VectorBase<float> * ::kaldi::nnet3::AmNnetSimple::PriorsPtr()

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

right_context() → int¶: Calls C++ function int ::kaldi::nnet3::AmNnetSimple::RightContext()

set_context()¶: Calls C++ function void ::kaldi::nnet3::AmNnetSimple::SetContext()

set_nnet(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::AmNnetSimple::SetNnet(::kaldi::nnet3::Nnet)

set_priors(priors:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::AmNnetSimple::SetPriors(::kaldi::VectorBase<float>)

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

class kaldi.nnet3.Analyzer¶

CLIF wrapper for ::kaldi::nnet3::Analyzer

command_attributes¶: C++ ::std::vector< ::kaldi::nnet3::CommandAttributes> Analyzer.command_attributes

init(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::Analyzer::Init(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation)

matrix_accesses¶: C++ ::std::vector< ::kaldi::nnet3::MatrixAccesses> Analyzer.matrix_accesses

variable_accesses¶: C++ ::std::vector< ::std::vector< ::kaldi::nnet3::Access> > Analyzer.variable_accesses

variables¶: C++ ::kaldi::nnet3::ComputationVariables Analyzer.variables

class kaldi.nnet3.BackpropTruncationComponent¶

CLIF wrapper for ::kaldi::nnet3::BackpropTruncationComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::BackpropTruncationComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::BackpropTruncationComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::BackpropTruncationComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

from_args(dim:int, scale:float, clipping_threshold:float, zeroing_threshold:float, zeroing_interval:int, recurrence_interval:int) → BackpropTruncationComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::BackpropTruncationComponent> ::kaldi::nnet3::BackpropTruncationComponent::BackpropTruncationComponent(int, float, float, float, int, int)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BackpropTruncationComponent::Info()

init(dim:int, scale:float, clipping_threshold:float, zeroing_threshold:float, zeroing_interval:int, recurrence_interval:int)¶: Calls C++ function void ::kaldi::nnet3::BackpropTruncationComponent::Init(int, float, float, float, int, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::BackpropTruncationComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::BackpropTruncationComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::BackpropTruncationComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::BackpropTruncationComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::BackpropTruncationComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::BackpropTruncationComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::BackpropTruncationComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BackpropTruncationComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::BackpropTruncationComponent::ZeroStats()

class kaldi.nnet3.BackpropTruncationComponentPrecomputedIndexes¶

CLIF wrapper for ::kaldi::nnet3::BackpropTruncationComponentPrecomputedIndexes

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::BackpropTruncationComponentPrecomputedIndexes::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BackpropTruncationComponentPrecomputedIndexes::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

zeroing¶: C++ ::kaldi::CuVector< ::kaldi::BaseFloat> BackpropTruncationComponentPrecomputedIndexes.zeroing

zeroing_sum¶: C++ ::kaldi::BaseFloat BackpropTruncationComponentPrecomputedIndexes.zeroing_sum

class kaldi.nnet3.BatchNormComponent¶

CLIF wrapper for ::kaldi::nnet3::BatchNormComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::BatchNormComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

get_offset() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::BatchNormComponent::Offset()

get_scale() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::BatchNormComponent::Scale()

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BatchNormComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::BatchNormComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::BatchNormComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::BatchNormComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::BatchNormComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::Scale(float)

set_test_mode(test_mode:bool)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::SetTestMode(bool)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BatchNormComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::BatchNormComponent::ZeroStats()

class kaldi.nnet3.BinarySumDescriptor¶

CLIF wrapper for ::kaldi::nnet3::BinarySumDescriptor

Operation¶: alias of BinarySumDescriptor.Operation

copy() → SumDescriptor¶: Calls C++ function ::kaldi::nnet3::SumDescriptor * ::kaldi::nnet3::BinarySumDescriptor::Copy()

get_dependencies(ind:Index) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::BinarySumDescriptor::GetDependencies(::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Cindex>*)

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::BinarySumDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::BinarySumDescriptor::GetScaleForNode(int)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::BinarySumDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::BinarySumDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.BlockAffineComponent¶

CLIF wrapper for ::kaldi::nnet3::BlockAffineComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::BlockAffineComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::BlockAffineComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::FreezeNaturalGradient(bool)

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

from_rac(other:RepeatedAffineComponent) → BlockAffineComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::BlockAffineComponent> ::kaldi::nnet3::BlockAffineComponent::BlockAffineComponent(::kaldi::nnet3::RepeatedAffineComponent)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BlockAffineComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::BlockAffineComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::BlockAffineComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::BlockAffineComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::BlockAffineComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::BlockAffineComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::BlockAffineComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::BlockAffineComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.CachingOptimizingCompiler¶

CLIF wrapper for ::kaldi::nnet3::CachingOptimizingCompiler

compile(request:ComputationRequest) → NnetComputation¶: Calls C++ function const ::kaldi::nnet3::NnetComputation * ::kaldi::nnet3::CachingOptimizingCompiler::CompilePtr(::kaldi::nnet3::ComputationRequest)

get_simple_nnet_context() -> (nnet_left_context:int, nnet_right_context:int)¶: Calls C++ function void ::kaldi::nnet3::CachingOptimizingCompiler::GetSimpleNnetContext(int*, int*)

new_with_optimize_opts(nnet:Nnet, opt_config:NnetOptimizeOptions, config:CachingOptimizingCompilerOptions=default) → CachingOptimizingCompiler¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::CachingOptimizingCompiler> ::kaldi::nnet3::CachingOptimizingCompiler::CachingOptimizingCompiler(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetOptimizeOptions, ::kaldi::nnet3::CachingOptimizingCompilerOptions)

read_cache(is:istream, binary:bool)¶: Calls C++ function void ::kaldi::nnet3::CachingOptimizingCompiler::ReadCache(::std::basic_istream<char, ::std::char_traits<char> >, bool)

write_cache(os:ostream, binary:bool)¶: Calls C++ function void ::kaldi::nnet3::CachingOptimizingCompiler::WriteCache(::std::basic_ostream<char, ::std::char_traits<char> >, bool)

class kaldi.nnet3.CachingOptimizingCompilerOptions¶

CLIF wrapper for ::kaldi::nnet3::CachingOptimizingCompilerOptions

cache_capacity¶: C++ ::int32 CachingOptimizingCompilerOptions.cache_capacity

register(opt:OptionsItf)¶: Calls C++ function void ::kaldi::nnet3::CachingOptimizingCompilerOptions::Register(::kaldi::OptionsItf *)

use_shortcut¶: C++ bool CachingOptimizingCompilerOptions.use_shortcut

class kaldi.nnet3.ChainExampleMerger¶

CLIF wrapper for ::kaldi::nnet3::ChainExampleMerger

accept_example(a:NnetChainExample)¶: Calls C++ function void ::kaldi::nnet3::ChainExampleMerger::AcceptExample(::kaldi::nnet3::NnetChainExample *)

exit_status() → int¶: Calls C++ function int ::kaldi::nnet3::ChainExampleMerger::ExitStatus()

finish()¶: Calls C++ function void ::kaldi::nnet3::ChainExampleMerger::Finish()

class kaldi.nnet3.ChainObjectiveInfo¶

CLIF wrapper for ::kaldi::nnet3::ChainObjectiveInfo

tot_l2_term¶: C++ double ChainObjectiveInfo.tot_l2_term

tot_like¶: C++ double ChainObjectiveInfo.tot_like

tot_weight¶: C++ double ChainObjectiveInfo.tot_weight

class kaldi.nnet3.CheckComputationOptions¶

CLIF wrapper for ::kaldi::nnet3::CheckComputationOptions

check_rewrite¶: C++ bool CheckComputationOptions.check_rewrite

check_unused_variables¶: C++ bool CheckComputationOptions.check_unused_variables

class kaldi.nnet3.ChunkTimeInfo¶

CLIF wrapper for ::kaldi::nnet3::ChunkTimeInfo

first_frame¶: C++ ::int32 ChunkTimeInfo.first_frame

left_context¶: C++ ::int32 ChunkTimeInfo.left_context

num_frames¶: C++ ::int32 ChunkTimeInfo.num_frames

output_weights¶: C++ ::std::vector< ::kaldi::BaseFloat> ChunkTimeInfo.output_weights

right_context¶: C++ ::int32 ChunkTimeInfo.right_context

class kaldi.nnet3.CindexSet¶

CLIF wrapper for ::kaldi::nnet3::CindexSet

from_computable(graph:ComputationGraph, is_computable:list<int>, treat_unknown_as_computable:bool) → CindexSet¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::CindexSet> ::kaldi::nnet3::CindexSet::CindexSet(::kaldi::nnet3::ComputationGraph, ::std::vector<char>, bool)

class kaldi.nnet3.ClipGradientComponent¶

CLIF wrapper for ::kaldi::nnet3::ClipGradientComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::ClipGradientComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::ClipGradientComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::ClipGradientComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

from_args(dim:int, clipping_threshold:float, norm_based_clipping:bool, self_repair_clipped_proportion_threshold:float, self_repair_target:float, self_repair_scale:float, num_clipped:int, count:int, num_self_repaired:int, num_backpropped:int) → ClipGradientComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::ClipGradientComponent> ::kaldi::nnet3::ClipGradientComponent::ClipGradientComponent(int, float, bool, float, float, float, int, int, int, int)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ClipGradientComponent::Info()

init(dim:int, clipping_threshold:float, norm_based_clipping:bool, self_repair_clipped_proportion_threshold:float, self_repair_target:float, self_repair_scale:float, num_clipped:int, count:int, num_self_repaired:int, num_backpropped:int)¶: Calls C++ function void ::kaldi::nnet3::ClipGradientComponent::Init(int, float, bool, float, float, float, int, int, int, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::ClipGradientComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ClipGradientComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ClipGradientComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::ClipGradientComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::ClipGradientComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::ClipGradientComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ClipGradientComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::ClipGradientComponent::ZeroStats()

class kaldi.nnet3.CollapseModelConfig¶

CLIF wrapper for ::kaldi::nnet3::CollapseModelConfig

collapse_affine¶: C++ bool CollapseModelConfig.collapse_affine

collapse_batchnorm¶: C++ bool CollapseModelConfig.collapse_batchnorm

collapse_dropout¶: C++ bool CollapseModelConfig.collapse_dropout

collapse_scale¶: C++ bool CollapseModelConfig.collapse_scale

class kaldi.nnet3.CommandAttributes¶

CLIF wrapper for ::kaldi::nnet3::CommandAttributes

has_side_effects¶: C++ bool CommandAttributes.has_side_effects

matrices_read¶: C++ ::std::vector< ::int32> CommandAttributes.matrices_read

matrices_written¶: C++ ::std::vector< ::int32> CommandAttributes.matrices_written

submatrices_read¶: C++ ::std::vector< ::int32> CommandAttributes.submatrices_read

submatrices_written¶: C++ ::std::vector< ::int32> CommandAttributes.submatrices_written

variables_read¶: C++ ::std::vector< ::int32> CommandAttributes.variables_read

variables_written¶: C++ ::std::vector< ::int32> CommandAttributes.variables_written

class kaldi.nnet3.CommandType¶

An enumeration.

ACCEPT_INPUT = 18¶

ADD_ROWS = 10¶

ADD_ROWS_MULTI = 13¶

ADD_ROW_RANGES = 15¶

ADD_TO_ROWS_MULTI = 14¶

ALLOC_MATRIX = 0¶

BACKPROP = 5¶

BACKPROP_NO_MODEL_UPDATE = 6¶

COMPRESS_MATRIX = 16¶

COPY_ROWS = 9¶

COPY_ROWS_MULTI = 11¶

COPY_TO_ROWS_MULTI = 12¶

DEALLOC_MATRIX = 1¶

DECOMPRESS_MATRIX = 17¶

GOTO_LABEL = 24¶

MATRIX_ADD = 8¶

MATRIX_COPY = 7¶

NO_OPERATION = 20¶

NO_OPERATION_LABEL = 23¶

NO_OPERATION_MARKER = 22¶

NO_OPERATION_PERMANENT = 21¶

PROPAGATE = 4¶

PROVIDE_OUTPUT = 19¶

SET_CONST = 3¶

SWAP_MATRIX = 2¶

class kaldi.nnet3.Compiler¶

CLIF wrapper for ::kaldi::nnet3::Compiler

create_computation(opts:CompilerOptions) → NnetComputation¶: Calls C++ function void ::kaldi::nnet3::Compiler::CreateComputation(::kaldi::nnet3::CompilerOptions, ::kaldi::nnet3::NnetComputation*)

class kaldi.nnet3.CompilerOptions¶

CLIF wrapper for ::kaldi::nnet3::CompilerOptions

output_debug_info¶: C++ bool CompilerOptions.output_debug_info

class kaldi.nnet3.Component¶

CLIF wrapper for ::kaldi::nnet3::Component

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ComponentPrecomputedIndexes¶

CLIF wrapper for ::kaldi::nnet3::ComponentPrecomputedIndexes

new_component_precomputed_indexes_of_type(cpi_type:str) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::ComponentPrecomputedIndexes::NewComponentPrecomputedIndexesOfType(::std::string)

read_new(is:istream, binary:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::ComponentPrecomputedIndexes::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

class kaldi.nnet3.ComponentProperties¶

An enumeration.

BACKPROP_ADDS = 32¶

BACKPROP_IN_PLACE = 256¶

BACKPROP_NEEDS_INPUT = 64¶

BACKPROP_NEEDS_OUTPUT = 128¶

INPUT_CONTIGUOUS = 1024¶

OUTPUT_CONTIGUOUS = 2048¶

PROPAGATE_ADDS = 8¶

PROPAGATE_IN_PLACE = 4¶

RANDOM_COMPONENT = 8192¶

REORDERS_INDEXES = 16¶

SIMPLE_COMPONENT = 1¶

STORES_STATS = 512¶

UPDATABLE_COMPONENT = 2¶

USES_MEMO = 4096¶

class kaldi.nnet3.CompositeComponent¶

CLIF wrapper for ::kaldi::nnet3::CompositeComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::CompositeComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::FreezeNaturalGradient(bool)

get_component(i:int) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::CompositeComponent::GetComponent(int)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::CompositeComponent::Info()

init(components:list<Component>, max_rows_process:int)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::Init(::std::vector< ::kaldi::nnet3::Component *>, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::CompositeComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_components() → int¶: Calls C++ function int ::kaldi::nnet3::CompositeComponent::NumComponents()

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::CompositeComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::CompositeComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::CompositeComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::CompositeComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::SetAsGradient()

set_component(i:int, component:Component)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::SetComponent(int, ::kaldi::nnet3::Component *)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::SetUnderlyingLearningRate(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::CompositeComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::CompositeComponent::ZeroStats()

class kaldi.nnet3.ComputationAnalysis¶

CLIF wrapper for ::kaldi::nnet3::ComputationAnalysis

data_invalidated_command(c:int, s:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::DataInvalidatedCommand(int, int)

first_access(s:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::FirstAccess(int)

first_nontrivial_access(s:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::FirstNontrivialAccess(int)

first_nontrivial_matrix_access(m:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::FirstNontrivialMatrixAccess(int)

last_access(s:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::LastAccess(int)

last_matrix_access(m:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::LastMatrixAccess(int)

last_write_access(s:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationAnalysis::LastWriteAccess(int)

class kaldi.nnet3.ComputationChecker¶

CLIF wrapper for ::kaldi::nnet3::ComputationChecker

check()¶: Calls C++ function void ::kaldi::nnet3::ComputationChecker::Check()

class kaldi.nnet3.ComputationGraph¶

CLIF wrapper for ::kaldi::nnet3::ComputationGraph

cindexes¶: C++ ::std::vector< ::kaldi::nnet3::Cindex> ComputationGraph.cindexes

dependencies¶: C++ ::std::vector< ::std::vector< ::int32> > ComputationGraph.dependencies

get_cindex_id(cindex:tuple<int, Index>) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationGraph::GetCindexId(::kaldi::nnet3::Cindex)

get_cindex_id_or_add(cindex:tuple<int, Index>, is_input:bool) -> (id:int, is_new:bool)¶: Calls C++ function int ::kaldi::nnet3::ComputationGraph::GetCindexId(::kaldi::nnet3::Cindex, bool, bool*)

is_input¶: C++ ::std::vector<bool> ComputationGraph.is_input

print_graph(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::ComputationGraph::Print(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

renumber(start_cindex_id:int, keep:list<bool>)¶: Calls C++ function void ::kaldi::nnet3::ComputationGraph::Renumber(int, ::std::vector<bool>)

segment_ends¶: C++ ::std::vector< ::int32> ComputationGraph.segment_ends

class kaldi.nnet3.ComputationGraphBuilder¶

CLIF wrapper for ::kaldi::nnet3::ComputationGraphBuilder

ComputableInfo¶: alias of ComputationGraphBuilder.ComputableInfo

all_outputs_are_computable() → bool¶: Calls C++ function bool ::kaldi::nnet3::ComputationGraphBuilder::AllOutputsAreComputable()

compute(request:ComputationRequest)¶: Calls C++ function void ::kaldi::nnet3::ComputationGraphBuilder::Compute(::kaldi::nnet3::ComputationRequest)

explain_why_all_outputs_not_computable()¶: Calls C++ function void ::kaldi::nnet3::ComputationGraphBuilder::ExplainWhyAllOutputsNotComputable()

get_computable_info() → list<list<bool>>¶: Calls C++ function void ::kaldi::nnet3::ComputationGraphBuilder::GetComputableInfo(::std::vector< ::std::vector<bool> >*)

prune()¶: Calls C++ function void ::kaldi::nnet3::ComputationGraphBuilder::Prune()

class kaldi.nnet3.ComputationRequest¶

CLIF wrapper for ::kaldi::nnet3::ComputationRequest

index_for_input(node_name:str) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationRequest::IndexForInput(::std::string)

index_for_output(node_name:str) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationRequest::IndexForOutput(::std::string)

inputs¶: C++ ::std::vector< ::kaldi::nnet3::IoSpecification> ComputationRequest.inputs

misc_info¶: C++ ::kaldi::nnet3::MiscComputationInfo ComputationRequest.misc_info

need_derivatives() → bool¶: Calls C++ function bool ::kaldi::nnet3::ComputationRequest::NeedDerivatives()

need_model_derivative¶: C++ bool ComputationRequest.need_model_derivative

outputs¶: C++ ::std::vector< ::kaldi::nnet3::IoSpecification> ComputationRequest.outputs

print_request(os:ostream)¶: Calls C++ function void ::kaldi::nnet3::ComputationRequest::Print(::std::basic_ostream<char, ::std::char_traits<char> >)

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

store_component_stats¶: C++ bool ComputationRequest.store_component_stats

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

class kaldi.nnet3.ComputationVariables¶

CLIF wrapper for ::kaldi::nnet3::ComputationVariables

append_variables_for_matrix(matrix_index:int) → list<int>¶: Calls C++ function void ::kaldi::nnet3::ComputationVariables::AppendVariablesForMatrix(int, ::std::vector< ::int32>*)

append_variables_for_submatrix(submatrix_index:int) → list<int>¶: Calls C++ function void ::kaldi::nnet3::ComputationVariables::AppendVariablesForSubmatrix(int, ::std::vector< ::int32>*)

describe_variable(variable:int) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ComputationVariables::DescribeVariable(int)

get_matrix_for_variable(variable:int) → int¶: Calls C++ function int ::kaldi::nnet3::ComputationVariables::GetMatrixForVariable(int)

init(computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::ComputationVariables::Init(::kaldi::nnet3::NnetComputation)

num_variables() → int¶: Calls C++ function int ::kaldi::nnet3::ComputationVariables::NumVariables()

record_access_for_submatrix(submatrix_index:int, access_type:AccessType, ca:CommandAttributes)¶: Calls C++ function void ::kaldi::nnet3::ComputationVariables::RecordAccessForSubmatrix(int, ::kaldi::nnet3::AccessType, ::kaldi::nnet3::CommandAttributes *)

variable_info(variable:int) → NnetComputation.SubMatrixInfo¶: Calls C++ function ::kaldi::nnet3::NnetComputation::SubMatrixInfo ::kaldi::nnet3::ComputationVariables::VariableInfo(int)

class kaldi.nnet3.ConfigLine¶

CLIF wrapper for ::kaldi::nnet3::ConfigLine

first_token() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConfigLine::FirstToken()

get_bool(key:str) -> (suc:bool, value:bool)¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::GetValue(::std::string, bool*)

get_float(key:str) -> (suc:bool, value:float)¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::GetValue(::std::string, float*)

get_int(key:str) -> (suc:bool, value:int)¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::GetValue(::std::string, int*)

get_intlist(key:str) -> (suc:bool, value:list<int>)¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::GetValue(::std::string, ::std::vector< ::int32>*)

get_str(key:str) -> (suc:bool, value:str)¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::GetValue(::std::string, ::std::string*)

has_unused_values() → bool¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::HasUnusedValues()

parse_line(line:str) → bool¶: Calls C++ function bool ::kaldi::nnet3::ConfigLine::ParseLine(::std::string)

unused_values() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConfigLine::UnusedValues()

whole_line() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConfigLine::WholeLine()

class kaldi.nnet3.ConstantComponent¶

CLIF wrapper for ::kaldi::nnet3::ConstantComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::ConstantComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::ConstantComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConstantComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::ConstantComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::ConstantComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConstantComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ConstantComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ConstantFunctionComponent¶

CLIF wrapper for ::kaldi::nnet3::ConstantFunctionComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::ConstantFunctionComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::ConstantFunctionComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConstantFunctionComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantFunctionComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantFunctionComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantFunctionComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::ConstantFunctionComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantFunctionComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ConstantFunctionComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ConstantFunctionComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ConstantSumDescriptor¶

CLIF wrapper for ::kaldi::nnet3::ConstantSumDescriptor

copy() → SumDescriptor¶: Calls C++ function ::kaldi::nnet3::SumDescriptor * ::kaldi::nnet3::ConstantSumDescriptor::Copy()

get_dependencies(ind:Index) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::ConstantSumDescriptor::GetDependencies(::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Cindex>*)

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::ConstantSumDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::ConstantSumDescriptor::GetScaleForNode(int)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::ConstantSumDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::ConstantSumDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.ConvolutionComputation¶

CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputation

class ConvolutionStep¶

CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputation::ConvolutionStep

backward_columns¶: C++ ::std::vector< ::kaldi::CuArray< ::int32> > ConvolutionComputation::ConvolutionStep.backward_columns

columns¶: C++ ::kaldi::CuArray< ::int32> ConvolutionComputation::ConvolutionStep.columns

columns_are_contiguous¶: C++ bool ConvolutionComputation::ConvolutionStep.columns_are_contiguous

first_column¶: C++ ::int32 ConvolutionComputation::ConvolutionStep.first_column

height_map¶: C++ ::std::vector< ::int32> ConvolutionComputation::ConvolutionStep.height_map

input_time_shift¶: C++ ::int32 ConvolutionComputation::ConvolutionStep.input_time_shift

params_start_col¶: C++ ::int32 ConvolutionComputation::ConvolutionStep.params_start_col

check()¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::ConvolutionComputation::Check()

compute_derived()¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::ConvolutionComputation::ComputeDerived()

height_in¶: C++ ::int32 ConvolutionComputation.height_in

height_out¶: C++ ::int32 ConvolutionComputation.height_out

num_filters_in¶: C++ ::int32 ConvolutionComputation.num_filters_in

num_filters_out¶: C++ ::int32 ConvolutionComputation.num_filters_out

num_images¶: C++ ::int32 ConvolutionComputation.num_images

num_t_in¶: C++ ::int32 ConvolutionComputation.num_t_in

num_t_out¶: C++ ::int32 ConvolutionComputation.num_t_out

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

steps¶: C++ ::std::vector< ::kaldi::nnet3::time_height_convolution::ConvolutionComputation::ConvolutionStep> ConvolutionComputation.steps

temp_cols¶: C++ ::int32 ConvolutionComputation.temp_cols

temp_rows¶: C++ ::int32 ConvolutionComputation.temp_rows

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

class kaldi.nnet3.ConvolutionComputationIo¶

CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo

num_images¶: C++ ::int32 ConvolutionComputationIo.num_images

num_t_in¶: C++ ::int32 ConvolutionComputationIo.num_t_in

num_t_out¶: C++ ::int32 ConvolutionComputationIo.num_t_out

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

reorder_t_in¶: C++ ::int32 ConvolutionComputationIo.reorder_t_in

start_t_in¶: C++ ::int32 ConvolutionComputationIo.start_t_in

start_t_out¶: C++ ::int32 ConvolutionComputationIo.start_t_out

t_step_in¶: C++ ::int32 ConvolutionComputationIo.t_step_in

t_step_out¶: C++ ::int32 ConvolutionComputationIo.t_step_out

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

class kaldi.nnet3.ConvolutionComputationOptions¶

CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionComputationOptions

max_memory_mb¶: C++ ::kaldi::BaseFloat ConvolutionComputationOptions.max_memory_mb

class kaldi.nnet3.ConvolutionModel¶

CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionModel

class Offset¶

CLIF wrapper for ::kaldi::nnet3::time_height_convolution::ConvolutionModel::Offset

height_offset¶: C++ ::int32 ConvolutionModel::Offset.height_offset

time_offset¶: C++ ::int32 ConvolutionModel::Offset.time_offset

all_time_offsets¶: C++ ::std::set< ::int32> ConvolutionModel.all_time_offsets

check(check_heights_used:bool=default, allow_height_padding:bool=default) → bool¶: Calls C++ function bool ::kaldi::nnet3::time_height_convolution::ConvolutionModel::Check(bool, bool)

compute_derived()¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::ConvolutionModel::ComputeDerived()

height_in¶: C++ ::int32 ConvolutionModel.height_in

height_out¶: C++ ::int32 ConvolutionModel.height_out

height_subsample_out¶: C++ ::int32 ConvolutionModel.height_subsample_out

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::time_height_convolution::ConvolutionModel::Info()

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::time_height_convolution::ConvolutionModel::InputDim()

num_filters_in¶: C++ ::int32 ConvolutionModel.num_filters_in

num_filters_out¶: C++ ::int32 ConvolutionModel.num_filters_out

offsets¶: C++ ::std::vector< ::kaldi::nnet3::time_height_convolution::ConvolutionModel::Offset> ConvolutionModel.offsets

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::time_height_convolution::ConvolutionModel::OutputDim()

param_cols() → int¶: Calls C++ function int ::kaldi::nnet3::time_height_convolution::ConvolutionModel::ParamCols()

param_rows() → int¶: Calls C++ function int ::kaldi::nnet3::time_height_convolution::ConvolutionModel::ParamRows()

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

required_time_offsets¶: C++ ::std::set< ::int32> ConvolutionModel.required_time_offsets

time_offsets_modulus¶: C++ ::int32 ConvolutionModel.time_offsets_modulus

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

class kaldi.nnet3.DecodableAmNnetLoopedOnline¶

frame_subsampling_factor() → int¶: Returns the frame subsampling factor.

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.nnet3.DecodableAmNnetSimple¶

CLIF wrapper for ::kaldi::nnet3::DecodableAmNnetSimple

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.nnet3.DecodableAmNnetSimpleLooped¶

CLIF wrapper for ::kaldi::nnet3::DecodableAmNnetSimpleLooped

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.nnet3.DecodableAmNnetSimpleParallel¶

CLIF wrapper for ::kaldi::nnet3::DecodableAmNnetSimpleParallel

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.nnet3.DecodableNnetLoopedOnline¶

frame_subsampling_factor() → int¶: Returns the frame subsampling factor.

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.nnet3.DecodableNnetSimple¶

CLIF wrapper for ::kaldi::nnet3::DecodableNnetSimple

get_output(subsampled_frame:int, pdf_id:int) → float¶: Calls C++ function float ::kaldi::nnet3::DecodableNnetSimple::GetOutput(int, int)

get_output_for_frame(frame:int, output:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::DecodableNnetSimple::GetOutputForFrame(int, ::kaldi::VectorBase<float> *)

num_frames() → int¶: Calls C++ function int ::kaldi::nnet3::DecodableNnetSimple::NumFrames()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DecodableNnetSimple::OutputDim()

class kaldi.nnet3.DecodableNnetSimpleLooped¶

CLIF wrapper for ::kaldi::nnet3::DecodableNnetSimpleLooped

get_output(subsampled_frame:int, pdf_id:int) → float¶: Calls C++ function float ::kaldi::nnet3::DecodableNnetSimpleLooped::GetOutput(int, int)

get_output_for_frame(frame:int, output:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::DecodableNnetSimpleLooped::GetOutputForFrame(int, ::kaldi::VectorBase<float> *)

num_frames() → int¶: Calls C++ function int ::kaldi::nnet3::DecodableNnetSimpleLooped::NumFrames()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DecodableNnetSimpleLooped::OutputDim()

class kaldi.nnet3.DecodableNnetSimpleLoopedInfo¶

CLIF wrapper for ::kaldi::nnet3::DecodableNnetSimpleLoopedInfo

computation¶: C++ ::kaldi::nnet3::NnetComputation DecodableNnetSimpleLoopedInfo.computation

frames_left_context¶: C++ ::int32 DecodableNnetSimpleLoopedInfo.frames_left_context

frames_per_chunk¶: C++ ::int32 DecodableNnetSimpleLoopedInfo.frames_per_chunk

frames_right_context¶: C++ ::int32 DecodableNnetSimpleLoopedInfo.frames_right_context

from_am(opts:NnetSimpleLoopedComputationOptions, nnet:AmNnetSimple) → DecodableNnetSimpleLoopedInfo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::DecodableNnetSimpleLoopedInfo> ::kaldi::nnet3::DecodableNnetSimpleLoopedInfo::DecodableNnetSimpleLoopedInfo(::kaldi::nnet3::NnetSimpleLoopedComputationOptions, ::kaldi::nnet3::AmNnetSimple *)

from_priors(opts:NnetSimpleLoopedComputationOptions, priors:Vector, nnet:Nnet) → DecodableNnetSimpleLoopedInfo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::DecodableNnetSimpleLoopedInfo> ::kaldi::nnet3::DecodableNnetSimpleLoopedInfo::DecodableNnetSimpleLoopedInfo(::kaldi::nnet3::NnetSimpleLoopedComputationOptions, ::kaldi::Vector<float>, ::kaldi::nnet3::Nnet *)

has_ivectors¶: C++ bool DecodableNnetSimpleLoopedInfo.has_ivectors

init(opts:NnetSimpleLoopedComputationOptions, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::DecodableNnetSimpleLoopedInfo::Init(::kaldi::nnet3::NnetSimpleLoopedComputationOptions, ::kaldi::nnet3::Nnet *)

log_priors¶: C++ ::kaldi::CuVector< ::kaldi::BaseFloat> DecodableNnetSimpleLoopedInfo.log_priors

output_dim¶: C++ ::int32 DecodableNnetSimpleLoopedInfo.output_dim

request1¶: C++ ::kaldi::nnet3::ComputationRequest DecodableNnetSimpleLoopedInfo.request1

request2¶: C++ ::kaldi::nnet3::ComputationRequest DecodableNnetSimpleLoopedInfo.request2

request3¶: C++ ::kaldi::nnet3::ComputationRequest DecodableNnetSimpleLoopedInfo.request3

class kaldi.nnet3.DerivativeTimeLimiter¶

CLIF wrapper for ::kaldi::nnet3::DerivativeTimeLimiter

limit_deriv_times()¶: Calls C++ function void ::kaldi::nnet3::DerivativeTimeLimiter::LimitDerivTimes()

class kaldi.nnet3.Descriptor¶

CLIF wrapper for ::kaldi::nnet3::Descriptor

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

from_parts(parts:list<SumDescriptor>) → Descriptor¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::Descriptor> ::kaldi::nnet3::Descriptor::Descriptor(::std::vector< ::kaldi::nnet3::SumDescriptor *>)

get_dependencies(index:Index) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::Descriptor::GetDependencies(::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Cindex>*)

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::Descriptor::GetNodeDependencies(::std::vector< ::int32>*)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::Descriptor::Modulus()

num_parts() → int¶: Calls C++ function int ::kaldi::nnet3::Descriptor::NumParts()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::Descriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.DistributeComponent¶

CLIF wrapper for ::kaldi::nnet3::DistributeComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::DistributeComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::DistributeComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

from_dims(input_dim:int, output_dim:int) → DistributeComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::DistributeComponent> ::kaldi::nnet3::DistributeComponent::DistributeComponent(int, int)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::DistributeComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

init(input_dim:int, output_dim:int)¶: Calls C++ function void ::kaldi::nnet3::DistributeComponent::Init(int, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::DistributeComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DistributeComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::DistributeComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DistributeComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::DistributeComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::DistributeComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::DistributeComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::DistributeComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.DistributeComponentPrecomputedIndexes¶

CLIF wrapper for ::kaldi::nnet3::DistributeComponentPrecomputedIndexes

copy() → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::DistributeComponentPrecomputedIndexes::Copy()

new_component_precomputed_indexes_of_type(cpi_type:str) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::ComponentPrecomputedIndexes::NewComponentPrecomputedIndexesOfType(::std::string)

pairs¶: C++ ::std::vector< ::std::pair< ::int32, ::int32> > DistributeComponentPrecomputedIndexes.pairs

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

read_new(is:istream, binary:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::ComponentPrecomputedIndexes::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::DistributeComponentPrecomputedIndexes::Type()

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

class kaldi.nnet3.DropoutComponent¶

CLIF wrapper for ::kaldi::nnet3::DropoutComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::DropoutComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::DropoutComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dropout_proportion() → float¶: Calls C++ function float ::kaldi::nnet3::DropoutComponent::DropoutProportion()

from_args(dim:int, dropout_proportion:float=default, dropout_per_frame:bool=default) → DropoutComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::DropoutComponent> ::kaldi::nnet3::DropoutComponent::DropoutComponent(int, float, bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::DropoutComponent::Info()

init(dim:int, dropout_proportion:float=default, dropout_per_frame:bool=default)¶: Calls C++ function void ::kaldi::nnet3::DropoutComponent::Init(int, float, bool)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::DropoutComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DropoutComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DropoutComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::DropoutComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::DropoutComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

reset_generator()¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::ResetGenerator()

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

set_dropout_proportion(dropout_proportion:float)¶: Calls C++ function void ::kaldi::nnet3::DropoutComponent::SetDropoutProportion(float)

set_test_mode(test_mode:bool)¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::SetTestMode(bool)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::DropoutComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.DropoutMaskComponent¶

CLIF wrapper for ::kaldi::nnet3::DropoutMaskComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::DropoutMaskComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::DropoutMaskComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::DropoutMaskComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::DropoutMaskComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::DropoutMaskComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DropoutMaskComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::DropoutMaskComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::DropoutMaskComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::DropoutMaskComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::DropoutMaskComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

reset_generator()¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::ResetGenerator()

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

set_dropout_proportion(p:float)¶: Calls C++ function void ::kaldi::nnet3::DropoutMaskComponent::SetDropoutProportion(float)

set_test_mode(test_mode:bool)¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::SetTestMode(bool)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::DropoutMaskComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ElementwiseProductComponent¶

CLIF wrapper for ::kaldi::nnet3::ElementwiseProductComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::ElementwiseProductComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::ElementwiseProductComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

init(input_dim:int, output_dim:int)¶: Calls C++ function void ::kaldi::nnet3::ElementwiseProductComponent::Init(int, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::ElementwiseProductComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ElementwiseProductComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new(input_dim:int, output_dim:int) → ElementwiseProductComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::ElementwiseProductComponent> ::kaldi::nnet3::ElementwiseProductComponent::ElementwiseProductComponent(int, int)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ElementwiseProductComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::ElementwiseProductComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::ElementwiseProductComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ElementwiseProductComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ExampleGenerationConfig¶

CLIF wrapper for ::kaldi::nnet3::ExampleGenerationConfig

compute_derived()¶: Calls C++ function void ::kaldi::nnet3::ExampleGenerationConfig::ComputeDerived()

frame_subsampling_factor¶: C++ ::int32 ExampleGenerationConfig.frame_subsampling_factor

left_context¶: C++ ::int32 ExampleGenerationConfig.left_context

left_context_initial¶: C++ ::int32 ExampleGenerationConfig.left_context_initial

num_frames¶: C++ ::std::vector< ::int32> ExampleGenerationConfig.num_frames

num_frames_overlap¶: C++ ::int32 ExampleGenerationConfig.num_frames_overlap

num_frames_str¶: C++ ::std::string ExampleGenerationConfig.num_frames_str

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

right_context¶: C++ ::int32 ExampleGenerationConfig.right_context

right_context_final¶: C++ ::int32 ExampleGenerationConfig.right_context_final

class kaldi.nnet3.ExampleMerger¶

CLIF wrapper for ::kaldi::nnet3::ExampleMerger

accept_example(a:NnetExample)¶: Calls C++ function void ::kaldi::nnet3::ExampleMerger::AcceptExample(::kaldi::nnet3::NnetExample *)

exit_status() → int¶: Calls C++ function int ::kaldi::nnet3::ExampleMerger::ExitStatus()

finish()¶: Calls C++ function void ::kaldi::nnet3::ExampleMerger::Finish()

class kaldi.nnet3.ExampleMergingConfig¶

CLIF wrapper for ::kaldi::nnet3::ExampleMergingConfig

compress¶: C++ bool ExampleMergingConfig.compress

compute_derived()¶: Calls C++ function void ::kaldi::nnet3::ExampleMergingConfig::ComputeDerived()

discard_partial_minibatches¶: C++ ::std::string ExampleMergingConfig.discard_partial_minibatches

get_minibatch_size(size_of_eg:int, num_available_egs:int, input_ended:bool) → int¶

This function tells you what minibatch size should be used for this eg.

Parameters:	size_of_eg (int) – The size of the eg, as obtained by `GetNnetExampleSize()` num_available_egs (int) – The number of egs of this size that are currently available input_ended (bool) – True if the input has ended. False otherwise
Returns:	Minibatch Size to use in this situation

measure_output_frames¶: C++ ::std::string ExampleMergingConfig.measure_output_frames

minibatch_size¶: C++ ::std::string ExampleMergingConfig.minibatch_size

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

class kaldi.nnet3.ExampleMergingStats¶

CLIF wrapper for ::kaldi::nnet3::ExampleMergingStats

discarded_examples(example_size:int, structure_hash:int, num_discarded:int)¶: Calls C++ function void ::kaldi::nnet3::ExampleMergingStats::DiscardedExamples(int, unsigned long, int)

print_stats()¶: Calls C++ function void ::kaldi::nnet3::ExampleMergingStats::PrintStats()

wrote_example(example_size:int, structure_hash:int, minibatch_size:int)¶: Calls C++ function void ::kaldi::nnet3::ExampleMergingStats::WroteExample(int, unsigned long, int)

class kaldi.nnet3.FixedAffineComponent¶

CLIF wrapper for ::kaldi::nnet3::FixedAffineComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::FixedAffineComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

bias_params() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::FixedAffineComponent::BiasParams()

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::FixedAffineComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

from_affine(c:AffineComponent) → FixedAffineComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::FixedAffineComponent> ::kaldi::nnet3::FixedAffineComponent::FixedAffineComponent(::kaldi::nnet3::AffineComponent)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::FixedAffineComponent::Info()

init(matrix:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::FixedAffineComponent::Init(::kaldi::CuMatrixBase<float>)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::FixedAffineComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::FixedAffineComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

linear_params() → CuMatrix¶: Calls C++ function ::kaldi::CuMatrix<float> ::kaldi::nnet3::FixedAffineComponent::LinearParams()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::FixedAffineComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::FixedAffineComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::FixedAffineComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::FixedAffineComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.FixedBiasComponent¶

CLIF wrapper for ::kaldi::nnet3::FixedBiasComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::FixedBiasComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::FixedBiasComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::FixedBiasComponent::Info()

init(scales:CuVectorBase)¶: Calls C++ function void ::kaldi::nnet3::FixedBiasComponent::Init(::kaldi::CuVectorBase<float>)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::FixedBiasComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::FixedBiasComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::FixedBiasComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::FixedBiasComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::FixedBiasComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::FixedBiasComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.FixedScaleComponent¶

CLIF wrapper for ::kaldi::nnet3::FixedScaleComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::FixedScaleComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::FixedScaleComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::FixedScaleComponent::Info()

init(scales:CuVectorBase)¶: Calls C++ function void ::kaldi::nnet3::FixedScaleComponent::Init(::kaldi::CuVectorBase<float>)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::FixedScaleComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::FixedScaleComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::FixedScaleComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::FixedScaleComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::FixedScaleComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

scales() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::FixedScaleComponent::Scales()

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::FixedScaleComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ForwardingDescriptor¶

CLIF wrapper for ::kaldi::nnet3::ForwardingDescriptor

copy() → ForwardingDescriptor¶: Calls C++ function ::kaldi::nnet3::ForwardingDescriptor * ::kaldi::nnet3::ForwardingDescriptor::Copy()

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::ForwardingDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::ForwardingDescriptor::GetScaleForNode(int)

map_to_input(output:Index) → tuple<int, Index>¶: Calls C++ function ::kaldi::nnet3::Cindex ::kaldi::nnet3::ForwardingDescriptor::MapToInput(::kaldi::nnet3::Index)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::ForwardingDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::ForwardingDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.GeneralDescriptor¶

CLIF wrapper for ::kaldi::nnet3::GeneralDescriptor

DescriptorType¶: alias of GeneralDescriptor.DescriptorType

convert_to_descriptor() → Descriptor¶: Calls C++ function ::kaldi::nnet3::Descriptor * ::kaldi::nnet3::GeneralDescriptor::ConvertToDescriptor()

get_normalized_descriptor() → GeneralDescriptor¶: Calls C++ function ::kaldi::nnet3::GeneralDescriptor * ::kaldi::nnet3::GeneralDescriptor::GetNormalizedDescriptor()

print_descriptor(node_names:list<str>, os:ostream)¶: Calls C++ function void ::kaldi::nnet3::GeneralDescriptor::Print(::std::vector< ::std::string>, ::std::basic_ostream<char, ::std::char_traits<char> >)

class kaldi.nnet3.GeneralDropoutComponent¶

CLIF wrapper for ::kaldi::nnet3::GeneralDropoutComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::GeneralDropoutComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::GeneralDropoutComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::GeneralDropoutComponent::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::GeneralDropoutComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::GeneralDropoutComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::GeneralDropoutComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::GeneralDropoutComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::GeneralDropoutComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::GeneralDropoutComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::GeneralDropoutComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

reset_generator()¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::ResetGenerator()

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

set_dropout_proportion(p:float)¶: Calls C++ function void ::kaldi::nnet3::GeneralDropoutComponent::SetDropoutProportion(float)

set_test_mode(test_mode:bool)¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::SetTestMode(bool)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::GeneralDropoutComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.GeneralDropoutComponentPrecomputedIndexes¶

CLIF wrapper for ::kaldi::nnet3::GeneralDropoutComponentPrecomputedIndexes

copy() → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::GeneralDropoutComponentPrecomputedIndexes::Copy()

indexes¶: C++ ::kaldi::CuArray< ::int32> GeneralDropoutComponentPrecomputedIndexes.indexes

new_component_precomputed_indexes_of_type(cpi_type:str) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::ComponentPrecomputedIndexes::NewComponentPrecomputedIndexesOfType(::std::string)

num_mask_rows¶: C++ ::int32 GeneralDropoutComponentPrecomputedIndexes.num_mask_rows

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

read_new(is:istream, binary:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::ComponentPrecomputedIndexes::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::GeneralDropoutComponentPrecomputedIndexes::Type()

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

class kaldi.nnet3.GruNonlinearityComponent¶

CLIF wrapper for ::kaldi::nnet3::GruNonlinearityComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::GruNonlinearityComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::GruNonlinearityComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::GruNonlinearityComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::GruNonlinearityComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::GruNonlinearityComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::GruNonlinearityComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::GruNonlinearityComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::GruNonlinearityComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::GruNonlinearityComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::GruNonlinearityComponent::ZeroStats()

class kaldi.nnet3.Index¶

CLIF wrapper for ::kaldi::nnet3::Index

n¶: C++ ::int32 Index.n

new(n:int, t:int, x:int=default) → Index¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::Index> ::kaldi::nnet3::Index::Index(int, int, int)

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

t¶: C++ ::int32 Index.t

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

x¶: C++ ::int32 Index.x

class kaldi.nnet3.IndexSet¶: CLIF wrapper for ::kaldi::nnet3::IndexSet

class kaldi.nnet3.IoSpecification¶

CLIF wrapper for ::kaldi::nnet3::IoSpecification

from_indexes(name:str, indexes:list<Index>, has_deriv:bool=default) → IoSpecification¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::IoSpecification> ::kaldi::nnet3::IoSpecification::IoSpecification(::std::string, ::std::vector< ::kaldi::nnet3::Index>, bool)

from_interval(name:str, t_start:int, t_end:int) → IoSpecification¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::IoSpecification> ::kaldi::nnet3::IoSpecification::IoSpecification(::std::string, int, int)

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

has_deriv¶: C++ bool IoSpecification.has_deriv

indexes¶: C++ ::std::vector< ::kaldi::nnet3::Index> IoSpecification.indexes

name¶: C++ ::std::string IoSpecification.name

print_io_spec(os:ostream)¶: Calls C++ function void ::kaldi::nnet3::IoSpecification::Print(::std::basic_ostream<char, ::std::char_traits<char> >)

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

swap(other:IoSpecification)¶: Calls C++ function void ::kaldi::nnet3::IoSpecification::Swap(::kaldi::nnet3::IoSpecification *)

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

class kaldi.nnet3.LinearComponent¶

CLIF wrapper for ::kaldi::nnet3::LinearComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::LinearComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::LinearComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::FreezeNaturalGradient(bool)

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

from_params(params:CuMatrix) → LinearComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::LinearComponent> ::kaldi::nnet3::LinearComponent::LinearComponent(::kaldi::CuMatrix<float>)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::LinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::LinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::LinearComponent::NumParameters()

orthonormal_constraint() → float¶: Calls C++ function float ::kaldi::nnet3::LinearComponent::OrthonormalConstraint()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::LinearComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::LinearComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::LinearComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::LinearComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::LinearComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.LogSoftmaxComponent¶

CLIF wrapper for ::kaldi::nnet3::LogSoftmaxComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::LogSoftmaxComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::LogSoftmaxComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NonlinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::LogSoftmaxComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::LogSoftmaxComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::LogSoftmaxComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.LstmNonlinearityComponent¶

CLIF wrapper for ::kaldi::nnet3::LstmNonlinearityComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::LstmNonlinearityComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::LstmNonlinearityComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::LstmNonlinearityComponent::Info()

init(cell_dim:int, use_dropout:bool, param_stddev:float, tanh_self_repair_threshold:float, sigmoid_self_repair_threshold:float, self_repair_scale:float)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::Init(int, bool, float, float, float, float)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::LstmNonlinearityComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::LstmNonlinearityComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::LstmNonlinearityComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::LstmNonlinearityComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::LstmNonlinearityComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::LstmNonlinearityComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::LstmNonlinearityComponent::ZeroStats()

class kaldi.nnet3.MatrixAccesses¶

CLIF wrapper for ::kaldi::nnet3::MatrixAccesses

accesses¶: C++ ::std::vector< ::kaldi::nnet3::Access> MatrixAccesses.accesses

allocate_command¶: C++ ::int32 MatrixAccesses.allocate_command

deallocate_command¶: C++ ::int32 MatrixAccesses.deallocate_command

is_input¶: C++ bool MatrixAccesses.is_input

is_output¶: C++ bool MatrixAccesses.is_output

class kaldi.nnet3.MiscComputationInfo¶

CLIF wrapper for ::kaldi::nnet3::MiscComputationInfo

print_info(os:ostream)¶: Calls C++ function void ::kaldi::nnet3::MiscComputationInfo::Print(::std::basic_ostream<char, ::std::char_traits<char> >)

class kaldi.nnet3.NaturalGradientAffineComponent¶

CLIF wrapper for ::kaldi::nnet3::NaturalGradientAffineComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientAffineComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

bias_params() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::AffineComponent::BiasParams()

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientAffineComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::NaturalGradientAffineComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::AffineComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientAffineComponent::FreezeNaturalGradient(bool)

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

from_params(linear_params:CuMatrixBase, bias_params:CuVectorBase) → NaturalGradientAffineComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NaturalGradientAffineComponent> ::kaldi::nnet3::NaturalGradientAffineComponent::NaturalGradientAffineComponent(::kaldi::CuMatrixBase<float>, ::kaldi::CuVectorBase<float>)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NaturalGradientAffineComponent::Info()

init(input_dim:int, output_dim:int, param_stddev:float, bias_stddev:float)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Init(int, int, float, float)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientAffineComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

linear_params() → CuMatrix¶: Calls C++ function ::kaldi::CuMatrix<float> ::kaldi::nnet3::AffineComponent::LinearParams()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::NumParameters()

orthonormal_constraint() → float¶: Calls C++ function float ::kaldi::nnet3::AffineComponent::OrthonormalConstraint()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::AffineComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::AffineComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

resize(input_dim:int, output_dim:int)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Resize(int, int)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientAffineComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_params(bias:CuVectorBase, linear:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::SetParams(::kaldi::CuVectorBase<float>, ::kaldi::CuMatrixBase<float>)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NaturalGradientAffineComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::AffineComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.NaturalGradientPerElementScaleComponent¶

CLIF wrapper for ::kaldi::nnet3::NaturalGradientPerElementScaleComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::PerElementScaleComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::Info()

init(dim:int, param_mean:float, param_stddev:float, rank:int, update_period:int, num_samples_history:float, alpha:float)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::Init(int, float, float, int, int, float, float)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

init_from_vector(vector_filename:str, rank:int, update_period:int, num_samples_history:float, alpha:float)¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::Init(::std::string, int, int, float, float)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::PerElementScaleComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NaturalGradientPerElementScaleComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.NaturalGradientRepeatedAffineComponent¶

CLIF wrapper for ::kaldi::nnet3::NaturalGradientRepeatedAffineComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

bias_params() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::RepeatedAffineComponent::BiasParams()

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NaturalGradientRepeatedAffineComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::NaturalGradientRepeatedAffineComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::RepeatedAffineComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::RepeatedAffineComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

linear_params() → CuMatrix¶: Calls C++ function ::kaldi::CuMatrix<float> ::kaldi::nnet3::RepeatedAffineComponent::LinearParams()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::RepeatedAffineComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NaturalGradientRepeatedAffineComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.NetworkNode¶

CLIF wrapper for ::kaldi::nnet3::NetworkNode

descriptor¶: C++ ::kaldi::nnet3::Descriptor NetworkNode.descriptor

dim¶: C++ ::int32 NetworkNode.dim

dim_offset¶: C++ ::int32 NetworkNode.dim_offset

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

node_type¶: C++ ::kaldi::nnet3::NodeType NetworkNode.node_type

class kaldi.nnet3.Nnet¶

CLIF wrapper for ::kaldi::nnet3::Nnet

add_component(name:str, component:Component) → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::AddComponent(::std::string, ::kaldi::nnet3::Component *)

check(warn_for_orphans:bool=default)¶: Calls C++ function void ::kaldi::nnet3::Nnet::Check(bool)

copy() → Nnet¶: Calls C++ function ::kaldi::nnet3::Nnet * ::kaldi::nnet3::Nnet::Copy()

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

get_component_index(component_name:str) → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::GetComponentIndex(::std::string)

get_component_name(node_index:int) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Nnet::GetComponentName(int)

get_component_names() → list<str>¶: Calls C++ function ::std::vector< ::std::string> ::kaldi::nnet3::Nnet::GetComponentNames()

get_config_lines(include_dim:bool) → list<str>¶: Calls C++ function void ::kaldi::nnet3::Nnet::GetConfigLines(bool, ::std::vector< ::std::string>*)

get_node(node:int) → NetworkNode¶: Calls C++ function ::kaldi::nnet3::NetworkNode ::kaldi::nnet3::Nnet::GetNode(int)

get_node_index(node_name:str) → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::GetNodeIndex(::std::string)

get_node_name(node_index:int) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Nnet::GetNodeName(int)

get_node_names() → list<str>¶: Calls C++ function ::std::vector< ::std::string> ::kaldi::nnet3::Nnet::GetNodeNames()

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Nnet::Info()

input_dim(input_name:str) → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::InputDim(::std::string)

is_component_input_node(node:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::Nnet::IsComponentInputNode(int)

is_component_node(node:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::Nnet::IsComponentNode(int)

is_descriptor_node(node:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::Nnet::IsDescriptorNode(int)

is_dim_range_node(node:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::Nnet::IsDimRangeNode(int)

is_input_node(node:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::Nnet::IsInputNode(int)

is_output_node(node:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::Nnet::IsOutputNode(int)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::Modulus()

num_components() → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::NumComponents()

num_nodes() → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::NumNodes()

output_dim(output_name:str) → int¶: Calls C++ function int ::kaldi::nnet3::Nnet::OutputDim(::std::string)

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

read_config(config_file:istream)¶: Calls C++ function void ::kaldi::nnet3::Nnet::ReadConfig(::std::basic_istream<char, ::std::char_traits<char> >)

remove_orphan_components()¶: Calls C++ function void ::kaldi::nnet3::Nnet::RemoveOrphanComponents()

remove_orphan_nodes(remove_orphan_inputs:bool=default)¶: Calls C++ function void ::kaldi::nnet3::Nnet::RemoveOrphanNodes(bool)

remove_some_nodes(nodes_to_remove:list<int>)¶: Calls C++ function void ::kaldi::nnet3::Nnet::RemoveSomeNodes(::std::vector< ::int32>)

reset_generators()¶: Calls C++ function void ::kaldi::nnet3::Nnet::ResetGenerators()

set_component(c:int, component:Component)¶: Calls C++ function void ::kaldi::nnet3::Nnet::SetComponent(int, ::kaldi::nnet3::Component *)

set_node_name(node_index:int, new_name:str)¶: Calls C++ function void ::kaldi::nnet3::Nnet::SetNodeName(int, ::std::string)

swap(other:Nnet)¶: Calls C++ function void ::kaldi::nnet3::Nnet::Swap(::kaldi::nnet3::Nnet *)

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

class kaldi.nnet3.NnetBatchComputer¶: CLIF wrapper for ::kaldi::nnet3::NnetBatchComputer

class kaldi.nnet3.NnetBatchComputerOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetBatchComputerOptions

acoustic_scale¶: C++ ::kaldi::BaseFloat NnetSimpleComputationOptions.acoustic_scale

compiler_config¶: C++ ::kaldi::nnet3::CachingOptimizingCompilerOptions NnetSimpleComputationOptions.compiler_config

compute_config¶: C++ ::kaldi::nnet3::NnetComputeOptions NnetSimpleComputationOptions.compute_config

debug_computation¶: C++ bool NnetSimpleComputationOptions.debug_computation

edge_minibatch_size¶: C++ ::int32 NnetBatchComputerOptions.edge_minibatch_size

ensure_exact_final_context¶: C++ bool NnetBatchComputerOptions.ensure_exact_final_context

extra_left_context¶: C++ ::int32 NnetSimpleComputationOptions.extra_left_context

extra_left_context_initial¶: C++ ::int32 NnetSimpleComputationOptions.extra_left_context_initial

extra_right_context¶: C++ ::int32 NnetSimpleComputationOptions.extra_right_context

extra_right_context_final¶: C++ ::int32 NnetSimpleComputationOptions.extra_right_context_final

frame_subsampling_factor¶: C++ ::int32 NnetSimpleComputationOptions.frame_subsampling_factor

frames_per_chunk¶: C++ ::int32 NnetSimpleComputationOptions.frames_per_chunk

minibatch_size¶: C++ ::int32 NnetBatchComputerOptions.minibatch_size

optimize_config¶: C++ ::kaldi::nnet3::NnetOptimizeOptions NnetSimpleComputationOptions.optimize_config

partial_minibatch_factor¶: C++ ::kaldi::BaseFloat NnetBatchComputerOptions.partial_minibatch_factor

register(opts:OptionsItf)¶

Registers options with an object implementing the options interface.

Parameters:	opts (OptionsItf) – An object implementing the options interface. Typically a command-line option parser.

class kaldi.nnet3.NnetBatchDecoder¶

CLIF wrapper for ::kaldi::nnet3::NnetBatchDecoder

accept_input(utterance_id:str, input:Matrix, ivector:Vector, online_ivectors:Matrix, online_ivector_period:int)¶: Calls C++ function void ::kaldi::nnet3::NnetBatchDecoder::AcceptInput(::std::string, ::kaldi::Matrix<float>, ::kaldi::Vector<float> *, ::kaldi::Matrix<float> *, int)

finished() → int¶: Calls C++ function int ::kaldi::nnet3::NnetBatchDecoder::Finished()

get_output() -> (success:bool, utterance_id:str, clat:CompactLatticeVectorFst, sentence:str)¶: Calls C++ function bool ::kaldi::nnet3::NnetBatchDecoder::GetOutput(::std::string*, ::fst::VectorFst< ::fst::ArcTpl< ::fst::CompactLatticeWeightTpl< ::fst::LatticeWeightTpl<float>, int> >, ::fst::VectorState< ::fst::ArcTpl< ::fst::CompactLatticeWeightTpl< ::fst::LatticeWeightTpl<float>, int> >, ::std::allocator< ::fst::ArcTpl< ::fst::CompactLatticeWeightTpl< ::fst::LatticeWeightTpl<float>, int> > > > >*, ::std::string*)

get_raw_output() -> (success:bool, utterance_id:str, clat:LatticeVectorFst, sentence:str)¶: Calls C++ function bool ::kaldi::nnet3::NnetBatchDecoder::GetOutput(::std::string*, ::fst::VectorFst< ::fst::ArcTpl< ::fst::LatticeWeightTpl<float> >, ::fst::VectorState< ::fst::ArcTpl< ::fst::LatticeWeightTpl<float> >, ::std::allocator< ::fst::ArcTpl< ::fst::LatticeWeightTpl<float> > > > >*, ::std::string*)

utterance_failed()¶: Calls C++ function void ::kaldi::nnet3::NnetBatchDecoder::UtteranceFailed()

class kaldi.nnet3.NnetBatchInference¶

CLIF wrapper for ::kaldi::nnet3::NnetBatchInference

accept_input(utterance_id:str, input:Matrix, ivector:Vector, online_ivectors:Matrix, online_ivector_period:int)¶: Calls C++ function void ::kaldi::nnet3::NnetBatchInference::AcceptInput(::std::string, ::kaldi::Matrix<float>, ::kaldi::Vector<float> *, ::kaldi::Matrix<float> *, int)

finished()¶: Calls C++ function void ::kaldi::nnet3::NnetBatchInference::Finished()

get_output() -> (success:bool, utterance_id:str, output:Matrix)¶: Calls C++ function bool ::kaldi::nnet3::NnetBatchInference::GetOutput(::std::string*, ::kaldi::Matrix<float>*)

class kaldi.nnet3.NnetChainComputeProb¶

CLIF wrapper for ::kaldi::nnet3::NnetChainComputeProb

compute(eg:NnetChainExample)¶: Calls C++ function void ::kaldi::nnet3::NnetChainComputeProb::Compute(::kaldi::nnet3::NnetChainExample)

get_deriv() → Nnet¶: Calls C++ function ::kaldi::nnet3::Nnet ::kaldi::nnet3::NnetChainComputeProb::GetDeriv()

get_objective(output_name:str) → ChainObjectiveInfo¶: Calls C++ function const ::kaldi::nnet3::ChainObjectiveInfo * ::kaldi::nnet3::NnetChainComputeProb::GetObjective(::std::string)

get_total_objective() -> (tot_objective:float, tot_weight:float)¶: Calls C++ function double ::kaldi::nnet3::NnetChainComputeProb::GetTotalObjective(double*)

print_total_stats() → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetChainComputeProb::PrintTotalStats()

reset()¶: Calls C++ function void ::kaldi::nnet3::NnetChainComputeProb::Reset()

class kaldi.nnet3.NnetChainExample¶

CLIF wrapper for ::kaldi::nnet3::NnetChainExample

compress()¶: Calls C++ function void ::kaldi::nnet3::NnetChainExample::Compress()

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

inputs¶: C++ ::std::vector< ::kaldi::nnet3::NnetIo> NnetChainExample.inputs

outputs¶: C++ ::std::vector< ::kaldi::nnet3::NnetChainSupervision> NnetChainExample.outputs

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

swap(other:NnetChainExample)¶: Calls C++ function void ::kaldi::nnet3::NnetChainExample::Swap(::kaldi::nnet3::NnetChainExample *)

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

class kaldi.nnet3.NnetChainSupervision¶

CLIF wrapper for ::kaldi::nnet3::NnetChainSupervision

check_dim()¶: Calls C++ function void ::kaldi::nnet3::NnetChainSupervision::CheckDim()

deriv_weights¶: C++ ::kaldi::Vector< ::kaldi::BaseFloat> NnetChainSupervision.deriv_weights

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

from_supervision(name:str, supervision:Supervision, deriv_weights:Vector, first_frame:int, frame_skip:int) → NnetChainSupervision¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NnetChainSupervision> ::kaldi::nnet3::NnetChainSupervision::NnetChainSupervision(::std::string, ::kaldi::chain::Supervision, ::kaldi::Vector<float>, int, int)

indexes¶: C++ ::std::vector< ::kaldi::nnet3::Index> NnetChainSupervision.indexes

name¶: C++ ::std::string NnetChainSupervision.name

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

supervision¶: C++ ::kaldi::chain::Supervision NnetChainSupervision.supervision

swap(other:NnetChainSupervision)¶: Calls C++ function void ::kaldi::nnet3::NnetChainSupervision::Swap(::kaldi::nnet3::NnetChainSupervision *)

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

class kaldi.nnet3.NnetChainTrainer¶

CLIF wrapper for ::kaldi::nnet3::NnetChainTrainer

print_max_change_stats()¶: Calls C++ function void ::kaldi::nnet3::NnetChainTrainer::PrintMaxChangeStats()

print_total_stats() → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetChainTrainer::PrintTotalStats()

train(eg:NnetChainExample)¶: Calls C++ function void ::kaldi::nnet3::NnetChainTrainer::Train(::kaldi::nnet3::NnetChainExample)

class kaldi.nnet3.NnetChainTrainingOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetChainTrainingOptions

apply_deriv_weights¶: C++ bool NnetChainTrainingOptions.apply_deriv_weights

chain_config¶: C++ ::kaldi::chain::ChainTrainingOptions NnetChainTrainingOptions.chain_config

nnet_config¶: C++ ::kaldi::nnet3::NnetTrainerOptions NnetChainTrainingOptions.nnet_config

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

class kaldi.nnet3.NnetComputation¶

CLIF wrapper for ::kaldi::nnet3::NnetComputation

class Command¶

CLIF wrapper for ::kaldi::nnet3::NnetComputation::Command

alpha¶: C++ ::kaldi::BaseFloat NnetComputation::Command.alpha

arg1¶: C++ ::int32 NnetComputation::Command.arg1

arg2¶: C++ ::int32 NnetComputation::Command.arg2

arg3¶: C++ ::int32 NnetComputation::Command.arg3

arg4¶: C++ ::int32 NnetComputation::Command.arg4

arg5¶: C++ ::int32 NnetComputation::Command.arg5

arg6¶: C++ ::int32 NnetComputation::Command.arg6

arg7¶: C++ ::int32 NnetComputation::Command.arg7

command_type¶: C++ ::kaldi::nnet3::CommandType NnetComputation::Command.command_type

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

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

class MatrixDebugInfo¶

CLIF wrapper for ::kaldi::nnet3::NnetComputation::MatrixDebugInfo

cindexes¶: C++ ::std::vector< ::kaldi::nnet3::Cindex> NnetComputation::MatrixDebugInfo.cindexes

is_deriv¶: C++ bool NnetComputation::MatrixDebugInfo.is_deriv

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

swap(other:MatrixDebugInfo)¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::MatrixDebugInfo::Swap(::kaldi::nnet3::NnetComputation::MatrixDebugInfo *)

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

class MatrixInfo¶

CLIF wrapper for ::kaldi::nnet3::NnetComputation::MatrixInfo

from_args(num_rows:int, num_cols:int, stride_type:MatrixStrideType) → MatrixInfo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NnetComputation::MatrixInfo> ::kaldi::nnet3::NnetComputation::MatrixInfo::MatrixInfo(int, int, ::kaldi::MatrixStrideType)

num_cols¶: C++ ::int32 NnetComputation::MatrixInfo.num_cols

num_rows¶: C++ ::int32 NnetComputation::MatrixInfo.num_rows

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

stride_type¶: C++ ::kaldi::MatrixStrideType NnetComputation::MatrixInfo.stride_type

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

class PrecomputedIndexesInfo¶

CLIF wrapper for ::kaldi::nnet3::NnetComputation::PrecomputedIndexesInfo

input_indexes¶: C++ ::std::vector< ::kaldi::nnet3::Index> NnetComputation::PrecomputedIndexesInfo.input_indexes

output_indexes¶: C++ ::std::vector< ::kaldi::nnet3::Index> NnetComputation::PrecomputedIndexesInfo.output_indexes

class SubMatrixInfo¶

CLIF wrapper for ::kaldi::nnet3::NnetComputation::SubMatrixInfo

col_offset¶: C++ ::int32 NnetComputation::SubMatrixInfo.col_offset

from_args(matrix_index:int, row_offset:int, num_rows:int, col_offset:int, num_cols:int) → SubMatrixInfo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NnetComputation::SubMatrixInfo> ::kaldi::nnet3::NnetComputation::SubMatrixInfo::SubMatrixInfo(int, int, int, int, int)

matrix_index¶: C++ ::int32 NnetComputation::SubMatrixInfo.matrix_index

num_cols¶: C++ ::int32 NnetComputation::SubMatrixInfo.num_cols

num_rows¶: C++ ::int32 NnetComputation::SubMatrixInfo.num_rows

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

row_offset¶: C++ ::int32 NnetComputation::SubMatrixInfo.row_offset

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

clear()¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::Clear()

commands¶: C++ ::std::vector< ::kaldi::nnet3::NnetComputation::Command> NnetComputation.commands

component_precomputed_indexes¶: C++ ::std::vector< ::kaldi::nnet3::NnetComputation::PrecomputedIndexesInfo> NnetComputation.component_precomputed_indexes

compute_cuda_indexes()¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::ComputeCudaIndexes()

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

get_command_strings(nnet:Nnet) -> (preamble:str, command_strings:list<str>)¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::GetCommandStrings(::kaldi::nnet3::Nnet, ::std::string*, ::std::vector< ::std::string>*)

get_submatrix_strings(nnet:Nnet) → list<str>¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::GetSubmatrixStrings(::kaldi::nnet3::Nnet, ::std::vector< ::std::string>*)

get_whole_submatrices() → list<int>¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::GetWholeSubmatrices(::std::vector< ::int32>*)

indexes¶: C++ ::std::vector< ::std::vector< ::int32> > NnetComputation.indexes

indexes_cuda¶: C++ ::std::vector< ::kaldi::CuArray< ::int32> > NnetComputation.indexes_cuda

indexes_multi¶: C++ ::std::vector< ::std::vector< ::std::pair< ::int32, ::int32> > > NnetComputation.indexes_multi

indexes_ranges¶: C++ ::std::vector< ::std::vector< ::std::pair< ::int32, ::int32> > > NnetComputation.indexes_ranges

indexes_ranges_cuda¶: C++ ::std::vector< ::kaldi::CuArray< ::Int32Pair> > NnetComputation.indexes_ranges_cuda

is_whole_matrix(submatrix_index:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetComputation::IsWholeMatrix(int)

matrices¶: C++ ::std::vector< ::kaldi::nnet3::NnetComputation::MatrixInfo> NnetComputation.matrices

matrix_debug_info¶: C++ ::std::vector< ::kaldi::nnet3::NnetComputation::MatrixDebugInfo> NnetComputation.matrix_debug_info

need_model_derivative¶: C++ bool NnetComputation.need_model_derivative

new_matrix(num_rows:int, num_cols:int, stride_type:MatrixStrideType) → int¶: Calls C++ function int ::kaldi::nnet3::NnetComputation::NewMatrix(int, int, ::kaldi::MatrixStrideType)

new_sub_matrix(base_submatrix:int, row_offset:int, num_rows:int, col_offset:int, num_cols:int) → int¶: Calls C++ function int ::kaldi::nnet3::NnetComputation::NewSubMatrix(int, int, int, int, int)

print_computation(os:ostream, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::NnetComputation::Print(::std::basic_ostream<char, ::std::char_traits<char> >, ::kaldi::nnet3::Nnet)

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

submatrices¶: C++ ::std::vector< ::kaldi::nnet3::NnetComputation::SubMatrixInfo> NnetComputation.submatrices

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

class kaldi.nnet3.NnetComputeOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetComputeOptions

debug¶: C++ bool NnetComputeOptions.debug

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

class kaldi.nnet3.NnetComputeProb¶

CLIF wrapper for ::kaldi::nnet3::NnetComputeProb

compute(eg:NnetExample)¶: Calls C++ function void ::kaldi::nnet3::NnetComputeProb::Compute(::kaldi::nnet3::NnetExample)

get_deriv() → Nnet¶: Calls C++ function ::kaldi::nnet3::Nnet ::kaldi::nnet3::NnetComputeProb::GetDeriv()

get_objective(output_name:str) → SimpleObjectiveInfo¶: Calls C++ function const ::kaldi::nnet3::SimpleObjectiveInfo * ::kaldi::nnet3::NnetComputeProb::GetObjective(::std::string)

get_total_objective() -> (tot_objective:float, tot_weight:float)¶: Calls C++ function double ::kaldi::nnet3::NnetComputeProb::GetTotalObjective(double*)

print_total_stats() → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetComputeProb::PrintTotalStats()

reset()¶: Calls C++ function void ::kaldi::nnet3::NnetComputeProb::Reset()

class kaldi.nnet3.NnetComputeProbOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetComputeProbOptions

compiler_config¶: C++ ::kaldi::nnet3::CachingOptimizingCompilerOptions NnetComputeProbOptions.compiler_config

compute_accuracy¶: C++ bool NnetComputeProbOptions.compute_accuracy

compute_config¶: C++ ::kaldi::nnet3::NnetComputeOptions NnetComputeProbOptions.compute_config

compute_deriv¶: C++ bool NnetComputeProbOptions.compute_deriv

compute_per_dim_accuracy¶: C++ bool NnetComputeProbOptions.compute_per_dim_accuracy

debug_computation¶: C++ bool NnetComputeProbOptions.debug_computation

optimize_config¶: C++ ::kaldi::nnet3::NnetOptimizeOptions NnetComputeProbOptions.optimize_config

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

store_component_stats¶: C++ bool NnetComputeProbOptions.store_component_stats

class kaldi.nnet3.NnetComputer¶

CLIF wrapper for ::kaldi::nnet3::NnetComputer

accept_input(node_name:str, input:CuMatrix)¶: Calls C++ function void ::kaldi::nnet3::NnetComputer::AcceptInput(::std::string, ::kaldi::CuMatrix<float> *)

accept_inputs(nnet:Nnet, io:list<NnetIo>)¶: Calls C++ function void ::kaldi::nnet3::NnetComputer::AcceptInputs(::kaldi::nnet3::Nnet, ::std::vector< ::kaldi::nnet3::NnetIo>)

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

get_output_destructive(output_name:str) → CuMatrix¶: Calls C++ function void ::kaldi::nnet3::NnetComputer::GetOutputDestructive(::std::string, ::kaldi::CuMatrix<float>*)

run()¶: Calls C++ function void ::kaldi::nnet3::NnetComputer::Run()

class kaldi.nnet3.NnetExample¶

CLIF wrapper for ::kaldi::nnet3::NnetExample

compress()¶: Calls C++ function void ::kaldi::nnet3::NnetExample::Compress()

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

io¶: C++ ::std::vector< ::kaldi::nnet3::NnetIo> NnetExample.io

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

swap(other:NnetExample)¶: Calls C++ function void ::kaldi::nnet3::NnetExample::Swap(::kaldi::nnet3::NnetExample *)

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

class kaldi.nnet3.NnetGenerationOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetGenerationOptions

allow_clockwork¶: C++ bool NnetGenerationOptions.allow_clockwork

allow_context¶: C++ bool NnetGenerationOptions.allow_context

allow_final_nonlinearity¶: C++ bool NnetGenerationOptions.allow_final_nonlinearity

allow_ivector¶: C++ bool NnetGenerationOptions.allow_ivector

allow_multiple_inputs¶: C++ bool NnetGenerationOptions.allow_multiple_inputs

allow_multiple_outputs¶: C++ bool NnetGenerationOptions.allow_multiple_outputs

allow_nonlinearity¶: C++ bool NnetGenerationOptions.allow_nonlinearity

allow_recursion¶: C++ bool NnetGenerationOptions.allow_recursion

allow_statistics_pooling¶: C++ bool NnetGenerationOptions.allow_statistics_pooling

allow_use_of_x_dim¶: C++ bool NnetGenerationOptions.allow_use_of_x_dim

output_dim¶: C++ ::int32 NnetGenerationOptions.output_dim

class kaldi.nnet3.NnetIo¶

CLIF wrapper for ::kaldi::nnet3::NnetIo

features¶: C++ ::kaldi::GeneralMatrix NnetIo.features

from_general_matrix(name:str, t_begin:int, feats:GeneralMatrix, t_stride:int=default) → NnetIo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NnetIo> ::kaldi::nnet3::NnetIo::NnetIo(::std::string, int, ::kaldi::GeneralMatrix, int)

from_matrix(name:str, t_begin:int, feats:MatrixBase, t_stride:int=default) → NnetIo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NnetIo> ::kaldi::nnet3::NnetIo::NnetIo(::std::string, int, ::kaldi::MatrixBase<float>, int)

from_posterior(name:str, dim:int, t_begin:int, labels:list<list<tuple<int, float>>>, t_stride:int=default) → NnetIo¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::NnetIo> ::kaldi::nnet3::NnetIo::NnetIo(::std::string, int, int, ::kaldi::Posterior, int)

indexes¶: C++ ::std::vector< ::kaldi::nnet3::Index> NnetIo.indexes

name¶: C++ ::std::string NnetIo.name

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

swap(other:NnetIo)¶: Calls C++ function void ::kaldi::nnet3::NnetIo::Swap(::kaldi::nnet3::NnetIo *)

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

class kaldi.nnet3.NnetOptimizeOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetOptimizeOptions

allocate_from_other¶: C++ bool NnetOptimizeOptions.allocate_from_other

allow_left_merge¶: C++ bool NnetOptimizeOptions.allow_left_merge

allow_right_merge¶: C++ bool NnetOptimizeOptions.allow_right_merge

backprop_in_place¶: C++ bool NnetOptimizeOptions.backprop_in_place

consolidate_model_update¶: C++ bool NnetOptimizeOptions.consolidate_model_update

convert_addition¶: C++ bool NnetOptimizeOptions.convert_addition

extend_matrices¶: C++ bool NnetOptimizeOptions.extend_matrices

initialize_undefined¶: C++ bool NnetOptimizeOptions.initialize_undefined

max_deriv_time¶: C++ ::int32 NnetOptimizeOptions.max_deriv_time

max_deriv_time_relative¶: C++ ::int32 NnetOptimizeOptions.max_deriv_time_relative

memory_compression_level¶: C++ ::int32 NnetOptimizeOptions.memory_compression_level

min_deriv_time¶: C++ ::int32 NnetOptimizeOptions.min_deriv_time

move_sizing_commands¶: C++ bool NnetOptimizeOptions.move_sizing_commands

optimize¶: C++ bool NnetOptimizeOptions.optimize

optimize_looped_computation¶: C++ bool NnetOptimizeOptions.optimize_looped_computation

optimize_row_ops¶: C++ bool NnetOptimizeOptions.optimize_row_ops

propagate_in_place¶: C++ bool NnetOptimizeOptions.propagate_in_place

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

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

remove_assignments¶: C++ bool NnetOptimizeOptions.remove_assignments

snip_row_ops¶: C++ bool NnetOptimizeOptions.snip_row_ops

split_row_ops¶: C++ bool NnetOptimizeOptions.split_row_ops

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

class kaldi.nnet3.NnetSimpleComputationOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetSimpleComputationOptions

acoustic_scale¶: C++ ::kaldi::BaseFloat NnetSimpleComputationOptions.acoustic_scale

compiler_config¶: C++ ::kaldi::nnet3::CachingOptimizingCompilerOptions NnetSimpleComputationOptions.compiler_config

compute_config¶: C++ ::kaldi::nnet3::NnetComputeOptions NnetSimpleComputationOptions.compute_config

debug_computation¶: C++ bool NnetSimpleComputationOptions.debug_computation

extra_left_context¶: C++ ::int32 NnetSimpleComputationOptions.extra_left_context

extra_left_context_initial¶: C++ ::int32 NnetSimpleComputationOptions.extra_left_context_initial

extra_right_context¶: C++ ::int32 NnetSimpleComputationOptions.extra_right_context

extra_right_context_final¶: C++ ::int32 NnetSimpleComputationOptions.extra_right_context_final

frame_subsampling_factor¶: C++ ::int32 NnetSimpleComputationOptions.frame_subsampling_factor

frames_per_chunk¶: C++ ::int32 NnetSimpleComputationOptions.frames_per_chunk

optimize_config¶: C++ ::kaldi::nnet3::NnetOptimizeOptions NnetSimpleComputationOptions.optimize_config

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

class kaldi.nnet3.NnetSimpleLoopedComputationOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetSimpleLoopedComputationOptions

acoustic_scale¶: C++ ::kaldi::BaseFloat NnetSimpleLoopedComputationOptions.acoustic_scale

compute_config¶: C++ ::kaldi::nnet3::NnetComputeOptions NnetSimpleLoopedComputationOptions.compute_config

debug_computation¶: C++ bool NnetSimpleLoopedComputationOptions.debug_computation

extra_left_context_initial¶: C++ ::int32 NnetSimpleLoopedComputationOptions.extra_left_context_initial

frame_subsampling_factor¶: C++ ::int32 NnetSimpleLoopedComputationOptions.frame_subsampling_factor

frames_per_chunk¶: C++ ::int32 NnetSimpleLoopedComputationOptions.frames_per_chunk

optimize_config¶: C++ ::kaldi::nnet3::NnetOptimizeOptions NnetSimpleLoopedComputationOptions.optimize_config

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

class kaldi.nnet3.NnetTrainer¶

CLIF wrapper for ::kaldi::nnet3::NnetTrainer

print_max_change_stats()¶: Calls C++ function void ::kaldi::nnet3::NnetTrainer::PrintMaxChangeStats()

print_total_stats() → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetTrainer::PrintTotalStats()

train(eg:NnetExample)¶: Calls C++ function void ::kaldi::nnet3::NnetTrainer::Train(::kaldi::nnet3::NnetExample)

class kaldi.nnet3.NnetTrainerOptions¶

CLIF wrapper for ::kaldi::nnet3::NnetTrainerOptions

backstitch_training_interval¶: C++ ::int32 NnetTrainerOptions.backstitch_training_interval

backstitch_training_scale¶: C++ ::kaldi::BaseFloat NnetTrainerOptions.backstitch_training_scale

batchnorm_stats_scale¶: C++ ::kaldi::BaseFloat NnetTrainerOptions.batchnorm_stats_scale

binary_write_cache¶: C++ bool NnetTrainerOptions.binary_write_cache

compiler_config¶: C++ ::kaldi::nnet3::CachingOptimizingCompilerOptions NnetTrainerOptions.compiler_config

compute_config¶: C++ ::kaldi::nnet3::NnetComputeOptions NnetTrainerOptions.compute_config

debug_computation¶: C++ bool NnetTrainerOptions.debug_computation

l2_regularize_factor¶: C++ ::kaldi::BaseFloat NnetTrainerOptions.l2_regularize_factor

max_param_change¶: C++ ::kaldi::BaseFloat NnetTrainerOptions.max_param_change

momentum¶: C++ ::kaldi::BaseFloat NnetTrainerOptions.momentum

optimize_config¶: C++ ::kaldi::nnet3::NnetOptimizeOptions NnetTrainerOptions.optimize_config

print_interval¶: C++ ::int32 NnetTrainerOptions.print_interval

read_cache¶: C++ ::std::string NnetTrainerOptions.read_cache

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

store_component_stats¶: C++ bool NnetTrainerOptions.store_component_stats

write_cache¶: C++ ::std::string NnetTrainerOptions.write_cache

zero_component_stats¶: C++ bool NnetTrainerOptions.zero_component_stats

class kaldi.nnet3.NoOpComponent¶

CLIF wrapper for ::kaldi::nnet3::NoOpComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::NoOpComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::NoOpComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NoOpComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NoOpComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NoOpComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NoOpComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::NoOpComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::NoOpComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NoOpComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.NodeType¶

An enumeration.

COMPONENT = 2¶

DESCRIPTOR = 1¶

DIM_RANGE = 3¶

INPUT = 0¶

NONE = 4¶

class kaldi.nnet3.NonlinearComponent¶

CLIF wrapper for ::kaldi::nnet3::NonlinearComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NonlinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.NormalizeComponent¶

CLIF wrapper for ::kaldi::nnet3::NormalizeComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::NormalizeComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::NormalizeComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NormalizeComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NormalizeComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NormalizeComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NormalizeComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::NormalizeComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::NormalizeComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NormalizeComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ObjectiveFunctionInfo¶

CLIF wrapper for ::kaldi::nnet3::ObjectiveFunctionInfo

current_phase¶: C++ ::int32 ObjectiveFunctionInfo.current_phase

minibatches_this_phase¶: C++ ::int32 ObjectiveFunctionInfo.minibatches_this_phase

print_stats_for_this_phase(output_name:str, minibatches_per_phase:int, phase:int)¶: Calls C++ function void ::kaldi::nnet3::ObjectiveFunctionInfo::PrintStatsForThisPhase(::std::string, int, int)

print_total_stats(output_name:str) → bool¶: Calls C++ function bool ::kaldi::nnet3::ObjectiveFunctionInfo::PrintTotalStats(::std::string)

tot_aux_objf¶: C++ double ObjectiveFunctionInfo.tot_aux_objf

tot_aux_objf_this_phase¶: C++ double ObjectiveFunctionInfo.tot_aux_objf_this_phase

tot_objf¶: C++ double ObjectiveFunctionInfo.tot_objf

tot_objf_this_phase¶: C++ double ObjectiveFunctionInfo.tot_objf_this_phase

tot_weight¶: C++ double ObjectiveFunctionInfo.tot_weight

tot_weight_this_phase¶: C++ double ObjectiveFunctionInfo.tot_weight_this_phase

update_stats(output_name:str, minibatches_per_phase:int, minibatch_counter:int, this_minibatch_weight:float, this_minibatch_tot_objf:float, this_minibatch_tot_aux_objf:float=default)¶: Calls C++ function void ::kaldi::nnet3::ObjectiveFunctionInfo::UpdateStats(::std::string, int, int, float, float, float)

class kaldi.nnet3.ObjectiveType¶

An enumeration.

LINEAR = 0¶

QUADRATIC = 1¶

class kaldi.nnet3.OffsetForwardingDescriptor¶

CLIF wrapper for ::kaldi::nnet3::OffsetForwardingDescriptor

copy() → ForwardingDescriptor¶: Calls C++ function ::kaldi::nnet3::ForwardingDescriptor * ::kaldi::nnet3::OffsetForwardingDescriptor::Copy()

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::OffsetForwardingDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::OffsetForwardingDescriptor::GetScaleForNode(int)

map_to_input(output:Index) → tuple<int, Index>¶: Calls C++ function ::kaldi::nnet3::Cindex ::kaldi::nnet3::OffsetForwardingDescriptor::MapToInput(::kaldi::nnet3::Index)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::OffsetForwardingDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::OffsetForwardingDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.OnlineNaturalGradient¶

CLIF wrapper for ::kaldi::nnet3::OnlineNaturalGradient

freeze(frozen:bool)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::Freeze(bool)

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

get_alpha() → float¶: Calls C++ function float ::kaldi::nnet3::OnlineNaturalGradient::GetAlpha()

get_num_samples_history() → float¶: Calls C++ function float ::kaldi::nnet3::OnlineNaturalGradient::GetNumSamplesHistory()

get_rank() → int¶: Calls C++ function int ::kaldi::nnet3::OnlineNaturalGradient::GetRank()

get_update_period() → int¶: Calls C++ function int ::kaldi::nnet3::OnlineNaturalGradient::GetUpdatePeriod()

precondition_directions(R:CuMatrixBase) → float¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::PreconditionDirections(::kaldi::CuMatrixBase<float> , float)

set_alpha(alpha:float)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::SetAlpha(float)

set_num_minibatches_history(num_minibatches_history:float)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::SetNumMinibatchesHistory(float)

set_num_samples_history(num_samples_history:float)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::SetNumSamplesHistory(float)

set_rank(rank:int)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::SetRank(int)

set_update_period(update_period:int)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::SetUpdatePeriod(int)

swap(other:OnlineNaturalGradient)¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::Swap(::kaldi::nnet3::OnlineNaturalGradient *)

turn_on_debug()¶: Calls C++ function void ::kaldi::nnet3::OnlineNaturalGradient::TurnOnDebug()

class kaldi.nnet3.OptionalSumDescriptor¶

CLIF wrapper for ::kaldi::nnet3::OptionalSumDescriptor

copy() → SumDescriptor¶: Calls C++ function ::kaldi::nnet3::SumDescriptor * ::kaldi::nnet3::OptionalSumDescriptor::Copy()

get_dependencies(ind:Index) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::OptionalSumDescriptor::GetDependencies(::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Cindex>*)

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::OptionalSumDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::OptionalSumDescriptor::GetScaleForNode(int)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::OptionalSumDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::OptionalSumDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.OutputGruNonlinearityComponent¶

CLIF wrapper for ::kaldi::nnet3::OutputGruNonlinearityComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::OutputGruNonlinearityComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::OutputGruNonlinearityComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::OutputGruNonlinearityComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::OutputGruNonlinearityComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::OutputGruNonlinearityComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::OutputGruNonlinearityComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::OutputGruNonlinearityComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::OutputGruNonlinearityComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::OutputGruNonlinearityComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::OutputGruNonlinearityComponent::ZeroStats()

class kaldi.nnet3.PerDimObjectiveInfo¶

CLIF wrapper for ::kaldi::nnet3::PerDimObjectiveInfo

tot_objective¶: C++ double SimpleObjectiveInfo.tot_objective

tot_objective_vec¶: C++ ::kaldi::Vector< ::kaldi::BaseFloat> PerDimObjectiveInfo.tot_objective_vec

tot_weight¶: C++ double SimpleObjectiveInfo.tot_weight

tot_weight_vec¶: C++ ::kaldi::Vector< ::kaldi::BaseFloat> PerDimObjectiveInfo.tot_weight_vec

class kaldi.nnet3.PerElementOffsetComponent¶

CLIF wrapper for ::kaldi::nnet3::PerElementOffsetComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::PerElementOffsetComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::PerElementOffsetComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PerElementOffsetComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementOffsetComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementOffsetComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementOffsetComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::PerElementOffsetComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementOffsetComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PerElementOffsetComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementOffsetComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.PerElementScaleComponent¶

CLIF wrapper for ::kaldi::nnet3::PerElementScaleComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::PerElementScaleComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::PerElementScaleComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PerElementScaleComponent::Info()

init(dim:int, param_mean:float, param_stddev:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Init(int, float, float)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

init_from_vector(vector_filename:str)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Init(::std::string)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::PerElementScaleComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::PerElementScaleComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PerElementScaleComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::PerElementScaleComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.PermuteComponent¶

CLIF wrapper for ::kaldi::nnet3::PermuteComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::PermuteComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::PermuteComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::PermuteComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

from_column_map(column_map:list<int>) → PermuteComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::PermuteComponent> ::kaldi::nnet3::PermuteComponent::PermuteComponent(::std::vector< ::int32>)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PermuteComponent::Info()

init(column_map:list<int>)¶: Calls C++ function void ::kaldi::nnet3::PermuteComponent::Init(::std::vector< ::int32>)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::PermuteComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PermuteComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PermuteComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::PermuteComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::PermuteComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::PermuteComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PermuteComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::PermuteComponent::ZeroStats()

class kaldi.nnet3.PnormComponent¶

CLIF wrapper for ::kaldi::nnet3::PnormComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::PnormComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::PnormComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

from_dims(input_dim:int, output_dim:int) → PnormComponent¶: Calls C++ function std::unique_ptr<::kaldi::nnet3::PnormComponent> ::kaldi::nnet3::PnormComponent::PnormComponent(int, int)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

init(input_dim:int, output_dim:int)¶: Calls C++ function void ::kaldi::nnet3::PnormComponent::Init(int, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::PnormComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PnormComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::PnormComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::PnormComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::PnormComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PnormComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.RandomComponent¶

CLIF wrapper for ::kaldi::nnet3::RandomComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

reset_generator()¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::ResetGenerator()

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

set_test_mode(test_mode:bool)¶: Calls C++ function void ::kaldi::nnet3::RandomComponent::SetTestMode(bool)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.RectifiedLinearComponent¶

CLIF wrapper for ::kaldi::nnet3::RectifiedLinearComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::RectifiedLinearComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::RectifiedLinearComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NonlinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::RectifiedLinearComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::RectifiedLinearComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::RectifiedLinearComponent::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::RectifiedLinearComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.RepeatedAffineComponent¶

CLIF wrapper for ::kaldi::nnet3::RepeatedAffineComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

bias_params() → CuVector¶: Calls C++ function ::kaldi::CuVector<float> ::kaldi::nnet3::RepeatedAffineComponent::BiasParams()

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::RepeatedAffineComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::RepeatedAffineComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::RepeatedAffineComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

linear_params() → CuMatrix¶: Calls C++ function ::kaldi::CuMatrix<float> ::kaldi::nnet3::RepeatedAffineComponent::LinearParams()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::RepeatedAffineComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::RepeatedAffineComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::RepeatedAffineComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::RepeatedAffineComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.ReplaceIndexForwardingDescriptor¶

CLIF wrapper for ::kaldi::nnet3::ReplaceIndexForwardingDescriptor

VariableName¶: alias of ReplaceIndexForwardingDescriptor.VariableName

copy() → ForwardingDescriptor¶: Calls C++ function ::kaldi::nnet3::ForwardingDescriptor * ::kaldi::nnet3::ReplaceIndexForwardingDescriptor::Copy()

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::ReplaceIndexForwardingDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::ReplaceIndexForwardingDescriptor::GetScaleForNode(int)

map_to_input(output:Index) → tuple<int, Index>¶: Calls C++ function ::kaldi::nnet3::Cindex ::kaldi::nnet3::ReplaceIndexForwardingDescriptor::MapToInput(::kaldi::nnet3::Index)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::ForwardingDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::ReplaceIndexForwardingDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.RestrictedAttentionComponent¶

CLIF wrapper for ::kaldi::nnet3::RestrictedAttentionComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::RestrictedAttentionComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::RestrictedAttentionComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::RestrictedAttentionComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::RestrictedAttentionComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::RestrictedAttentionComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::RestrictedAttentionComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::RestrictedAttentionComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::RestrictedAttentionComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::RestrictedAttentionComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::RestrictedAttentionComponent::ZeroStats()

class kaldi.nnet3.RoundingForwardingDescriptor¶

CLIF wrapper for ::kaldi::nnet3::RoundingForwardingDescriptor

copy() → ForwardingDescriptor¶: Calls C++ function ::kaldi::nnet3::ForwardingDescriptor * ::kaldi::nnet3::RoundingForwardingDescriptor::Copy()

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::RoundingForwardingDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::RoundingForwardingDescriptor::GetScaleForNode(int)

map_to_input(output:Index) → tuple<int, Index>¶: Calls C++ function ::kaldi::nnet3::Cindex ::kaldi::nnet3::RoundingForwardingDescriptor::MapToInput(::kaldi::nnet3::Index)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::RoundingForwardingDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::RoundingForwardingDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.ScaleAndOffsetComponent¶

CLIF wrapper for ::kaldi::nnet3::ScaleAndOffsetComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::ScaleAndOffsetComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::ScaleAndOffsetComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ScaleAndOffsetComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ScaleAndOffsetComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::ScaleAndOffsetComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::ScaleAndOffsetComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::ScaleAndOffsetComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::ScaleAndOffsetComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ScaleAndOffsetComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ScaleAndOffsetComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.SigmoidComponent¶

CLIF wrapper for ::kaldi::nnet3::SigmoidComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::SigmoidComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::SigmoidComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NonlinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::SigmoidComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::SigmoidComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::SigmoidComponent::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SigmoidComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.SimpleForwardingDescriptor¶

CLIF wrapper for ::kaldi::nnet3::SimpleForwardingDescriptor

copy() → ForwardingDescriptor¶: Calls C++ function ::kaldi::nnet3::ForwardingDescriptor * ::kaldi::nnet3::SimpleForwardingDescriptor::Copy()

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::SimpleForwardingDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::SimpleForwardingDescriptor::GetScaleForNode(int)

map_to_input(output:Index) → tuple<int, Index>¶: Calls C++ function ::kaldi::nnet3::Cindex ::kaldi::nnet3::SimpleForwardingDescriptor::MapToInput(::kaldi::nnet3::Index)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::ForwardingDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::SimpleForwardingDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.SimpleObjectiveInfo¶

CLIF wrapper for ::kaldi::nnet3::SimpleObjectiveInfo

tot_objective¶: C++ double SimpleObjectiveInfo.tot_objective

tot_weight¶: C++ double SimpleObjectiveInfo.tot_weight

class kaldi.nnet3.SimpleSumDescriptor¶

CLIF wrapper for ::kaldi::nnet3::SimpleSumDescriptor

copy() → SumDescriptor¶: Calls C++ function ::kaldi::nnet3::SumDescriptor * ::kaldi::nnet3::SimpleSumDescriptor::Copy()

get_dependencies(ind:Index) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::SimpleSumDescriptor::GetDependencies(::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Cindex>*)

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::SimpleSumDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::SimpleSumDescriptor::GetScaleForNode(int)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::SimpleSumDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::SimpleSumDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.SoftmaxComponent¶

CLIF wrapper for ::kaldi::nnet3::SoftmaxComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::SoftmaxComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::SoftmaxComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NonlinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::SoftmaxComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::SoftmaxComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::SoftmaxComponent::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SoftmaxComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.StatisticsExtractionComponent¶

CLIF wrapper for ::kaldi::nnet3::StatisticsExtractionComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::StatisticsExtractionComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::StatisticsExtractionComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::StatisticsExtractionComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::StatisticsExtractionComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::StatisticsExtractionComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::StatisticsExtractionComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::StatisticsExtractionComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::StatisticsExtractionComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::StatisticsExtractionComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::StatisticsExtractionComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::StatisticsExtractionComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.StatisticsExtractionComponentPrecomputedIndexes¶

CLIF wrapper for ::kaldi::nnet3::StatisticsExtractionComponentPrecomputedIndexes

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backward_indexes¶: C++ ::kaldi::CuArray< ::int32> StatisticsExtractionComponentPrecomputedIndexes.backward_indexes

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::StatisticsExtractionComponentPrecomputedIndexes::Copy()

counts¶: C++ ::kaldi::CuVector< ::kaldi::BaseFloat> StatisticsExtractionComponentPrecomputedIndexes.counts

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

forward_indexes¶: C++ ::kaldi::CuArray< ::Int32Pair> StatisticsExtractionComponentPrecomputedIndexes.forward_indexes

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::StatisticsExtractionComponentPrecomputedIndexes::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.StatisticsPoolingComponent¶

CLIF wrapper for ::kaldi::nnet3::StatisticsPoolingComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::StatisticsPoolingComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::StatisticsPoolingComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::StatisticsPoolingComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::StatisticsPoolingComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::StatisticsPoolingComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::StatisticsPoolingComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::StatisticsPoolingComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::StatisticsPoolingComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::StatisticsPoolingComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::StatisticsPoolingComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::StatisticsPoolingComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.StatisticsPoolingComponentPrecomputedIndexes¶

CLIF wrapper for ::kaldi::nnet3::StatisticsPoolingComponentPrecomputedIndexes

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backward_indexes¶: C++ ::kaldi::CuArray< ::Int32Pair> StatisticsPoolingComponentPrecomputedIndexes.backward_indexes

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::StatisticsPoolingComponentPrecomputedIndexes::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

forward_indexes¶: C++ ::kaldi::CuArray< ::Int32Pair> StatisticsPoolingComponentPrecomputedIndexes.forward_indexes

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::StatisticsPoolingComponentPrecomputedIndexes::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.SumBlockComponent¶

CLIF wrapper for ::kaldi::nnet3::SumBlockComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::SumBlockComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::SumBlockComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SumBlockComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::SumBlockComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::SumBlockComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::SumBlockComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::SumBlockComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::SumBlockComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SumBlockComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.SumDescriptor¶

CLIF wrapper for ::kaldi::nnet3::SumDescriptor

get_dependencies(ind:Index) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::SumDescriptor::GetDependencies(::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Cindex>*)

class kaldi.nnet3.SumGroupComponent¶

CLIF wrapper for ::kaldi::nnet3::SumGroupComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::SumGroupComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::SumGroupComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

get_sizes() → list<int>¶: Calls C++ function void ::kaldi::nnet3::SumGroupComponent::GetSizes(::std::vector< ::int32>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::Component::Info()

init(input_dim:int, output_dim:int)¶: Calls C++ function void ::kaldi::nnet3::SumGroupComponent::Init(int, int)

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::SumGroupComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

init_from_sizes(sizes:list<int>)¶: Calls C++ function void ::kaldi::nnet3::SumGroupComponent::Init(::std::vector< ::int32>)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::SumGroupComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::SumGroupComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::SumGroupComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::SumGroupComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SumGroupComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.SwitchingForwardingDescriptor¶

CLIF wrapper for ::kaldi::nnet3::SwitchingForwardingDescriptor

copy() → ForwardingDescriptor¶: Calls C++ function ::kaldi::nnet3::ForwardingDescriptor * ::kaldi::nnet3::SwitchingForwardingDescriptor::Copy()

get_node_dependencies() → list<int>¶: Calls C++ function void ::kaldi::nnet3::SwitchingForwardingDescriptor::GetNodeDependencies(::std::vector< ::int32>*)

get_scale_for_node(node_index:int) → float¶: Calls C++ function float ::kaldi::nnet3::SwitchingForwardingDescriptor::GetScaleForNode(int)

map_to_input(output:Index) → tuple<int, Index>¶: Calls C++ function ::kaldi::nnet3::Cindex ::kaldi::nnet3::SwitchingForwardingDescriptor::MapToInput(::kaldi::nnet3::Index)

modulus() → int¶: Calls C++ function int ::kaldi::nnet3::SwitchingForwardingDescriptor::Modulus()

write_config(os:ostream, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::SwitchingForwardingDescriptor::WriteConfig(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>)

class kaldi.nnet3.TanhComponent¶

CLIF wrapper for ::kaldi::nnet3::TanhComponent

DerivSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::DerivSum()

ValueSum() → CuDoubleVector¶: Calls C++ function ::kaldi::CuVector<double> ::kaldi::nnet3::NonlinearComponent::ValueSum()

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::TanhComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::TanhComponent::Copy()

count() → float¶: Calls C++ function double ::kaldi::nnet3::NonlinearComponent::Count()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NonlinearComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::NonlinearComponent::OutputDim()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::TanhComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::TanhComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::Scale(float)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::TanhComponent::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::TanhComponent::Type()

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::NonlinearComponent::ZeroStats()

class kaldi.nnet3.TdnnComponent¶

CLIF wrapper for ::kaldi::nnet3::TdnnComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::TdnnComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::TdnnComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::TdnnComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::TdnnComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::TdnnComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::TdnnComponent::NumParameters()

orthonormal_constraint() → float¶: Calls C++ function float ::kaldi::nnet3::TdnnComponent::OrthonormalConstraint()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::TdnnComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::TdnnComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::TdnnComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::TdnnComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::TdnnComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::TdnnComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.TimeHeightConvolutionComponent¶

CLIF wrapper for ::kaldi::nnet3::TimeHeightConvolutionComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::Add(float, ::kaldi::nnet3::Component)

backprop(debug_info:str, indexes:ComponentPrecomputedIndexes, in_value:CuMatrixBase, out_value:CuMatrixBase, out_deriv:CuMatrixBase, memo:Memo, to_update:Component, in_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::Backprop(::std::string, ::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *, ::kaldi::nnet3::Component *, ::kaldi::CuMatrixBase<float> *)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::ConsolidateMemory()

copy() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::TimeHeightConvolutionComponent::Copy()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

dot_product(other:UpdatableComponent) → float¶: Calls C++ function float ::kaldi::nnet3::TimeHeightConvolutionComponent::DotProduct(::kaldi::nnet3::UpdatableComponent)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::FreezeNaturalGradient(bool)

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

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::UpdatableComponent::Info()

init_from_config(cfl:ConfigLine)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::InitFromConfig(::kaldi::nnet3::ConfigLine *)

input_dim() → int¶: Calls C++ function int ::kaldi::nnet3::TimeHeightConvolutionComponent::InputDim()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::TimeHeightConvolutionComponent::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::TimeHeightConvolutionComponent::NumParameters()

output_dim() → int¶: Calls C++ function int ::kaldi::nnet3::TimeHeightConvolutionComponent::OutputDim()

perturb_params(stddev:float)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::PerturbParams(float)

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::TimeHeightConvolutionComponent::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

propagate(indexes:ComponentPrecomputedIndexes, in:CuMatrixBase, out:CuMatrixBase) → Memo¶: Calls C++ function void * ::kaldi::nnet3::TimeHeightConvolutionComponent::Propagate(::kaldi::nnet3::ComponentPrecomputedIndexes *, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

properties() → int¶: Calls C++ function int ::kaldi::nnet3::TimeHeightConvolutionComponent::Properties()

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

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::Scale(float)

scale_linear_params(alpha:float)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::ScaleLinearParams(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

type() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::TimeHeightConvolutionComponent::Type()

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::TimeHeightConvolutionComponent::Vectorize(::kaldi::VectorBase<float> *)

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

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.UpdatableComponent¶

CLIF wrapper for ::kaldi::nnet3::UpdatableComponent

add(alpha:float, other:Component)¶: Calls C++ function void ::kaldi::nnet3::Component::Add(float, ::kaldi::nnet3::Component)

consolidate_memory()¶: Calls C++ function void ::kaldi::nnet3::Component::ConsolidateMemory()

delete_memo(memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::DeleteMemo(void *)

freeze_natural_gradient(freeze:bool)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::FreezeNaturalGradient(bool)

get_input_indexes(misc_info:MiscComputationInfo, output_index:Index) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::Component::GetInputIndexes(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::std::vector< ::kaldi::nnet3::Index>*)

info() → str¶: Calls C++ function ::std::string ::kaldi::nnet3::UpdatableComponent::Info()

is_computable(misc_info:MiscComputationInfo, output_index:Index, input_index_set:IndexSet) -> (ret:bool, used_inputs:list<Index>)¶: Calls C++ function bool ::kaldi::nnet3::Component::IsComputable(::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::Index, ::kaldi::nnet3::IndexSet, ::std::vector< ::kaldi::nnet3::Index>*)

l2_regularization() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::L2Regularization()

learning_rate() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRate()

learning_rate_factor() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::LearningRateFactor()

max_change() → float¶: Calls C++ function float ::kaldi::nnet3::UpdatableComponent::MaxChange()

new_component_of_type(type:str) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::NewComponentOfType(::std::string)

num_parameters() → int¶: Calls C++ function int ::kaldi::nnet3::UpdatableComponent::NumParameters()

precompute_indexes(misc_info:MiscComputationInfo, input_indexes:list<Index>, output_indexes:list<Index>, need_backprop:bool) → ComponentPrecomputedIndexes¶: Calls C++ function ::kaldi::nnet3::ComponentPrecomputedIndexes * ::kaldi::nnet3::Component::PrecomputeIndexes(::kaldi::nnet3::MiscComputationInfo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, bool)

read_new(is:istream, binary:bool) → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::Component::ReadNew(::std::basic_istream<char, ::std::char_traits<char> >, bool)

scale(scale:float)¶: Calls C++ function void ::kaldi::nnet3::Component::Scale(float)

set_actual_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetActualLearningRate(float)

set_as_gradient()¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetAsGradient()

set_l2_regularization(a:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetL2Regularization(float)

set_learning_rate_factor(lrate_factor:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetLearningRateFactor(float)

set_max_change(max_change:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetMaxChange(float)

set_underlying_learning_rate(lrate:float)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUnderlyingLearningRate(float)

set_updatable_configs(other:UpdatableComponent)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::SetUpdatableConfigs(::kaldi::nnet3::UpdatableComponent)

store_stats(in_value:CuMatrixBase, out_value:CuMatrixBase, memo:Memo)¶: Calls C++ function void ::kaldi::nnet3::Component::StoreStats(::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, void *)

unvectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::UnVectorize(::kaldi::VectorBase<float>)

vectorize(params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::UpdatableComponent::Vectorize(::kaldi::VectorBase<float> *)

zero_stats()¶: Calls C++ function void ::kaldi::nnet3::Component::ZeroStats()

class kaldi.nnet3.UtteranceSplitter¶

CLIF wrapper for ::kaldi::nnet3::UtteranceSplitter

config() → ExampleGenerationConfig¶: Calls C++ function ::kaldi::nnet3::ExampleGenerationConfig ::kaldi::nnet3::UtteranceSplitter::Config()

exit_status() → int¶: Calls C++ function int ::kaldi::nnet3::UtteranceSplitter::ExitStatus()

get_chunks_for_utterance(utterance_length:int) → list<ChunkTimeInfo>¶: Calls C++ function void ::kaldi::nnet3::UtteranceSplitter::GetChunksForUtterance(int, ::std::vector< ::kaldi::nnet3::ChunkTimeInfo>*)

lengths_match(utt:str, utterance_length:int, supervision_length:int, length_tolerance:int=default) → bool¶: Calls C++ function bool ::kaldi::nnet3::UtteranceSplitter::LengthsMatch(::std::string, int, int, int)

class kaldi.nnet3.VariableMergingOptimizer¶

CLIF wrapper for ::kaldi::nnet3::VariableMergingOptimizer

merge_variables() → bool¶: Calls C++ function bool ::kaldi::nnet3::VariableMergingOptimizer::MergeVariables()

kaldi.nnet3.add_nnet(src:Nnet, alpha:float, dest:Nnet)¶: Calls C++ function void ::kaldi::nnet3::AddNnet(::kaldi::nnet3::Nnet, float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.add_nnet_components(src:Nnet, alphas:Vector, scale:float, dest:Nnet)¶: Calls C++ function void ::kaldi::nnet3::AddNnetComponents(::kaldi::nnet3::Nnet, ::kaldi::Vector<float>, float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.append_cindexes(node:int, indexes:list<Index>) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::AppendCindexes(int, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Cindex>*)

kaldi.nnet3.append_input_frames(model:ConvolutionModel, io:ConvolutionComputationIo) -> (model_appended:ConvolutionModel, io_appended:ConvolutionComputationIo)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::AppendInputFrames(::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo , ::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo*)

kaldi.nnet3.apply_l2_regularization(nnet:Nnet, l2_regularize_scale:float, delta_nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ApplyL2Regularization(::kaldi::nnet3::Nnet, float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.apply_scales_to_input(alpha:float, A:CuMatrixBase, C:CuMatrixBase, B:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::attention::ApplyScalesToInput(float, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.apply_scales_to_output(alpha:float, B:CuMatrixBase, C:CuMatrixBase, A:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::attention::ApplyScalesToOutput(float, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.attention_backward(key_scale:float, keys:CuMatrixBase, queries:CuMatrixBase, values:CuMatrixBase, c:CuMatrixBase, output_deriv:CuMatrixBase, keys_deriv:CuMatrixBase, queries_deriv:CuMatrixBase, values_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::attention::AttentionBackward(float, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *, ::kaldi::CuMatrixBase<float> *, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.attention_forward(key_scale:float, keys:CuMatrixBase, queries:CuMatrixBase, values:CuMatrixBase, c:CuMatrixBase, output:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::attention::AttentionForward(float, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.check_computation(nnet:Nnet, computation:NnetComputation, check_rewrite:bool=default)¶: Calls C++ function void ::kaldi::nnet3::CheckComputation(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation, bool)

kaldi.nnet3.check_model_and_io(model:ConvolutionModel, io:ConvolutionComputationIo, allow_extra_input:bool=default)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::CheckModelAndIo(::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo, bool)

kaldi.nnet3.collapse_model(config:CollapseModelConfig, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::CollapseModel(::kaldi::nnet3::CollapseModelConfig, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.compile_convolution_computation(model:ConvolutionModel, input_indexes:list<Index>, output_indexes:list<Index>, opts:ConvolutionComputationOptions) -> (computation:ConvolutionComputation, input_indexes_modified:list<Index>, output_indexes_modified:list<Index>)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::CompileConvolutionComputation(::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationOptions, ::kaldi::nnet3::time_height_convolution::ConvolutionComputation*, ::std::vector< ::kaldi::nnet3::Index>*, ::std::vector< ::kaldi::nnet3::Index>*)

kaldi.nnet3.compile_looped(nnet:Nnet, optimize_opts:NnetOptimizeOptions, request1:ComputationRequest, request2:ComputationRequest, request3:ComputationRequest) → NnetComputation¶: Calls C++ function void ::kaldi::nnet3::CompileLooped(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetOptimizeOptions, ::kaldi::nnet3::ComputationRequest, ::kaldi::nnet3::ComputationRequest, ::kaldi::nnet3::ComputationRequest, ::kaldi::nnet3::NnetComputation*)

kaldi.nnet3.component_dot_products(nnet1:Nnet, nnet2:Nnet, dot_prod:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::ComponentDotProducts(::kaldi::nnet3::Nnet, ::kaldi::nnet3::Nnet, ::kaldi::VectorBase<float> *)

kaldi.nnet3.compute_command_attributes(nnet:Nnet, computation:NnetComputation, variables:ComputationVariables) → list<CommandAttributes>¶: Calls C++ function void ::kaldi::nnet3::ComputeCommandAttributes(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation, ::kaldi::nnet3::ComputationVariables, ::std::vector< ::kaldi::nnet3::CommandAttributes>*)

kaldi.nnet3.compute_computation_phases(nnet:Nnet, graph:ComputationGraph) → list<list<list<int>>>¶: Calls C++ function void ::kaldi::nnet3::ComputeComputationPhases(::kaldi::nnet3::Nnet, ::kaldi::nnet3::ComputationGraph, ::std::vector< ::std::vector< ::std::vector< ::int32> > >*)

kaldi.nnet3.compute_example_computation_request_simple(nnet:Nnet, request:ComputationRequest) → list<Matrix>¶: Calls C++ function void ::kaldi::nnet3::ComputeExampleComputationRequestSimple(::kaldi::nnet3::Nnet, ::kaldi::nnet3::ComputationRequest , ::std::vector< ::kaldi::Matrix< ::kaldi::BaseFloat> >)

kaldi.nnet3.compute_graph_transpose(graph:list<list<int>>) → list<list<int>>¶: Calls C++ function void ::kaldi::nnet3::ComputeGraphTranspose(::std::vector< ::std::vector< ::int32> >, ::std::vector< ::std::vector< ::int32> >*)

kaldi.nnet3.compute_matrix_accesses(nnet:Nnet, computation:NnetComputation, variables:ComputationVariables, command_attributes:list<CommandAttributes>) → list<MatrixAccesses>¶: Calls C++ function void ::kaldi::nnet3::ComputeMatrixAccesses(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation, ::kaldi::nnet3::ComputationVariables, ::std::vector< ::kaldi::nnet3::CommandAttributes>, ::std::vector< ::kaldi::nnet3::MatrixAccesses>*)

kaldi.nnet3.compute_matrix_to_submatrix(computation:NnetComputation) → list<list<int>>¶: Calls C++ function void ::kaldi::nnet3::ComputeMatrixToSubmatrix(::kaldi::nnet3::NnetComputation, ::std::vector< ::std::vector< ::int32> >*)

kaldi.nnet3.compute_nnet_computation_epochs(nnet:Nnet) → list<int>¶: Calls C++ function void ::kaldi::nnet3::ComputeNnetComputationEpochs(::kaldi::nnet3::Nnet, ::std::vector< ::int32>*)

kaldi.nnet3.compute_objective_function(supervision:GeneralMatrix, objective_type:ObjectiveType, output_name:str, supply_deriv:bool, computer:NnetComputer) -> (tot_weight:float, tot_objf:float)¶: Calls C++ function void ::kaldi::nnet3::ComputeObjectiveFunction(::kaldi::GeneralMatrix, ::kaldi::nnet3::ObjectiveType, ::std::string, bool, ::kaldi::nnet3::NnetComputer , float, float*)

kaldi.nnet3.compute_simple_nnet_context(nnet:Nnet) -> (left_context:int, right_context:int)¶: Calls C++ function void ::kaldi::nnet3::ComputeSimpleNnetContext(::kaldi::nnet3::Nnet, int*, int*)

kaldi.nnet3.compute_top_sort_order(graph:list<list<int>>) → list<int>¶: Calls C++ function void ::kaldi::nnet3::ComputeTopSortOrder(::std::vector< ::std::vector< ::int32> >, ::std::vector< ::int32>*)

kaldi.nnet3.compute_variable_accesses(variables:ComputationVariables, command_attributes:list<CommandAttributes>) → list<list<Access>>¶: Calls C++ function void ::kaldi::nnet3::ComputeVariableAccesses(::kaldi::nnet3::ComputationVariables, ::std::vector< ::kaldi::nnet3::CommandAttributes>, ::std::vector< ::std::vector< ::kaldi::nnet3::Access> >*)

kaldi.nnet3.consolidate_io_operations(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::ConsolidateIoOperations(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.consolidate_memory(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ConsolidateMemory(::kaldi::nnet3::Nnet *)

kaldi.nnet3.consolidate_model_update(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::ConsolidateModelUpdate(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.constrain_orthonormal(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ConstrainOrthonormal(::kaldi::nnet3::Nnet *)

kaldi.nnet3.convert_addition_to_assignment(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::ConvertAdditionToAssignment(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.convert_repeated_to_block_affine(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ConvertRepeatedToBlockAffine(::kaldi::nnet3::Nnet *)

kaldi.nnet3.convert_to_indexes(location_vector:list<tuple<int, int>>) -> (success:bool, first_value:int, second_values:list<int>)¶: Calls C++ function bool ::kaldi::nnet3::ConvertToIndexes(::std::vector< ::std::pair< ::int32, ::int32> >, int*, ::std::vector< ::int32>*)

kaldi.nnet3.convolve_backward_data(conv_comp:ConvolutionComputation, params:CuMatrixBase, output_deriv:CuMatrixBase, input_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::ConvolveBackwardData(::kaldi::nnet3::time_height_convolution::ConvolutionComputation, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.convolve_backward_params(conv_comp:ConvolutionComputation, input:CuMatrixBase, output_deriv:CuMatrixBase, alpha:float, params_deriv:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::ConvolveBackwardParams(::kaldi::nnet3::time_height_convolution::ConvolutionComputation, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, float, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.convolve_forward(conv_comp:ConvolutionComputation, input:CuMatrixBase, params:CuMatrixBase, output:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::ConvolveForward(::kaldi::nnet3::time_height_convolution::ConvolutionComputation, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.create_looped_computation_request(nnet:Nnet, chunk_size:int, frame_subsampling_factor:int, ivector_period:int, left_context_begin:int, right_context:int, num_sequences:int) -> (request1:ComputationRequest, request2:ComputationRequest, request3:ComputationRequest)¶: Calls C++ function void ::kaldi::nnet3::CreateLoopedComputationRequest(::kaldi::nnet3::Nnet, int, int, int, int, int, int, ::kaldi::nnet3::ComputationRequest*, ::kaldi::nnet3::ComputationRequest*, ::kaldi::nnet3::ComputationRequest*)

kaldi.nnet3.create_looped_computation_request_simple(nnet:Nnet, chunk_size:int, frame_subsampling_factor:int, ivector_period:int, extra_left_context_begin:int, extra_right_context:int, num_sequences:int) -> (request1:ComputationRequest, request2:ComputationRequest, request3:ComputationRequest)¶: Calls C++ function void ::kaldi::nnet3::CreateLoopedComputationRequestSimple(::kaldi::nnet3::Nnet, int, int, int, int, int, int, ::kaldi::nnet3::ComputationRequest*, ::kaldi::nnet3::ComputationRequest*, ::kaldi::nnet3::ComputationRequest*)

kaldi.nnet3.descriptor_tokenize(input:str) -> (suc:bool, tokens:list<str>)¶: Calls C++ function bool ::kaldi::nnet3::DescriptorTokenize(::std::string, ::std::vector< ::std::string>*)

kaldi.nnet3.dot_product(nnet1:Nnet, nnet2:Nnet) → float¶: Calls C++ function float ::kaldi::nnet3::DotProduct(::kaldi::nnet3::Nnet, ::kaldi::nnet3::Nnet)

kaldi.nnet3.ensure_contiguous_property(indexes:list<int>) → list<list<int>>¶: Calls C++ function void ::kaldi::nnet3::EnsureContiguousProperty(::std::vector< ::int32>, ::std::vector< ::std::vector< ::int32> >*)

kaldi.nnet3.error_context(str:str) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ErrorContext(::std::string)

kaldi.nnet3.error_context_from_stream(is:istream) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::ErrorContext(::std::basic_istream<char, ::std::char_traits<char> >)

kaldi.nnet3.evaluate_computation_request(nnet:Nnet, request:ComputationRequest) → list<list<bool>>¶: Calls C++ function void ::kaldi::nnet3::EvaluateComputationRequest(::kaldi::nnet3::Nnet, ::kaldi::nnet3::ComputationRequest, ::std::vector< ::std::vector<bool> >*)

kaldi.nnet3.example_approx_equal(eg1:NnetExample, eg2:NnetExample, delta:float) → bool¶: Calls C++ function bool ::kaldi::nnet3::ExampleApproxEqual(::kaldi::nnet3::NnetExample, ::kaldi::nnet3::NnetExample, float)

kaldi.nnet3.expand_computation(nnet:Nnet, misc_info:MiscComputationInfo, computation:NnetComputation, need_debug_info:bool, num_n_values:int) → NnetComputation¶: Calls C++ function void ::kaldi::nnet3::ExpandComputation(::kaldi::nnet3::Nnet, ::kaldi::nnet3::MiscComputationInfo, ::kaldi::nnet3::NnetComputation, bool, int, ::kaldi::nnet3::NnetComputation*)

kaldi.nnet3.extend_matrices(computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::ExtendMatrices(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.find_orphan_components(nnet:Nnet) → list<int>¶: Calls C++ function void ::kaldi::nnet3::FindOrphanComponents(::kaldi::nnet3::Nnet, ::std::vector< ::int32>*)

kaldi.nnet3.find_orphan_nodes(nnet:Nnet) → list<int>¶: Calls C++ function void ::kaldi::nnet3::FindOrphanNodes(::kaldi::nnet3::Nnet, ::std::vector< ::int32>*)

kaldi.nnet3.find_sccs(graph:list<list<int>>) → list<list<int>>¶: Calls C++ function void ::kaldi::nnet3::FindSccs(::std::vector< ::std::vector< ::int32> >, ::std::vector< ::std::vector< ::int32> >*)

kaldi.nnet3.fix_goto_label(computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::FixGotoLabel(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.freeze_natural_gradient(freeze:bool, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::FreezeNaturalGradient(bool, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.generate_config_sequence(opts:NnetGenerationOptions) → list<str>¶: Calls C++ function void ::kaldi::nnet3::GenerateConfigSequence(::kaldi::nnet3::NnetGenerationOptions, ::std::vector< ::std::string>*)

kaldi.nnet3.generate_config_sequence_composite_block(opts:NnetGenerationOptions) → list<str>¶: Calls C++ function void ::kaldi::nnet3::GenerateConfigSequenceCompositeBlock(::kaldi::nnet3::NnetGenerationOptions, ::std::vector< ::std::string>*)

kaldi.nnet3.generate_random_simple_component() → Component¶: Calls C++ function ::kaldi::nnet3::Component * ::kaldi::nnet3::GenerateRandomSimpleComponent()

kaldi.nnet3.generate_simple_nnet_training_example(num_supervised_frames:int, left_context:int, right_context:int, input_dim:int, output_dim:int, ivector_dim:int) → NnetExample¶: Calls C++ function void ::kaldi::nnet3::GenerateSimpleNnetTrainingExample(int, int, int, int, int, int, ::kaldi::nnet3::NnetExample*)

kaldi.nnet3.get_attention_dot_products(alpha:float, A:CuMatrixBase, B:CuMatrixBase, C:CuMatrixBase)¶: Calls C++ function void ::kaldi::nnet3::attention::GetAttentionDotProducts(float, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float>, ::kaldi::CuMatrixBase<float> *)

kaldi.nnet3.get_chain_computation_request(nnet:Nnet, eg:NnetChainExample, need_model_derivative:bool, store_component_stats:bool, use_xent_regularization:bool, use_xent_derivative:bool) → ComputationRequest¶: Calls C++ function void ::kaldi::nnet3::GetChainComputationRequest(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetChainExample, bool, bool, bool, bool, ::kaldi::nnet3::ComputationRequest*)

kaldi.nnet3.get_chunk_size(nnet:Nnet, frame_subsampling_factor:int, advised_chunk_size:int) → int¶: Calls C++ function int ::kaldi::nnet3::GetChunkSize(::kaldi::nnet3::Nnet, int, int)

kaldi.nnet3.get_commands_of_type(computation:NnetComputation, t:CommandType) → list<int>¶: Calls C++ function void ::kaldi::nnet3::GetCommandsOfType(::kaldi::nnet3::NnetComputation, ::kaldi::nnet3::CommandType, ::std::vector< ::int32>*)

kaldi.nnet3.get_computation_io(input_indexes:list<Index>, output_indexes:list<Index>) → ConvolutionComputationIo¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::GetComputationIo(::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo*)

kaldi.nnet3.get_computation_request(nnet:Nnet, eg:NnetExample, need_model_derivative:bool, store_component_stats:bool) → ComputationRequest¶: Calls C++ function void ::kaldi::nnet3::GetComputationRequest(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetExample, bool, bool, ::kaldi::nnet3::ComputationRequest*)

kaldi.nnet3.get_indexes_for_computation(io:ConvolutionComputationIo, orig_input_indexes:list<Index>, orig_output_indexes:list<Index>) -> (input_indexes:list<Index>, output_indexes:list<Index>)¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::GetIndexesForComputation(::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::kaldi::nnet3::Index>*, ::std::vector< ::kaldi::nnet3::Index>*)

kaldi.nnet3.get_max_memory_use(computation:NnetComputation) → int¶: Calls C++ function long ::kaldi::nnet3::GetMaxMemoryUse(::kaldi::nnet3::NnetComputation)

kaldi.nnet3.get_nnet_example_size(a:NnetExample) → int¶: Calls C++ function int ::kaldi::nnet3::GetNnetExampleSize(::kaldi::nnet3::NnetExample)

kaldi.nnet3.get_num_n_values(io_vec:list<NnetIo>, exhaustive:bool) → int¶: Calls C++ function int ::kaldi::nnet3::GetNumNvalues(::std::vector< ::kaldi::nnet3::NnetIo>, bool)

kaldi.nnet3.get_nx_list(indexes:list<Index>) → list<tuple<int, int>>¶: Calls C++ function void ::kaldi::nnet3::GetNxList(::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::std::pair< ::int32, ::int32> >*)

kaldi.nnet3.get_t_list(indexes:list<Index>) → list<int>¶: Calls C++ function void ::kaldi::nnet3::GetTList(::std::vector< ::kaldi::nnet3::Index>, ::std::vector< ::int32>*)

kaldi.nnet3.graph_has_cycles(graph:list<list<int>>) → bool¶: Calls C++ function bool ::kaldi::nnet3::GraphHasCycles(::std::vector< ::std::vector< ::int32> >)

kaldi.nnet3.has_batchnorm(nnet:Nnet) → bool¶: Calls C++ function bool ::kaldi::nnet3::HasBatchnorm(::kaldi::nnet3::Nnet)

kaldi.nnet3.has_contiguous_property(indexes:list<int>) -> (success:bool, reverse_indexes:list<tuple<int, int>>)¶: Calls C++ function bool ::kaldi::nnet3::HasContiguousProperty(::std::vector< ::int32>, ::std::vector< ::std::pair< ::int32, ::int32> >*)

kaldi.nnet3.identify_submatrix_args(command:NnetComputation.Command) → list<int>¶: Calls C++ function void ::kaldi::nnet3::IdentifySubmatrixArgs(::kaldi::nnet3::NnetComputation::Command , ::std::vector< ::int32 *>)

kaldi.nnet3.identify_submatrix_args_in_computation(computation:NnetComputation) → list<int>¶: Calls C++ function void ::kaldi::nnet3::IdentifySubmatrixArgsInComputation(::kaldi::nnet3::NnetComputation , ::std::vector< ::int32 *>)

kaldi.nnet3.is_simple_nnet(nnet:Nnet) → bool¶: Calls C++ function bool ::kaldi::nnet3::IsSimpleNnet(::kaldi::nnet3::Nnet)

kaldi.nnet3.is_valid_name(name:str) → bool¶: Calls C++ function bool ::kaldi::nnet3::IsValidName(::std::string)

kaldi.nnet3.limit_derivative_times(nnet:Nnet, min_deriv_time:int, max_deriv_time:int, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::LimitDerivativeTimes(::kaldi::nnet3::Nnet, int, int, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.make_computation(model:ConvolutionModel, io:ConvolutionComputationIo, opts:ConvolutionComputationOptions) → ConvolutionComputation¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::MakeComputation(::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationOptions, ::kaldi::nnet3::time_height_convolution::ConvolutionComputation*)

kaldi.nnet3.make_scc_graph(graph:list<list<int>>, sccs:list<list<int>>) → list<list<int>>¶: Calls C++ function void ::kaldi::nnet3::MakeSccGraph(::std::vector< ::std::vector< ::int32> >, ::std::vector< ::std::vector< ::int32> >, ::std::vector< ::std::vector< ::int32> >*)

kaldi.nnet3.matrix_is_unused(analyzer:Analyzer, computation:NnetComputation, m:int) → bool¶: Calls C++ function bool ::kaldi::nnet3::MatrixIsUnused(::kaldi::nnet3::Analyzer, ::kaldi::nnet3::NnetComputation, int)

kaldi.nnet3.max_output_time_in_request(request:ComputationRequest) → int¶: Calls C++ function int ::kaldi::nnet3::MaxOutputTimeInRequest(::kaldi::nnet3::ComputationRequest)

kaldi.nnet3.merge_chain_examples(compress:bool, input:list<NnetChainExample>) → NnetChainExample¶: Calls C++ function void ::kaldi::nnet3::MergeChainExamplesExt(bool, ::std::vector< ::kaldi::nnet3::NnetChainExample>, ::kaldi::nnet3::NnetChainExample*)

kaldi.nnet3.merge_examples(src:list<NnetExample>, compress:bool) → NnetExample¶: Calls C++ function void ::kaldi::nnet3::MergeExamples(::std::vector< ::kaldi::nnet3::NnetExample>, bool, ::kaldi::nnet3::NnetExample*)

kaldi.nnet3.modify_nnet_ivector_period(ivector_period:int, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ModifyNnetIvectorPeriod(int, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.move_sizing_commands(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::MoveSizingCommands(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.nnet_info(nnet:Nnet) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::NnetInfo(::kaldi::nnet3::Nnet)

kaldi.nnet3.nnet_is_recurrent(nnet:Nnet) → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetIsRecurrent(::kaldi::nnet3::Nnet)

kaldi.nnet3.nnet_parameters_are_identical(nnet1:Nnet, nnet2:Nnet, threshold:float) → bool¶: Calls C++ function bool ::kaldi::nnet3::NnetParametersAreIdentical(::kaldi::nnet3::Nnet, ::kaldi::nnet3::Nnet, float)

kaldi.nnet3.nnet_to_directed_graph(nnet:Nnet) → list<list<int>>¶: Calls C++ function void ::kaldi::nnet3::NnetToDirectedGraph(::kaldi::nnet3::Nnet, ::std::vector< ::std::vector< ::int32> >*)

kaldi.nnet3.num_input_nodes(nnet:Nnet) → int¶: Calls C++ function int ::kaldi::nnet3::NumInputNodes(::kaldi::nnet3::Nnet)

kaldi.nnet3.num_output_nodes(nnet:Nnet) → int¶: Calls C++ function int ::kaldi::nnet3::NumOutputNodes(::kaldi::nnet3::Nnet)

kaldi.nnet3.num_parameters(src:Nnet) → int¶: Calls C++ function int ::kaldi::nnet3::NumParameters(::kaldi::nnet3::Nnet)

kaldi.nnet3.num_updatable_components(dest:Nnet) → int¶: Calls C++ function int ::kaldi::nnet3::NumUpdatableComponents(::kaldi::nnet3::Nnet)

kaldi.nnet3.optimize(config:NnetOptimizeOptions, nnet:Nnet, max_output_time_in_request:int, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::Optimize(::kaldi::nnet3::NnetOptimizeOptions, ::kaldi::nnet3::Nnet, int, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.optimize_looped_computation(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::OptimizeLoopedComputation(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.optimize_memory_compression(nnet:Nnet, memory_compression_level:int, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::OptimizeMemoryCompression(::kaldi::nnet3::Nnet, int, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.pad_computation_input_time(model:ConvolutionModel) → ConvolutionComputationIo¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::PadComputationInputTime(::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionComputationIo*)

kaldi.nnet3.pad_model_height(model:ConvolutionModel) → ConvolutionModel¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::PadModelHeight(::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionModel*)

kaldi.nnet3.parse_config_lines(lines:list<str>) → list<ConfigLine>¶: Calls C++ function void ::kaldi::nnet3::ParseConfigLines(::std::vector< ::std::string>, ::std::vector< ::kaldi::nnet3::ConfigLine>*)

kaldi.nnet3.perturb_params(stddev:float, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::PerturbParams(float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.print_cindex(os:ostream, cindex:tuple<int, Index>, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::PrintCindex(::std::basic_ostream<char, ::std::char_traits<char> >, ::kaldi::nnet3::Cindex, ::std::vector< ::std::string>)

kaldi.nnet3.print_cindexes(os:ostream, cindexes:list<tuple<int, Index>>, node_names:list<str>)¶: Calls C++ function void ::kaldi::nnet3::PrintCindexes(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::kaldi::nnet3::Cindex>, ::std::vector< ::std::string>)

kaldi.nnet3.print_command_attributes(os:ostream, attributes:list<CommandAttributes>)¶: Calls C++ function void ::kaldi::nnet3::PrintCommandAttributes(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::kaldi::nnet3::CommandAttributes>)

kaldi.nnet3.print_graph_to_string(graph:list<list<int>>) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PrintGraphToString(::std::vector< ::std::vector< ::int32> >)

kaldi.nnet3.print_indexes(os:ostream, indexes:list<Index>)¶: Calls C++ function void ::kaldi::nnet3::PrintIndexes(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::kaldi::nnet3::Index>)

kaldi.nnet3.print_integer_vector(os:ostream, ints:list<int>)¶: Calls C++ function void ::kaldi::nnet3::PrintIntegerVector(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::int32>)

kaldi.nnet3.print_matrix_accesses(os:ostream, matrix_accesses:list<MatrixAccesses>)¶: Calls C++ function void ::kaldi::nnet3::PrintMatrixAccesses(::std::basic_ostream<char, ::std::char_traits<char> >, ::std::vector< ::kaldi::nnet3::MatrixAccesses>)

kaldi.nnet3.print_parameter_matrix_stats(os:ostringstream, name:str, params:CuMatrix, include_mean:bool=default, include_row_norms:bool=default, include_column_norms:bool=default, include_singular_values:bool=default)¶: Calls C++ function void ::kaldi::nnet3::PrintParameterStats(::std::basic_ostringstream<char, ::std::char_traits<char>, ::std::allocator<char> >, ::std::string, ::kaldi::CuMatrix<float>, bool, bool, bool, bool)

kaldi.nnet3.print_parameter_vector_stats(os:ostringstream, name:str, params:CuVectorBase, include_mean:bool=default)¶: Calls C++ function void ::kaldi::nnet3::PrintParameterStats(::std::basic_ostringstream<char, ::std::char_traits<char>, ::std::allocator<char> >, ::std::string, ::kaldi::CuVectorBase<float>, bool)

kaldi.nnet3.print_vector_per_updatable_component(nnet:Nnet, vec:VectorBase) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::PrintVectorPerUpdatableComponent(::kaldi::nnet3::Nnet, ::kaldi::VectorBase<float>)

kaldi.nnet3.read_cindex_vector(is:istream, binary:bool) → list<tuple<int, Index>>¶: Calls C++ function void ::kaldi::nnet3::ReadCindexVector(::std::basic_istream<char, ::std::char_traits<char> >, bool, ::std::vector< ::kaldi::nnet3::Cindex>*)

kaldi.nnet3.read_config_lines(is:istream) → list<str>¶: Calls C++ function void ::kaldi::nnet3::ReadConfigLines(::std::basic_istream<char, ::std::char_traits<char> >, ::std::vector< ::std::string>*)

kaldi.nnet3.read_edit_config(config_file:istream, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ReadEditConfig(::std::basic_istream<char, ::std::char_traits<char> >, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.read_index_vector(is:istream, binary:bool) → list<Index>¶: Calls C++ function void ::kaldi::nnet3::ReadIndexVector(::std::basic_istream<char, ::std::char_traits<char> >, bool, ::std::vector< ::kaldi::nnet3::Index>*)

kaldi.nnet3.read_vector_as_char(is:istream, binary:bool) → Vector¶: Calls C++ function void ::kaldi::nnet3::ReadVectorAsChar(::std::basic_istream<char, ::std::char_traits<char> >, bool, ::kaldi::Vector<float>*)

kaldi.nnet3.recompute_stats(egs:list<NnetChainExample>, chain_config:ChainTrainingOptions, den_fst:StdVectorFst, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::RecomputeStats(::std::vector< ::kaldi::nnet3::NnetChainExample>, ::kaldi::chain::ChainTrainingOptions, ::fst::VectorFst< ::fst::ArcTpl< ::fst::TropicalWeightTpl<float> >, ::fst::VectorState< ::fst::ArcTpl< ::fst::TropicalWeightTpl<float> >, ::std::allocator< ::fst::ArcTpl< ::fst::TropicalWeightTpl<float> > > > >, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.remove_commands_for_unused_matrix(analyzer:Analyzer, m:int, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::RemoveCommandsForUnusedMatrix(::kaldi::nnet3::Analyzer, int, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.remove_no_ops(computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::RemoveNoOps(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.remove_unnecessary_allocation(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::RemoveUnnecessaryAllocation(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.remove_unnecessary_zeroing(nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::RemoveUnnecessaryZeroing(::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.renumber_computation(computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::RenumberComputation(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.replace_row_with_matrix_ops(computation:NnetComputation) → bool¶: Calls C++ function bool ::kaldi::nnet3::ReplaceRowWithMatrixOps(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.request_is_decomposable(request:ComputationRequest) -> (suc:bool, mini_request:ComputationRequest, num_n_values:int)¶: Calls C++ function bool ::kaldi::nnet3::RequestIsDecomposable(::kaldi::nnet3::ComputationRequest, ::kaldi::nnet3::ComputationRequest*, int*)

kaldi.nnet3.reset_generators(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ResetGenerators(::kaldi::nnet3::Nnet *)

kaldi.nnet3.scale_batchnorm_stats(batchnorm_stats_scale:float, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ScaleBatchnormStats(float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.scale_nnet(scale:float, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ScaleNnet(float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.set_batchnorm_test_mode(test_mode:bool, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::SetBatchnormTestMode(bool, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.set_dropout_proportion(dropout_proportion:float, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::SetDropoutProportion(float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.set_dropout_test_mode(test_mode:bool, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::SetDropoutTestMode(bool, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.set_learning_rate(learning_rate:float, nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::SetLearningRate(float, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.set_nnet_as_gradient(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::SetNnetAsGradient(::kaldi::nnet3::Nnet *)

kaldi.nnet3.shift_chain_example_times(frame_shift:int, exclude_names:list<str>, eg:NnetChainExample)¶: Calls C++ function void ::kaldi::nnet3::ShiftChainExampleTimes(int, ::std::vector< ::std::string>, ::kaldi::nnet3::NnetChainExample *)

kaldi.nnet3.snip_row_ops(computation:NnetComputation) → bool¶: Calls C++ function bool ::kaldi::nnet3::SnipRowOps(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.split_locations(submat_lists:list<list<tuple<int, int>>>) → list<list<tuple<int, int>>>¶: Calls C++ function void ::kaldi::nnet3::SplitLocations(::std::vector< ::std::vector< ::std::pair< ::int32, ::int32> > >, ::std::vector< ::std::vector< ::std::pair< ::int32, ::int32> > >*)

kaldi.nnet3.split_locations_backward(submat_lists:list<list<tuple<int, int>>>) → list<list<tuple<int, int>>>¶: Calls C++ function void ::kaldi::nnet3::SplitLocationsBackward(::std::vector< ::std::vector< ::std::pair< ::int32, ::int32> > >, ::std::vector< ::std::vector< ::std::pair< ::int32, ::int32> > >*)

kaldi.nnet3.split_row_ops(computation:NnetComputation) → bool¶: Calls C++ function bool ::kaldi::nnet3::SplitRowOps(::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.summarize_cu_vector(vec:CuVectorBase) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SummarizeVector(::kaldi::CuVectorBase<float>)

kaldi.nnet3.summarize_double_vector(vec:DoubleVectorBase) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SummarizeVector(::kaldi::VectorBase<double>)

kaldi.nnet3.summarize_vector(vec:VectorBase) → str¶: Calls C++ function ::std::string ::kaldi::nnet3::SummarizeVector(::kaldi::VectorBase<float>)

kaldi.nnet3.un_pad_model_height(opts:ConvolutionComputationOptions, model:ConvolutionModel, model_padded:ConvolutionModel) → ConvolutionComputation¶: Calls C++ function void ::kaldi::nnet3::time_height_convolution::UnPadModelHeight(::kaldi::nnet3::time_height_convolution::ConvolutionComputationOptions, ::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionModel, ::kaldi::nnet3::time_height_convolution::ConvolutionComputation*)

kaldi.nnet3.un_vectorize_nnet(params:VectorBase, dest:Nnet)¶: Calls C++ function void ::kaldi::nnet3::UnVectorizeNnet(::kaldi::VectorBase<float>, ::kaldi::nnet3::Nnet *)

kaldi.nnet3.update_nnet_with_max_change(delta_nnet:Nnet, max_param_change:float, max_change_scale:float, scale:float, nnet:Nnet) -> (suc:bool, num_max_change_per_component_applied:list<int>, num_max_change_global_applied:int)¶: Calls C++ function bool ::kaldi::nnet3::UpdateNnetWithMaxChange(::kaldi::nnet3::Nnet, float, float, float, ::kaldi::nnet3::Nnet , ::std::vector< ::int32>, int*)

kaldi.nnet3.variable_merging_optimization(config:NnetOptimizeOptions, nnet:Nnet, computation:NnetComputation)¶: Calls C++ function void ::kaldi::nnet3::VariableMergingOptimization(::kaldi::nnet3::NnetOptimizeOptions, ::kaldi::nnet3::Nnet, ::kaldi::nnet3::NnetComputation *)

kaldi.nnet3.vectorize_nnet(src:Nnet, params:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::VectorizeNnet(::kaldi::nnet3::Nnet, ::kaldi::VectorBase<float> *)

kaldi.nnet3.write_cindex_vector(os:ostream, binary:bool, vec:list<tuple<int, Index>>)¶: Calls C++ function void ::kaldi::nnet3::WriteCindexVector(::std::basic_ostream<char, ::std::char_traits<char> >, bool, ::std::vector< ::kaldi::nnet3::Cindex>)

kaldi.nnet3.write_index_vector(os:ostream, binary:bool, vec:list<Index>)¶: Calls C++ function void ::kaldi::nnet3::WriteIndexVector(::std::basic_ostream<char, ::std::char_traits<char> >, bool, ::std::vector< ::kaldi::nnet3::Index>)

kaldi.nnet3.write_vector_as_char(os:ostream, binary:bool, vec:VectorBase)¶: Calls C++ function void ::kaldi::nnet3::WriteVectorAsChar(::std::basic_ostream<char, ::std::char_traits<char> >, bool, ::kaldi::VectorBase<float>)

kaldi.nnet3.zero_component_stats(nnet:Nnet)¶: Calls C++ function void ::kaldi::nnet3::ZeroComponentStats(::kaldi::nnet3::Nnet *)