def add_overlay(self, origin, name):
"""
Creates an overlay (meaning e.g. a subset or other kind of modified version) of an existing corpus
:param str origin: name/corpus_key of the original common rasr parameters with associated alignments, features, etc
:param str name: name/corpus_key of the new overlay over the original
:return:
"""
self.crp[name] = rasr.CommonRasrParameters(base=self.crp[origin])
self.alignments[name] = {}
self.ctm_files[name] = {}
self.feature_caches[name] = copy.deepcopy(self.feature_caches[origin])
self.feature_bundles[name] = copy.deepcopy(
self.feature_bundles[origin])
self.feature_flows[name] = copy.deepcopy(self.feature_flows[origin])
self.feature_scorers[name] = copy.deepcopy(
self.feature_scorers[origin])
self.lattice_caches[name] = {}
self.lattice_bundles[name] = {}
self.mixtures[name] = {}
self.nn_configs[name] = {}
self.nn_models[name] = {}
self.normalization_matrices[name] = {}
self.jobs[name] = {}
def set_corpus(self, name, corpus, concurrent, segment_path=None):
"""
Initialize collections and crp for a new corpus
:param str name: will be the corpus_key
:param CorpusObject corpus:
:param int concurrent:
:param util.MultiOutputPath segment_path:
:return:
"""
self.crp[name] = rasr.CommonRasrParameters(base=self.crp["base"])
rasr.crp_set_corpus(self.crp[name], corpus)
self.crp[name].concurrent = concurrent
self.crp[name].segment_path = segment_path
self.alignments[name] = {}
self.ctm_files[name] = {}
self.feature_caches[name] = {}
self.feature_bundles[name] = {}
self.feature_flows[name] = {}
self.feature_scorers[name] = {}
self.lattice_caches[name] = {}
self.lattice_bundles[name] = {}
self.mixtures[name] = {}
self.nn_configs[name] = {}
self.nn_models[name] = {}
self.normalization_matrices[name] = {}
self.jobs[name] = {}
def __init__(self):
self.crp = {"base": rasr.CommonRasrParameters()}
rasr.crp_add_default_output(self.crp["base"])
self.default_mixture_scorer = rasr.DiagonalMaximumScorer
# collections which are a nested dict of corpus_key -> name -> some object / some container
# container can be list, tuple or dict
self.alignments = {} # type: Dict[str,Dict[str,Union[List[Any], Any]]]
# corpus_key -> alignment_name -> element or list of e.g. FlowAttributes with cache_mode containing caches and bundle
self.ctm_files = {}
self.feature_caches = {}
self.feature_bundles = {}
self.feature_flows = {}
self.feature_scorers = {}
self.lattice_caches = {}
self.lattice_bundles = {}
self.mixtures = {}
self.nn_configs = {}
self.nn_models = {}
self.allophone_files = {}
self.cart_questions = {}
self.normalization_matrices = {}
self.stm_files = {}
self.glm_files = {}
self.scorers = {}
self.scorer_args = {}
self.scorer_hyp_arg = {}
self.jobs = {"base": {}} # type: Dict[str,Dict[str,Job]]
def build_crp(
self,
am_args,
corpus_object,
concurrent,
segment_path,
lexicon_args,
cart_tree_path=None,
allophone_file=None,
lm_args=None,
):
"""
constructs and returns a CommonRasrParameters from the given settings and files
"""
crp = rasr.CommonRasrParameters()
rasr.crp_add_default_output(crp)
crp.acoustic_model_config = am.acoustic_model_config(**am_args)
rasr.crp_set_corpus(crp, corpus_object)
crp.concurrent = concurrent
crp.segment_path = segment_path
crp.lexicon_config = rasr.RasrConfig()
crp.lexicon_config.file = lexicon_args["filename"]
crp.lexicon_config.normalize_pronunciation = lexicon_args[
"normalize_pronunciation"]
if "add_from_lexicon" in lexicon_args:
crp.acoustic_model_config.allophones.add_from_lexicon = lexicon_args[
"add_from_lexicon"]
if "add_all" in lexicon_args:
crp.acoustic_model_config.allophones.add_all = lexicon_args[
"add_all"]
if cart_tree_path is not None:
crp.acoustic_model_config.state_tying.type = "cart"
crp.acoustic_model_config.state_tying.file = cart_tree_path
if lm_args is not None:
crp.language_model_config = rasr.RasrConfig()
crp.language_model_config.type = lm_args["type"]
crp.language_model_config.file = lm_args["filename"]
crp.language_model_config.scale = lm_args["scale"]
if allophone_file is not None:
crp.acoustic_model_config.allophones.add_from_file = allophone_file
self.crp = crp
def copy_from_system(self, origin_system, origin_name, target_name=None):
"""
Import the dictionaries from another System
:param System origin_system:
:param str origin_name: Name of the dataset in another system
:param str target_name: Name of the dataset in current system (optional) (default=origin_name)
:return:
"""
if not target_name:
target_name = origin_name
self.crp[target_name] = rasr.CommonRasrParameters(
base=origin_system.crp[origin_name])
self.alignments[target_name] = copy.deepcopy(
origin_system.alignments[origin_name])
self.ctm_files[target_name] = copy.deepcopy(
origin_system.ctm_files[origin_name])
self.feature_caches[target_name] = copy.deepcopy(
origin_system.feature_caches[origin_name])
self.feature_bundles[target_name] = copy.deepcopy(
origin_system.feature_bundles[origin_name])
self.feature_flows[target_name] = copy.deepcopy(
origin_system.feature_flows[origin_name])
self.feature_scorers[target_name] = copy.deepcopy(
origin_system.feature_scorers[origin_name])
self.lattice_caches[target_name] = copy.deepcopy(
origin_system.lattice_caches[origin_name])
self.lattice_bundles[target_name] = copy.deepcopy(
origin_system.lattice_bundles[origin_name])
self.mixtures[target_name] = copy.deepcopy(
origin_system.mixtures[origin_name])
self.nn_configs[target_name] = copy.deepcopy(
origin_system.nn_configs[origin_name])
self.nn_models[target_name] = copy.deepcopy(
origin_system.nn_models[origin_name])
# self.stm_files [target_name] = copy.deepcopy(origin_system.stm_files[origin_name])
self.normalization_matrices[target_name] = copy.deepcopy(
origin_system.normalization_matrices[origin_name])
self.jobs[target_name] = {}
def __init__(
self,
original_crp,
initial_flow,
context_flow,
alignment,
questions,
num_dim,
num_iter,
cart_sum_args=None,
cart_estimate_args=None,
lda_scatter_args=None,
lda_estimate_args=None,
eigenvalue_args=None,
generalized_eigenvalue_args=None,
):
cart_sum_args = {} if cart_sum_args is None else cart_sum_args
cart_estimate_args = {} if cart_estimate_args is None else cart_estimate_args
lda_scatter_args = {} if lda_scatter_args is None else lda_scatter_args
lda_estimate_args = {} if lda_estimate_args is None else lda_estimate_args
eigenvalue_args = {} if eigenvalue_args is None else eigenvalue_args
generalized_eigenvalue_args = ({}
if generalized_eigenvalue_args is None
else generalized_eigenvalue_args)
self.cart_sum_jobs = []
self.cart_estimate_jobs = []
self.lda_scatter_jobs = []
self.lda_estimate_jobs = []
self.last_lda_matrix = None
self.last_cart_tree = None
self.last_num_cart_labels = None
crp = rasr.CommonRasrParameters(base=original_crp)
crp.acoustic_model_config = original_crp.acoustic_model_config._copy()
for iteration in range(num_iter):
crp.acoustic_model_config.state_tying.type = "monophone"
del crp.acoustic_model_config.state_tying.file
temp_alignment_flow = mm.cached_alignment_flow(
initial_flow, alignment)
args = {"crp": crp, "alignment_flow": temp_alignment_flow}
args.update(select_args(cart_sum_args, iteration))
cart_sum = cart.AccumulateCartStatisticsJob(**args)
args = {
"crp": crp,
"questions": questions,
"cart_examples": cart_sum.out_cart_sum,
}
args.update(select_args(cart_estimate_args, iteration))
cart_estimate = cart.EstimateCartJob(**args)
crp.acoustic_model_config.state_tying.type = "cart"
crp.acoustic_model_config.state_tying.file = cart_estimate.out_cart_tree
temp_alignment_flow = mm.cached_alignment_flow(
context_flow, alignment)
args = {"crp": crp, "alignment_flow": temp_alignment_flow}
args.update(select_args(lda_scatter_args, iteration))
lda_scatter = lda.EstimateScatterMatricesJob(**args)
args = self.default_eigenvalue_params.copy()
args.update(select_args(eigenvalue_args, iteration))
eigenvalue_problem_config = lda.build_eigenvalue_problem_config(
**args)
args = self.default_generalized_eigenvalue_params.copy()
args.update(select_args(generalized_eigenvalue_args, iteration))
generalized_eigenvalue_problem_config = (
lda.build_generalized_eigenvalue_problem_config(**args))
args = {
"crp":
crp,
"between_class_scatter_matrix":
lda_scatter.between_class_scatter_matrix,
"within_class_scatter_matrix":
lda_scatter.within_class_scatter_matrix,
"reduced_dimension":
num_dim,
"eigenvalue_problem_config":
eigenvalue_problem_config,
"generalized_eigenvalue_problem_config":
generalized_eigenvalue_problem_config,
}
args.update(select_args(lda_estimate_args, iteration))
lda_estimate = lda.EstimateLDAMatrixJob(**args)
initial_flow = features.add_linear_transform(
context_flow, lda_estimate.lda_matrix)
self.cart_sum_jobs.append(cart_sum)
self.cart_estimate_jobs.append(cart_estimate)
self.lda_scatter_jobs.append(lda_scatter)
self.lda_estimate_jobs.append(lda_estimate)
self.last_cart_tree = cart_estimate.out_cart_tree
self.last_lda_matrix = lda_estimate.lda_matrix
self.last_num_cart_labels = cart_estimate.out_num_labels
def train_nn(
self,
name,
corpus_key,
feature_flow,
returnn_config,
num_classes,
use_hdf=False,
add_speaker_map=False,
**kwargs,
):
assert isinstance(
returnn_config, ReturnnConfig
), "Passing returnn_config as dict to train_nn is no longer supported, please construct a ReturnnConfig object instead"
corpus_key = self.train_corpora[0]
train_corpus_key = corpus_key + "_train"
cv_corpus_key = corpus_key + "_cv"
cv_size = 0.005
all_segments = SegmentCorpusJob(self.corpora[corpus_key].corpus_file,
1).out_single_segment_files[1]
new_segments = ShuffleAndSplitSegmentsJob(segment_file=all_segments,
split={
"train": 1.0 - cv_size,
"cv": cv_size
})
train_segments = new_segments.out_segments["train"]
cv_segments = new_segments.out_segments["cv"]
self.add_overlay(corpus_key, train_corpus_key)
self.crp[train_corpus_key].corpus_config = copy.deepcopy(
self.crp[train_corpus_key].corpus_config)
self.crp[train_corpus_key].corpus_config.segments.file = train_segments
self.crp[train_corpus_key].corpus_config.segment_order_shuffle = True
self.crp[
train_corpus_key].corpus_config.segment_order_sort_by_time_length = True
self.crp[
train_corpus_key].corpus_config.segment_order_sort_by_time_length_chunk_size = 384
self.add_overlay(corpus_key, cv_corpus_key)
self.crp[cv_corpus_key].corpus_config = copy.deepcopy(
self.crp[train_corpus_key].corpus_config)
self.crp[cv_corpus_key].corpus_config.segments.file = cv_segments
self.crp["loss"] = rasr.CommonRasrParameters(base=self.crp[corpus_key])
config, post_config = self.create_full_sum_loss_config(num_classes)
custom_config = None
if use_hdf:
from i6_core.returnn.hdf import ReturnnRasrDumpHDFJob
from i6_core.rasr.config import WriteRasrConfigJob
train_hdf_job = ReturnnRasrDumpHDFJob(
crp=self.crp[train_corpus_key],
feature_flow=self.feature_flows[corpus_key][feature_flow],
alignment=None,
num_classes=self.functor_value(num_classes))
cv_hdf_job = ReturnnRasrDumpHDFJob(
crp=self.crp[cv_corpus_key],
feature_flow=self.feature_flows[corpus_key][feature_flow],
alignment=None,
num_classes=self.functor_value(num_classes))
custom_config = WriteRasrConfigJob(config, post_config).out_config
returnn_config.config["train"] = {
"class":
"HDFDataset",
"files": [train_hdf_job.out_hdf],
"seq_ordering":
"laplace.1000",
"partition_epoch":
kwargs.pop("partition_epochs", {'train': 1})["train"],
"use_cache_manager":
True,
"cache_byte_size":
0,
}
returnn_config.config["dev"] = {
"class": "HDFDataset",
"files": [cv_hdf_job.out_hdf],
"seq_ordering": "sorted_reverse",
"use_cache_manager": True,
"cache_byte_size": 0,
}
def add_rasr_loss(network, custom_config=None):
network["rasr_loss"] = {
"class": "copy",
"from": "output",
"loss_opts": {
'tdp_scale':
0.0,
"sprint_opts":
self.create_rasr_loss_opts(custom_config=custom_config)
},
"loss": "fast_bw",
"target": None,
}
if returnn_config.staged_network_dict:
for net in returnn_config.staged_network_dict.values():
add_rasr_loss(net, custom_config=custom_config)
else:
if returnn_config.config['network']['output'].get(
"loss", None) != "fast_bw":
add_rasr_loss(returnn_config.config["network"],
custom_config=custom_config)
if add_speaker_map:
from i6_core.corpus.convert import CorpusToSpeakerMap
speaker_map = CorpusToSpeakerMap(
self.corpora[corpus_key].corpus_file).out_speaker_target_map
if "dev" not in returnn_config.config:
returnn_config.config["dev"] = {}
if "train" not in returnn_config.config:
returnn_config.config["train"] = {}
returnn_config.config["train"]["target_maps"] = {
'speaker_name': speaker_map
}
returnn_config.config["dev"]["target_maps"] = {
'speaker_name': speaker_map
}
if use_hdf:
kwargs.pop("alignment")
kwargs.pop("use_python_control")
j = ReturnnTrainingJob(
returnn_config=returnn_config,
**kwargs,
)
else:
j = ReturnnRasrTrainingJob(
train_crp=self.crp[train_corpus_key],
dev_crp=self.crp[cv_corpus_key],
feature_flow=self.feature_flows[corpus_key][feature_flow],
returnn_config=returnn_config,
num_classes=self.functor_value(num_classes),
additional_rasr_config_files={"rasr.loss": config},
additional_rasr_post_config_files={"rasr.loss": post_config},
**kwargs,
)
j.add_alias("train_nn_%s_%s" % (corpus_key, name))
self.jobs[corpus_key]["train_nn_%s" % name] = j
self.tf_checkpoints[name] = j.out_checkpoints
#self.nn_models[corpus_key][name] = j.out_models
self.nn_configs[corpus_key][name] = j.out_returnn_config_file
state_tying_job = DumpStateTyingJob(self.crp[corpus_key])
tk.register_output(
"{}_{}_state_tying".format(corpus_key, name),
state_tying_job.out_state_tying,
)
self.state_tying = state_tying_job.out_state_tying