def create_config(
cls,
crp,
feature_flow,
extra_config_estimate=None,
extra_post_config_estimate=None,
extra_config_normalization=None,
extra_post_config_normalization=None,
):
# estimate
config_estimate, post_config_estimate = rasr.build_config_from_mapping(
crp, {"corpus": "feature-statistics.corpus"})
config_estimate.feature_statistics.action = "estimate-covariance"
config_estimate.feature_statistics.covariance_estimator.file = (
"xml:covariance.matrix")
config_estimate.feature_statistics.covariance_estimator.shall_normalize = True
config_estimate.feature_statistics.covariance_estimator.feature_extraction.file = (
"feature.flow")
config_estimate.feature_statistics.covariance_estimator.output_precision = 20
feature_flow.apply_config(
"feature-statistics.covariance-estimator.feature-extraction",
config_estimate,
post_config_estimate,
)
config_estimate._update(extra_config_estimate)
post_config_estimate._update(extra_post_config_estimate)
# normalization
(
config_normalization,
post_config_normalization,
) = rasr.build_config_from_mapping(crp, {})
config_normalization.feature_statistics.action = (
"calculate-covariance-diagonal-normalization")
config_normalization.feature_statistics.covariance_diagonal_normalization.covariance_file = (
"xml:covariance.matrix")
config_normalization.feature_statistics.covariance_diagonal_normalization.normalization_file = (
"xml:normalization.matrix")
config_normalization.feature_statistics.covariance_diagonal_normalization.output_precision = (
20)
config_normalization._update(extra_config_normalization)
post_config_normalization._update(extra_post_config_normalization)
return (
config_estimate,
post_config_estimate,
config_normalization,
post_config_normalization,
)
def create_config(
cls,
crp,
extra_config,
extra_post_config,
encoding,
**kwargs,
):
config, post_config = rasr.build_config_from_mapping(
crp, {
"lexicon": "lm-util.lexicon",
"language_model": "lm-util.lm"
})
del (config.lm_util.lm.scale
) # scale not considered here, delete to remove ambiguity
assert config.lm_util.lm.type == "ARPA"
if post_config.lm_util.lm.image:
logging.warning(
"The LM image already exists, but a new one will be recreated."
)
config.lm_util.action = "load-lm"
config.lm_util.lm.image = "lm.image"
config.lm_util.encoding = encoding
config.lm_util.batch_size = 100
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
text_file,
encoding,
renormalize,
extra_config,
extra_post_config,
**kwargs,
):
config, post_config = rasr.build_config_from_mapping(
crp, {
"lexicon": "lm-util.lexicon",
"language_model": "lm-util.lm"
})
del (config.lm_util.lm.scale
) # scale not considered here, delete to remove ambiguity
config.lm_util.action = "compute-perplexity-from-text-file"
config.lm_util.file = text_file
config.lm_util.encoding = encoding
config.lm_util.batch_size = 100
config.lm_util.renormalize = renormalize
config.lm_util.score_file = "word.scores"
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
alignment,
num_classes,
buffer_size,
disregarded_classes,
class_label_file,
extra_rasr_config,
extra_rasr_post_config,
use_python_control,
**kwargs,
):
config, post_config = rasr.build_config_from_mapping(
crp,
{
"acoustic_model":
"neural-network-trainer.model-combination.acoustic-model",
"corpus": "neural-network-trainer.corpus",
"lexicon": "neural-network-trainer.model-combination.lexicon",
},
parallelize=(crp.concurrent == 1),
)
if use_python_control:
config.neural_network_trainer.action = "python-control"
config.neural_network_trainer.feature_extraction.file = "feature.flow"
config.neural_network_trainer.python_control_enabled = True
config.neural_network_trainer.python_control_loop_type = "iterate-corpus"
config.neural_network_trainer.extract_alignments = alignment is not None
config.neural_network_trainer.soft_alignments = False
else:
config.neural_network_trainer.action = "supervised-training"
config.neural_network_trainer.feature_extraction.file = "dummy.flow"
config.neural_network_trainer.aligning_feature_extractor.feature_extraction.file = (
"feature.flow")
config.neural_network_trainer.single_precision = True
config.neural_network_trainer.silence_weight = 1.0
config.neural_network_trainer.weighted_alignment = False
config.neural_network_trainer.class_labels.disregard_classes = (
disregarded_classes)
config.neural_network_trainer.class_labels.load_from_file = class_label_file
config.neural_network_trainer.class_labels.save_to_file = "class.labels"
config.neural_network_trainer.estimator = "steepest-descent"
config.neural_network_trainer.training_criterion = "cross-entropy"
config.neural_network_trainer.trainer_output_dimension = num_classes
config.neural_network_trainer.buffer_type = "utterance"
config.neural_network_trainer.buffer_size = buffer_size
config.neural_network_trainer.shuffle = False
config.neural_network_trainer.window_size = 1
config.neural_network_trainer.window_size_derivatives = 0
config.neural_network_trainer.regression_window_size = 5
config._update(extra_rasr_config)
post_config._update(extra_rasr_post_config)
return config, post_config
def create_config(cls, crp, feature_flow, alignment_options, word_boundaries,
label_scorer, align_node_options,
extra_config, extra_post_config, **kwargs):
"""
:param recipe.rasr.csp.CommonSprintParameters csp:
:param feature_flow:
:param rasr.FeatureScorer feature_scorer:
:param dict[str] alignment_options:
:param bool word_boundaries:
:param recipe.rasr.LabelScorer label_scorer:
:param dict[str] align_node_options:
:param extra_config:
:param extra_post_config:
:return: config, post_config
:rtype: (rasr.SprintConfig, rasr.SprintConfig)
"""
alignment_flow = cls.create_flow(feature_flow)
align_node = 'speech-label-alignment'
assert label_scorer is not None, 'need label scorer for label aligner'
# acoustic model + lexicon for the flow nodes
mapping = { 'corpus' : 'acoustic-model-trainer.corpus',
'lexicon' : [],
'acoustic_model': []
}
for node in alignment_flow.get_node_names_by_filter(align_node):
mapping['lexicon'] .append('acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.lexicon' % node)
mapping['acoustic_model'].append('acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.acoustic-model' % node)
config, post_config = rasr.build_config_from_mapping(crp, mapping, parallelize=True)
# alignment options for the flow nodes
alignopt = {}
if alignment_options is not None:
alignopt.update(alignment_options)
for node in alignment_flow.get_node_names_by_filter(align_node):
node_config = config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction[node]
# alignment node option
for k, v in align_node_options.items():
node_config[k] = v
# alinger search option
node_config.aligner = rasr.RasrConfig()
for k, v in alignopt.items():
node_config.aligner[k] = v
# scorer
label_scorer.apply_config('label-scorer', node_config, node_config)
alignment_flow.apply_config('acoustic-model-trainer.aligning-feature-extractor.feature-extraction', config, post_config)
config.action = 'dry'
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = 'alignment.flow'
post_config['*'].allow_overwrite = True
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_merge_config(cls, crp, extra_config_merge,
extra_post_config_merge, **kwargs):
config, post_config = rasr.build_config_from_mapping(crp, {})
config.acoustic_model_trainer.action = "combine-scatter-matrix-accumulators"
config._update(extra_config_merge)
post_config._update(extra_post_config_merge)
return config, post_config
def create_merge_config(cls, crp, estimator, extra_config,
extra_post_config, **kwargs):
config, post_config = rasr.build_config_from_mapping(crp, {})
config.acoustic_model_trainer.action = "combine-mixture-sets"
config.acoustic_model_trainer.mixture_set_trainer.estimator_type = estimator
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
old_mixtures,
feature_flow,
warping_map,
warping_factors,
split_first,
min_observation_weight,
extra_warping_args,
extra_config,
extra_post_config,
**kwargs,
):
label_flow = cls.create_flow(feature_flow, warping_map,
extra_warping_args)
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus":
"acoustic-model-trainer.corpus",
"acoustic_model":
"acoustic-model-trainer.mixture-set-trainer.acoustic-model",
},
parallelize=True,
)
config.acoustic_model_trainer.action = "accumulate-mixture-set-text-independent"
config.acoustic_model_trainer.labeling.feature_extraction.file = "label.flow"
config.acoustic_model_trainer.labeling.labels = warping_factors
config.acoustic_model_trainer.mixture_set_trainer.split_first = split_first
config.acoustic_model_trainer.mixture_set_trainer.old_mixture_set_file = (
old_mixtures)
config.acoustic_model_trainer.mixture_set_trainer.new_mixture_set_file = (
"am.acc.$(TASK)")
config.acoustic_model_trainer.mixture_set_trainer.covariance_tying = "none"
config.acoustic_model_trainer.mixture_set_trainer.force_covariance_tying = True
config.acoustic_model_trainer.mixture_set_trainer.minimum_observation_weight = (
min_observation_weight)
config.acoustic_model_trainer.mixture_set_trainer.splitter.minimum_mean_observation_weight = (
min_observation_weight)
config.acoustic_model_trainer.mixture_set_trainer.splitter.minimum_covariance_observation_weight = (
min_observation_weight)
label_flow.apply_config(
"acoustic-model-trainer.labeling.feature-extraction", config,
post_config)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls, crp, feature_flow, extra_config, extra_post_config, **kwargs
):
config, post_config = rasr.build_config_from_mapping(
crp, {"corpus": "extraction.corpus"}, parallelize=True
)
config.extraction.feature_extraction.file = "cluster.flow"
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_full_sum_loss_config(
self,
num_classes,
sprint_loss_config=None,
sprint_loss_post_config=None,
skip_segments=None,
**kwargs,
):
"""
:param num_classes:
:param sprint_loss_config:
:param sprint_loss_post_config:
:param skip_segments:
:param kwargs:
:return:
:rtype: (RasrConfig, RasrConfig)
"""
crp = self.crp["loss"]
mapping = {
"acoustic_model": "*.model-combination.acoustic-model",
"corpus": "*.corpus",
"lexicon": "*.model-combination.lexicon",
}
config, post_config = rasr.build_config_from_mapping(
crp, mapping, parallelize=(crp.concurrent == 1))
# concrete action in PythonControl called from RETURNN SprintErrorSignals.py derived from Loss/Layers
config.neural_network_trainer.action = "python-control"
config.neural_network_trainer.python_control_loop_type = "python-control-loop"
config.neural_network_trainer.extract_features = False
# allophone-state transducer
config["*"].transducer_builder_filter_out_invalid_allophones = True
config["*"].fix_allophone_context_at_word_boundaries = True
# Automaton manipulation (RASR): default CTC topology
config.neural_network_trainer.alignment_fsa_exporter.add_blank_transition = (
kwargs.get("add_blank_transition", True))
config.neural_network_trainer.alignment_fsa_exporter.allow_label_loop = (
kwargs.get("allow_label_loop", True))
# default blank replace silence
if kwargs.get("blank_label_index", None) is not None:
config.neural_network_trainer.alignment_fsa_exporter.blank_label_index = (
kwargs.get("blank_label_index", None))
# maybe not needed
config["*"].allow_for_silence_repetitions = False
config["*"].number_of_classes = num_classes
# config['*'].normalize_lemma_sequence_scores = True
config._update(sprint_loss_config)
post_config._update(sprint_loss_post_config)
return config, post_config
def create_dump_config(cls, crp, samples_flow, extra_dump_config,
extra_dump_post_config, **kwargs):
dump_flow = cls.create_dump_flow(crp, samples_flow)
config, post_config = rasr.build_config_from_mapping(
crp, {"corpus": "extraction.corpus"}, parallelize=True)
config.extraction.feature_extraction.file = "dump.flow"
config.extraction.feature_extraction["*"].allow_overwrite = True
dump_flow.apply_config("extraction.feature-extraction", config,
post_config)
config._update(extra_dump_config)
post_config._update(extra_dump_post_config)
return config, post_config
def create_config(cls, crp, extra_config, extra_post_config, **kwargs):
config, post_config = rasr.build_config_from_mapping(
crp,
{
"acoustic_model": "allophone-tool.acoustic-model",
"lexicon": "allophone-tool.lexicon",
},
parallelize=False,
)
config.allophone_tool.acoustic_model.allophones.store_to_file = "allophones"
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_accumulate_config(
cls,
crp,
alignment_flow,
extra_config_accumulate,
extra_post_config_accumulate,
**kwargs,
):
"""
:param rasr.crp.CommonRasrParameters crp:
:param rasr.flow.FlowNetwork alignment_flow:
:param rasr.config.RasrConfig extra_config_accumulate:
:param rasr.config.RasrConfig extra_post_config_accumulate:
:param kwargs:
:return:
:rtype: (rasr.config.RasrConfig, rasr.config.RasrConfig)
"""
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus":
"acoustic-model-trainer.corpus",
"lexicon":
"acoustic-model-trainer.cart-trainer.lexicon",
"acoustic_model":
"acoustic-model-trainer.cart-trainer.acoustic-model",
},
parallelize=True,
)
config.acoustic_model_trainer.action = "accumulate-cart-examples"
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"alignment.flow")
config.acoustic_model_trainer.cart_trainer.example_file = (
"cart.acc.xml.$(TASK).gz")
alignment_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
config._update(extra_config_accumulate)
post_config._update(extra_post_config_accumulate)
return config, post_config
def create_config(
cls,
crp,
old_mixtures,
feature_flow,
alignment,
split_first,
extra_config,
extra_post_config,
**kwargs,
):
alignment_flow = cls.create_flow(feature_flow, alignment)
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus":
"acoustic-model-trainer.corpus",
"lexicon":
"acoustic-model-trainer.mixture-set-trainer.lexicon",
"acoustic_model":
"acoustic-model-trainer.mixture-set-trainer.acoustic-model",
},
parallelize=True,
)
config.acoustic_model_trainer.action = "accumulate-mixture-set-text-dependent"
config.acoustic_model_trainer.mixture_set_trainer.split_first = split_first
config.acoustic_model_trainer.mixture_set_trainer.old_mixture_set_file = (
old_mixtures)
config.acoustic_model_trainer.mixture_set_trainer.new_mixture_set_file = (
"am.acc.$(TASK)")
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"alignment.flow")
alignment_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_estimate_config(cls, crp, extra_config_estimate,
extra_post_config_estimate, **kwargs):
config, post_config = rasr.build_config_from_mapping(crp, {})
config.acoustic_model_trainer.action = (
"estimate-scatter-matrices-from-accumulator")
config.acoustic_model_trainer.scatter_matrix_estimator.between_class_scatter_matrix_file = (
"between_class_scatter.matrix")
config.acoustic_model_trainer.scatter_matrix_estimator.within_class_scatter_matrix_file = (
"within_class_scatter.matrix")
config.acoustic_model_trainer.scatter_matrix_estimator.total_scatter_matrix_file = (
"total_scatter.matrix")
config.acoustic_model_trainer.scatter_matrix_estimator.shall_normalize = True
config.acoustic_model_trainer.scatter_matrix_estimator.output_precision = 20
config._update(extra_config_estimate)
post_config._update(extra_post_config_estimate)
return config, post_config
def create_config(
cls,
crp,
questions,
cart_examples,
variance_clipping,
generate_cluster_file,
extra_config,
extra_post_config,
**kwargs,
):
"""
:param rasr.crp.CommonRasrParameters crp:
:param Path|BasicCartQuestions|str questions:
:param Path cart_examples:
:param float variance_clipping:
:param bool generate_cluster_file:
:param rasr.config.RasrConfig extra_config:
:param rasr.config.RasrConfig extra_post_config:
"""
if not type(questions) == str and not tk.is_path(questions):
questions_path = "questions.xml"
else:
questions_path = questions
config, post_config = rasr.build_config_from_mapping(crp, {},
parallelize=False)
config.acoustic_model_trainer.action = "estimate-cart"
config.acoustic_model_trainer.cart_trainer.training_file = questions_path
config.acoustic_model_trainer.cart_trainer.example_file = cart_examples
config.acoustic_model_trainer.cart_trainer.decision_tree_file = (
"cart.tree.xml.gz")
if generate_cluster_file:
config.acoustic_model_trainer.cart_trainer.cluster_file = (
"cart.cluster.xml.gz")
config.acoustic_model_trainer.cart_trainer.log_likelihood_gain.variance_clipping = (
variance_clipping)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
feature_flow,
feature_scorer,
extra_config,
extra_post_config,
**kwargs,
):
"""
:param rasr.crp.CommonRasrParameters crp:
:param rasr.flow.FlowNetwork feature_flow:
:param rasr.feature_scorer.FeatureScorer feature_scorer:
:param rasr.config.RasrConfig|None extra_config:
:param rasr.config.RasrConfig|None extra_post_config:
:param kwargs:
:return:
:rtype (rasr.config.RasrConfig, rasr.config.RasrConfig)
"""
config, post_config = rasr.build_config_from_mapping(
crp, {"corpus": "acoustic-model-trainer.corpus"}, parallelize=True)
feature_scorer.apply_config(
"acoustic-model-trainer.average-feature-scorer-activation.mixture-set",
config,
post_config,
)
feature_flow.apply_config(
"acoustic-model-trainer.average-feature-scorer-activation.feature-extraction",
config,
post_config,
)
config.action = "calculate-average-feature-scorer-activation"
config.acoustic_model_trainer.average_feature_scorer_activation.feature_extraction.file = (
"feature.flow")
config.acoustic_model_trainer.average_feature_scorer_activation.output.channel = (
crp.default_log_channel)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(cls, crp, extra_config, extra_post_config, **kwargs):
config, post_config = rasr.build_config_from_mapping(
crp,
{
"acoustic_model": "allophone-tool.acoustic-model",
"lexicon": "allophone-tool.lexicon",
},
parallelize=False,
)
config.allophone_tool.dump_state_tying.channel = "state-tying-channel"
config.allophone_tool.channels.state_tying_channel.append = False
config.allophone_tool.channels.state_tying_channel.compressed = False
config.allophone_tool.channels.state_tying_channel.file = "state-tying"
config.allophone_tool.channels.state_tying_channel.unbuffered = False
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_merge_config(cls, crp, extra_config_merge,
extra_post_config_merge, **kwargs):
"""
:param rasr.crp.CommonRasrParameters crp:
:param rasr.config.RasrConfig extra_config_merge:
:param rasr.config.RasrConfig extra_post_config_merge:
:param kwargs:
:return:
:rtype: (rasr.config.RasrConfig, rasr.config.RasrConfig)
"""
config, post_config = rasr.build_config_from_mapping(crp, {})
config.acoustic_model_trainer.action = "merge-cart-examples"
config.acoustic_model_trainer.cart_trainer.merge_example_files = " ".join(
"cart.acc.xml.%d.gz" % i for i in range(1, crp.concurrent + 1))
config.acoustic_model_trainer.cart_trainer.example_file = "cart.sum.xml.gz"
config._update(extra_config_merge)
post_config._update(extra_post_config_merge)
return config, post_config
def create_config(
cls,
crp,
between_class_scatter_matrix,
within_class_scatter_matrix,
reduced_dimension,
eigenvalue_problem_config,
generalized_eigenvalue_problem_config,
extra_config,
extra_post_config,
):
config, post_config = rasr.build_config_from_mapping(crp, {})
config.acoustic_model_trainer.action = "estimate-lda"
config.acoustic_model_trainer.lda_estimator.reduced_dimesion = (
reduced_dimension # yes, reduced-dimesion is the correct config parameter
)
config.acoustic_model_trainer.lda_estimator.output_precision = 20
config.acoustic_model_trainer.lda_estimator.between_class_scatter_matrix_file = DelayedAdd(
"xml:", between_class_scatter_matrix)
config.acoustic_model_trainer.lda_estimator.within_class_scatter_matrix_file = (
DelayedAdd("xml:", within_class_scatter_matrix))
config.acoustic_model_trainer.lda_estimator.projector_matrix_file = (
"xml:lda.matrix")
config.acoustic_model_trainer.lda_estimator.results.channel = (
crp.default_log_channel)
config.acoustic_model_trainer.lda_estimator.generalized_eigenvalue_problem.condition_numbers.channel = (
crp.default_log_channel)
config.acoustic_model_trainer.lda_estimator.eigenvalue_problem = (
eigenvalue_problem_config)
config.acoustic_model_trainer.lda_estimator.generalized_eigenvalue_problem = (
generalized_eigenvalue_problem_config)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(cls, crp, extra_config, extra_post_config, **kwargs):
dump_flow = cls.create_flow(**kwargs)
mapping = {
"corpus": "acoustic-model-trainer.corpus",
"lexicon": [],
"acoustic_model": [],
}
# acoustic model + lexicon for the flow nodes
for node in dump_flow.get_node_names_by_filter(
"speech-alignment-dump"):
mapping["lexicon"].append(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.lexicon"
% node)
mapping["acoustic_model"].append(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.acoustic-model"
% node)
config, post_config = rasr.build_config_from_mapping(crp,
mapping,
parallelize=True)
config.acoustic_model_trainer.action = "dry"
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"dump.flow")
post_config["*"].allow_overwrite = True
dump_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_accumulate_config(
cls,
crp,
alignment_flow,
extra_config_accumulate,
extra_post_config_accumulate,
**kwargs,
):
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus":
"acoustic-model-trainer.corpus",
"lexicon":
"acoustic-model-trainer.scatter-matrices-estimator.lexicon",
"acoustic_model":
"acoustic-model-trainer.scatter-matrices-estimator.acoustic-model",
},
parallelize=True,
)
config.acoustic_model_trainer.action = (
"estimate-scatter-matrices-text-dependent")
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"alignment.flow")
config.acoustic_model_trainer.scatter_matrices_estimator.new_accumulator_file = (
"scatter.acc.$(TASK)")
alignment_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
config._update(extra_config_accumulate)
post_config._update(extra_post_config_accumulate)
return config, post_config
def create_convert_config(
cls,
crp,
timestamp_flow,
timestamp_port,
extra_convert_config,
extra_convert_post_config,
**kwargs,
):
convert_flow = cls.create_convert_flow(crp, timestamp_flow,
timestamp_port)
config, post_config = rasr.build_config_from_mapping(
crp, {"corpus": "extraction.corpus"}, parallelize=True)
config.extraction.feature_extraction.file = "convert.flow"
config.extraction.feature_extraction["*"].allow_overwrite = True
convert_flow.apply_config("extraction.feature-extraction", config,
post_config)
config._update(extra_convert_config)
post_config._update(extra_convert_post_config)
return config, post_config
def create_config(
cls,
crp,
feature_flow,
feature_scorer,
denominator_path,
mem,
alignment_options,
short_pauses,
extra_config,
extra_post_config,
**kwargs,
):
alignment_flow = cls.create_flow(feature_flow)
alignopt = {
"increase-pruning-until-no-score-difference": True,
"min-acoustic-pruning": 1000,
"max-acoustic-pruning": 512000,
"acoustic-pruning-increment-factor": 2,
"min-average-number-of-states": 12,
}
if alignment_options is not None:
alignopt.update(alignment_options)
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus":
"lattice-processor.corpus",
"lexicon": [
"lattice-processor.topology-reader.model-combination.lexicon",
"lattice-processor.rescoring.tdps.model-combination.lexicon",
"lattice-processor.rescoring.segmentwise-alignment.model-combination.lexicon",
],
"acoustic_model": [
"lattice-processor.rescoring.tdps.model-combination.acoustic-model",
"lattice-processor.rescoring.segmentwise-alignment.model-combination.acoustic-model",
],
},
parallelize=True,
)
# Define and name actions
config.lattice_processor.actions = "read,rescore,write"
config.lattice_processor.selections = (
"topology-reader,rescoring,accuracy-writer")
# Reader
config.lattice_processor.topology_reader.readers = "total"
config.lattice_processor.topology_reader.lattice_archive.path = denominator_path
# rescoring
config.lattice_processor.rescoring.share_acoustic_model = True
config.lattice_processor.rescoring.tdp_rescorers = "tdps"
config.lattice_processor.rescoring.distance_rescorers = "accuracy"
config.lattice_processor.rescoring.accuracy.spoken_source = "orthography"
# Parameters for Am::ClassicAcousticModel
for node in ["tdps", "segmentwise-alignment"]:
feature_scorer.apply_config(
"lattice-processor.rescoring.{}.model-combination.acoustic-model.mixture-set"
.format(node),
config,
post_config,
)
# rescoring aligner
config.lattice_processor.rescoring.segmentwise_alignment.port_name = "features"
config.lattice_processor.rescoring.segmentwise_alignment.alignment_cache.alignment_label_type = (
"emission-ids")
config.lattice_processor.rescoring.segmentwise_alignment.alignment_cache.path = (
"segmentwise-alignment.$(TASK)")
post_config.lattice_processor.rescoring.segmentwise_alignment.model_acceptor_cache.log.channel = (
"nil")
post_config.lattice_processor.rescoring.segmentwise_alignment.aligner.statistics.channel = (
"nil")
node = config.lattice_processor.rescoring.segmentwise_alignment.aligner
for k, v in alignopt.items():
node[k] = v
alignment_flow.apply_config(
"lattice-processor.rescoring.segmentwise-feature-extraction.feature-extraction",
config,
post_config,
)
config.lattice_processor.rescoring.segmentwise_feature_extraction.feature_extraction.file = (
"alignment.flow")
# writer
config.lattice_processor.accuracy_writer.lattice_archive.path = (
"accuracy.$(TASK)")
return config, post_config
def create_config(
cls,
crp,
feature_flow,
alignment,
feature_scorer,
omega,
filterbank_node,
extra_config,
extra_post_config,
**kwargs,
):
feature_flow = cls.create_flow(feature_flow, alignment, filterbank_node)
config, post_config = rasr.build_config_from_mapping(
crp,
{
"acoustic_model": "acoustic-model-trainer.feature-scorer.acoustic-model",
"corpus": "acoustic-model-trainer.corpus",
"lexicon": "acoustic-model-trainer.feature-scorer.lexicon",
},
parallelize=True,
)
config.action = "score-features"
post_config["*"].segment_map_channel.append = False
post_config["*"].segment_map_channel.compressed = False
post_config["*"].segment_map_channel.encoding = "UTF-8"
post_config["*"].segment_map_channel.file = "$(SCORE-LOGFILE)"
post_config["*"].segment_map_channel.unbuffered = False
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"feature_and_alignment.flow"
)
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.warping_alpha = (
"$(WARPING-FACTOR)"
)
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.warping_omega = (
omega
)
config.acoustic_model_trainer.feature_scorer.corpus_key.template = "<segment>"
post_config.acoustic_model_trainer.feature_scorer.output.channel = (
"segment-map-channel"
)
feature_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
feature_scorer.apply_config(
"acoustic-model-trainer.feature-scorer.acoustic-model.mixture-set",
config,
post_config,
)
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
raw_denominator_path,
numerator_path,
mem,
search_options,
extra_config,
extra_post_config,
**kwargs,
):
search_opts = {
"pruning-threshold": 15,
"pruning-threshold-relative": True
}
if search_options:
search_opts.update(search_options)
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus":
"lattice-processor.corpus",
"lexicon": [
"lattice-processor.lattice-reader.model-combination.lexicon",
"lattice-processor.merging.model-combination.lexicon",
],
"acoustic_model":
"lattice-processor.merging.acoustic-model",
"language_model": [
"lattice-processor.lattice-reader.lm",
"lattice-processor.merging.lm",
],
},
parallelize=True,
)
# Define and name actions
config.lattice_processor.actions = (
"read,linear-combination,prune,graph-error-rate,merge,write")
config.lattice_processor.selections = (
"lattice-reader,linear-combination,pruning,ger,merging,lattice-writer"
)
# Reader
config.lattice_processor.lattice_reader.readers = "acoustic,lm"
config.lattice_processor.lattice_reader.lattice_archive.path = (
raw_denominator_path)
# linear-combination
config["*"].LM_SCALE = crp.language_model_config.scale
config.lattice_processor.linear_combination.scales = [
"$[1.0/$(LM-SCALE)]"
] * 2
# pruning
config.lattice_processor.pruning.threshold = search_opts[
"pruning-threshold"]
config.lattice_processor.pruning.threshold_is_relative = search_opts[
"pruning-threshold-relative"]
# merging
config.lattice_processor.merging.fsa_prefix = "acoustic"
config.lattice_processor.merging.merge_only_if_spoken_not_in_lattice = True
config.lattice_processor.merging.numerator_lattice_archive.path = numerator_path
# graph error rate [needs no config]
# writer
config.lattice_processor.lattice_writer.lattice_archive.path = (
"denominator.$(TASK)")
# additional config
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
feature_flow,
feature_scorer,
search_parameters,
lm_lookahead,
lookahead_options,
mem,
model_combination_config,
model_combination_post_config,
extra_config,
extra_post_config,
**kwargs,
):
lm_gc = recognition.AdvancedTreeSearchLmImageAndGlobalCacheJob(
crp, feature_scorer, extra_config, extra_post_config)
lm_gc.rqmt["mem"] = mem
if search_parameters is None:
search_parameters = {}
default_search_parameters = {
"beam-pruning": 15,
"beam-pruning-limit": 100000,
"word-end-pruning": 0.5,
"word-end-pruning-limit": 10000,
}
default_search_parameters.update(search_parameters)
search_parameters = default_search_parameters
la_opts = {
"history_limit": 1,
"tree_cutoff": 30,
"minimum_representation": 1,
"cache_low": 2000,
"cache_high": 3000,
"laziness": 15,
}
if lookahead_options is not None:
la_opts.update(lookahead_options)
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus": "speech-recognizer.corpus",
"lexicon": "speech-recognizer.model-combination.lexicon",
"acoustic_model":
"speech-recognizer.model-combination.acoustic-model",
"language_model": "speech-recognizer.model-combination.lm",
},
parallelize=True,
)
# Parameters for Speech::Recognizer
config.speech_recognizer.search_type = "advanced-tree-search"
# Parameters for Speech::DataSource or Sparse::DataSource
config.speech_recognizer.feature_extraction.file = "feature.flow"
feature_flow.apply_config("speech-recognizer.feature-extraction",
config, post_config)
# Parameters for Am::ClassicAcousticModel
feature_scorer.apply_config(
"speech-recognizer.model-combination.acoustic-model.mixture-set",
config,
post_config,
)
# Parameters for Speech::Model combination (besides AM and LM parameters)
config.speech_recognizer.model_combination.pronunciation_scale = 3.0
config.speech_recognizer.model_combination._update(
model_combination_config)
post_config.speech_recognizer.model_combination._update(
model_combination_post_config)
# Search parameters
config.speech_recognizer.recognizer.create_lattice = True
config.speech_recognizer.store_lattices = True
config.speech_recognizer.recognizer.beam_pruning = search_parameters[
"beam-pruning"]
config.speech_recognizer.recognizer.beam_pruning_limit = search_parameters[
"beam-pruning-limit"]
config.speech_recognizer.recognizer.word_end_pruning = search_parameters[
"word-end-pruning"]
config.speech_recognizer.recognizer.word_end_pruning_limit = search_parameters[
"word-end-pruning-limit"]
config.speech_recognizer.recognizer.lm_lookahead = rasr.RasrConfig()
config.speech_recognizer.recognizer.lm_lookahead._value = lm_lookahead
config.speech_recognizer.recognizer.optimize_lattice = "simple"
if lm_lookahead:
config.speech_recognizer.recognizer.lm_lookahead_laziness = la_opts[
"laziness"]
config.speech_recognizer.recognizer.lm_lookahead.history_limit = la_opts[
"history_limit"]
config.speech_recognizer.recognizer.lm_lookahead.tree_cutoff = la_opts[
"tree_cutoff"]
config.speech_recognizer.recognizer.lm_lookahead.minimum_representation = (
la_opts["minimum_representation"])
post_config.speech_recognizer.recognizer.lm_lookahead.cache_size_low = (
la_opts["cache_low"])
post_config.speech_recognizer.recognizer.lm_lookahead.cache_size_high = (
la_opts["cache_high"])
post_config.speech_recognizer.global_cache.read_only = True
post_config.speech_recognizer.global_cache.file = lm_gc.out_global_cache
post_config.speech_recognizer.model_combination.lm.image = lm_gc.lm_image
# Lattice writer options
config.speech_recognizer.lattice_archive.path = "raw-denominator.$(TASK)"
post_config.speech_recognizer.lattice_archive.info = True
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
feature_flow,
feature_scorer,
alignment_options,
extra_config,
extra_post_config,
**kwargs,
):
alignment_flow = cls.create_flow(feature_flow)
alignopt = {
"increase-pruning-until-no-score-difference": True,
"min-acoustic-pruning": 500,
"max-acoustic-pruning": 10000,
"acoustic-pruning-increment-factor": 2,
}
if alignment_options is not None:
alignopt.update(alignment_options)
mapping = {
"corpus": "acoustic-model-trainer.corpus",
"lexicon": [],
"acoustic_model": [],
}
# acoustic model + lexicon for the flow nodes
for node in alignment_flow.get_node_names_by_filter(
"speech-alignment"):
mapping["lexicon"].append(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.lexicon"
% node)
mapping["acoustic_model"].append(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.acoustic-model"
% node)
config, post_config = rasr.build_config_from_mapping(crp,
mapping,
parallelize=True)
# alignment options for the flow nodes
for node in alignment_flow.get_node_names_by_filter(
"speech-alignment"):
node_config = config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction[
node]
node_config.aligner = rasr.RasrConfig()
for k, v in alignopt.items():
node_config.aligner[k] = v
feature_scorer.apply_config(
"model-combination.acoustic-model.mixture-set", node_config,
node_config)
node_config.store_lattices = True
node_config.lattice_archive.path = "numerator.$(TASK)"
alignment_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
config.action = "dry"
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"alignment.flow")
post_config["*"].allow_overwrite = True
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
feature_flow,
feature_scorer,
lattice_cache,
global_scale,
confidence_threshold,
weight_scale,
ref_alignment_path,
extra_config,
extra_post_config,
**kwargs,
):
alignment_flow = cls.create_flow(
feature_flow,
lattice_cache,
global_scale,
confidence_threshold,
weight_scale,
ref_alignment_path,
)
mapping = {
"corpus": "acoustic-model-trainer.corpus",
"lexicon": [],
"acoustic_model": [],
}
# acoustic model + lexicon for the flow nodes
for node_type in [
"model-combination",
"alignment-weights-by-tied-state-alignment-weights",
]:
for node in alignment_flow.get_node_names_by_filter(node_type):
mapping["lexicon"].append(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.lexicon"
% node)
mapping["acoustic_model"].append(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction.%s.model-combination.acoustic-model"
% node)
config, post_config = rasr.build_config_from_mapping(crp,
mapping,
parallelize=True)
for node_type in [
"model-combination",
"alignment-weights-by-tied-state-alignment-weights",
]:
for node in alignment_flow.get_node_names_by_filter(node_type):
node_config = config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction[
node]
node_post_config = post_config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction[
node]
feature_scorer.apply_config(
"model-combination.acoustic-model.mixture-set",
node_config,
node_post_config,
)
alignment_flow.apply_config(
"acoustic-model-trainer.aligning-feature-extractor.feature-extraction",
config,
post_config,
)
config.action = "dry"
config.acoustic_model_trainer.aligning_feature_extractor.feature_extraction.file = (
"alignment.flow")
post_config["*"].allow_overwrite = True
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
def create_config(
cls,
crp,
lattice_path,
pruning_threshold,
phone_coverage,
nonword_phones,
max_arcs_per_second,
max_arcs_per_segment,
output_format,
pronunciation_scale,
extra_config,
extra_post_config,
):
config, post_config = rasr.build_config_from_mapping(
crp,
{
"corpus": "flf-lattice-tool.corpus",
"lexicon": "flf-lattice-tool.lexicon",
},
parallelize=True,
)
config.flf_lattice_tool.network.initial_nodes = "segment"
config.flf_lattice_tool.network.segment.type = "speech-segment"
config.flf_lattice_tool.network.segment.links = (
"0->archive-reader:1 0->archive-writer:1"
)
config.flf_lattice_tool.network.archive_reader.type = "archive-reader"
config.flf_lattice_tool.network.archive_reader.format = "flf"
config.flf_lattice_tool.network.archive_reader.path = lattice_path
config.flf_lattice_tool.network.archive_reader.links = "0->prune:0"
config.flf_lattice_tool.network.prune.type = "prune-posterior"
config.flf_lattice_tool.network.prune.threshold = pruning_threshold
config.flf_lattice_tool.network.prune.nonword_phones = nonword_phones
config.flf_lattice_tool.network.prune.min_phone_coverage = phone_coverage
if max_arcs_per_second is not None:
config.flf_lattice_tool.network.prune.max_arcs_per_second = (
max_arcs_per_second
)
if max_arcs_per_segment is not None:
config.flf_lattice_tool.network.prune.max_arcs_per_segment = (
max_arcs_per_segment
)
config.flf_lattice_tool.network.prune.links = "apply-pruning"
config.flf_lattice_tool.network.apply_pruning.type = "copy"
config.flf_lattice_tool.network.apply_pruning.trim = True
config.flf_lattice_tool.network.apply_pruning.normalize = True
config.flf_lattice_tool.network.apply_pruning.info = True
config.flf_lattice_tool.network.apply_pruning.links = "archive-writer"
config.flf_lattice_tool.network.archive_writer.type = "archive-writer"
config.flf_lattice_tool.network.archive_writer.path = (
"pruned_lattice.cache.$(TASK)"
)
config.flf_lattice_tool.network.archive_writer.format = output_format
config.flf_lattice_tool.network.archive_writer.flf.partial.keys = "am lm"
config.flf_lattice_tool.network.archive_writer.flf.partial.add = False
config.flf_lattice_tool.network.archive_writer.links = "sink"
if output_format == "lattice-processor":
config.flf_lattice_tool.network.archive_writer.lattice_processor.pronunciation_scale = (
pronunciation_scale
)
config.flf_lattice_tool.network.sink.type = "sink"
config.flf_lattice_tool.network.sink.warn_on_empty_lattice = True
config.flf_lattice_tool.network.sink.error_on_empty_lattice = False
config._update(extra_config)
post_config._update(extra_post_config)
return config, post_config
